solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, l, r;
int main() {
cin >> n;
for (; n--;) {
int x, y;
cin >> x >> y;
x > 0 ? r++ : l++;
}
puts(l <= 1 || r <= 1 ? "Yes" : "No");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
int rep = 1, max_rep = 0;
for (int i = 0; i < n; i++) {
if (i > 0 && ar[i] == ar[i - 1])
rep++;
else
rep = 1;
max_rep = max(max_rep, rep);
}
if (max_rep > 2) {
cout << "NO"
<< "\n";
return;
}
vector<int> a, b;
for (int i = 0; i < n; i++) {
if (i > 0 && ar[i] == ar[i - 1])
a.push_back(ar[i]);
else
b.push_back(ar[i]);
}
sort(a.begin(), a.end());
sort(b.rbegin(), b.rend());
cout << "YES"
<< "\n";
cout << a.size() << "\n";
for (auto &x : a) cout << x << " ";
cout << "\n" << b.size() << "\n";
for (auto &x : b) cout << x << " ";
cout << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long T = 1;
while (T--) solve();
return 0;
}
| 1 |
//#pragma GCC optimize ("O2")
//#pragma GCC optimize ("Ofast")
// <IN THE NAME OF GOD>
// this is mamad
#include <bits/stdc++.h>
using namespace std;
typedef pair <int64_t, int64_t> pii;
#define debug "ahhh shit\n"
template <typename Head>
inline void dout(Head in) {
cerr << in << '\n';
}
int main() {
ios::sync_with_stdio(false), cin.tie(NULL);
int n;
cin >> n;
vector <pii> v(n);
for (pii &e: v)
cin >> e.first >> e.second;
function <int64_t (pii, pii)> dis = [](pii P1, pii P2) {
return (P1.first - P2.first) * (P1.first - P2.first) + (P1.second - P2.second) * (P1.second - P2.second);
};
vector <bool> mark(n);
mark[0] = true;
vector <int> ans;
ans.emplace_back(0);
int prev = 0;
for (int i = 0; i < n - 1; i++) {
int idx = prev;
for (int j = 0; j < n; j++) {
if (dis(v[prev], v[idx]) < dis(v[prev], v[j]) and !mark[j]) {
idx = j;
}
}
mark[idx] = true;
ans.emplace_back(idx);
prev = idx;
}
for (int &e: ans)
e++;
for (int e: ans)
cout << e << ' ';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 10;
long long n, a, b, v[maxN];
vector<int> adjList[maxN];
pair<long long, long long> solve(int cur, int fr) {
pair<long long, long long> ret(0, 0);
for (int i = 0; i < adjList[cur].size(); ++i)
if (adjList[cur][i] != fr) {
pair<long long, long long> res = solve(adjList[cur][i], cur);
ret.first = min(ret.first, res.first);
ret.second = max(ret.second, res.second);
}
v[cur] += ret.first + ret.second;
if (v[cur] > 0)
ret.first -= v[cur];
else
ret.second -= v[cur];
return ret;
}
int main() {
scanf("%lld", &n);
for (int i = 0; i < n - 1; ++i) {
scanf("%lld", &a), scanf("%lld", &b);
adjList[a].push_back(b);
adjList[b].push_back(a);
}
for (int i = 0; i < n; ++i) scanf("%lld", &v[i + 1]);
pair<long long, long long> res = solve(1, -1);
printf("%lld\n", -res.first + res.second);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> start(m + 1);
vector<int> exam(m + 1);
vector<int> cost(m + 1);
vector<int> ans(n + 1);
for (int i = 1; i <= m; i++) cin >> start[i] >> exam[i] >> cost[i];
for (int day = 1; day <= n; day++) {
bool isExam = false;
for (int i = 1; i <= m; i++) {
if (exam[i] == day) isExam = true;
}
if (isExam) {
ans[day] = m + 1;
continue;
}
int prep = -1;
int g = INT_MAX;
for (int i = 1; i <= m; i++) {
if (start[i] <= day && exam[i] > day && cost[i] != 0) {
if ((exam[i] - day - cost[i]) < g) {
g = (exam[i] - day - cost[i]);
prep = i;
}
}
}
if (prep == -1)
ans[day] = 0;
else {
ans[day] = prep;
cost[prep]--;
}
}
bool iv = true;
for (int i = 1; i < cost.size(); i++) {
if (cost[i] != 0) {
iv = false;
break;
}
}
if (iv) {
for (int i = 1; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
} else
cout << "-1" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
static int r, sign;
static char c;
r = 0, sign = 1;
do c = getchar();
while (c != '-' && (c < '0' || c > '9'));
if (c == '-') sign = -1, c = getchar();
while (c >= '0' && c <= '9') r = r * 10 + (int)(c - '0'), c = getchar();
return sign * r;
}
template <typename T>
inline void print(T *a, int n) {
for (int i = 1; i < n; ++i) cout << a[i] << " ";
cout << a[n] << endl;
}
int n, k;
int calc(vector<int> a) {
int ret = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < i; ++j)
if (a[i] < a[j]) ++ret;
return ret;
}
double dfs(vector<int> a, int k) {
if (k == 0) return calc(a);
double ret = 0.0;
for (int l = 0; l < n; ++l)
for (int r = l; r < n; ++r) {
vector<int> b = a;
for (int i = l; i <= r; ++i) b[i] = a[r - (i - l)];
ret += dfs(b, k - 1) / (n * (n + 1) / 2);
}
return ret;
}
int main(int argc, char *argv[]) {
cin >> n >> k;
vector<int> a;
for (int i = 1, x; i <= n; ++i) {
cin >> x;
a.push_back(x);
}
double ans = dfs(a, k);
printf("%.12lf\n", ans);
fclose(stdin);
fclose(stdout);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
bool prime(long long n) {
if (n < 2) return false;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(NULL), cout.tie(NULL), cin.tie(NULL);
char arr[4][4];
int sz = 4;
for (int i = 0; i < sz; i++)
for (int j = 0; j < sz; j++) cin >> arr[i][j];
for (int i = 0; i < sz - 1; i++)
for (int j = 0; j < sz - 1; j++) {
int c = 0;
c += (arr[i][j] == '#') + (arr[i + 1][j + 1] == '#');
c += (arr[i][j + 1] == '#') + (arr[i + 1][j] == '#');
if (c != 2) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
long long solve(vector<vector<int>>& C, vector<pair<int, int>>& edges,
vector<int>& res) {
res.clear();
int n = C[0].size();
res.resize(n, -1);
vector<vector<int>> graph(n);
for (auto& e : edges) {
int u = e.first, v = e.second;
graph[u].push_back(v);
graph[v].push_back(u);
}
for (int i = 0; i < n; ++i) {
if (graph[i].size() > 2) {
return -1;
}
}
const long long INF = 1LL << 58;
int rt = -1;
for (int i = 0; i < n; ++i) {
if (graph[i].size() == 1) {
rt = i;
break;
}
}
vector<int> ord;
vector<int> pars(n, -1);
ord.push_back(rt);
for (int i = 0; i < ord.size(); ++i) {
int u = ord[i];
for (auto v : graph[u]) {
if (v == pars[u]) {
continue;
}
pars[v] = u;
ord.push_back(v);
}
}
pair<long long, vector<int>> best{INF, vector<int>(3, 0)};
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (i == j) {
continue;
}
vector<int> clr{i, j, 0 + 1 + 2 - j - i};
long long cost = 0;
for (int k = 0; k < n; ++k) {
cost += C[clr[k % 3]][ord[k]];
}
best = min(best, make_pair(cost, clr));
}
}
for (int i = 0; i < n; ++i) {
int u = ord[i];
res[u] = best.second[i % 3];
}
return best.first;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
Solution sol;
int n;
cin >> n;
vector<vector<int>> C(3, vector<int>(n, 0));
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < n; ++j) {
cin >> C[i][j];
}
}
vector<pair<int, int>> edges;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
edges.emplace_back(u, v);
}
vector<int> res;
auto ans = sol.solve(C, edges, res);
cout << ans << '\n';
if (ans >= 0) {
for (auto x : res) {
cout << x + 1 << ' ';
}
cout << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e4 + 9;
const int mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
deque<int> d;
multiset<int> ms;
int p = 0, mx = 0;
for (int i = 0; i < n; i++) {
bool ov = false;
while (1) {
mx = 0;
if (ms.size() > 0) mx = *ms.rbegin();
if (ms.size() > 2 * n) {
ov = true;
break;
}
if (a[p] * 2 >= mx)
d.push_back(a[p]), ms.insert(a[p]), p = (p + 1) % n;
else if (a[p] * 2 < mx)
break;
}
if (ov)
cout << "-1 ";
else
cout << ms.size() << " ";
int x = d.front();
d.pop_front();
ms.erase(ms.find(x));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MOD2 = (int)1e8 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
int sum(long long n) {
int res = 0;
while (n) {
res += n % 10;
n /= 10;
}
return res;
}
void solve() {
long long n, s;
cin >> n >> s;
long long l = 1, r = n + 1;
while (l < r) {
long long m = l + r >> 1;
if (m - sum(m) < s) {
l = m + 1;
} else {
r = m;
}
}
cout << n + 1 - (l + r) / 2 << "\n";
}
int main() {
int JUDGE_ONLINE = 1;
if (fopen("in.txt", "r")) {
JUDGE_ONLINE = 0;
assert(freopen("in.txt", "r", stdin));
} else {
ios_base::sync_with_stdio(0), cin.tie(0);
}
solve();
if (!JUDGE_ONLINE) {
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
if (2 * n <= s) {
cout << "YES\n";
for (int i = 0; i + 1 < n; ++i) cout << "2 ";
cout << s - 2 * (n - 1) << '\n';
cout << "1\n";
} else {
cout << "NO\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long x0, y0, ax, ay, bx, by, xs, ys, t;
cin >> x0 >> y0 >> ax >> ay >> bx >> by >> xs >> ys >> t;
long long x_d = x0, y_d = y0;
vector<pair<long long, long long> > data_points;
while (x_d <= xs + t and y_d <= ys + t) {
data_points.push_back(make_pair(x_d, y_d));
long long xn = x_d * ax + bx;
long long yn = y_d * ay + by;
x_d = xn;
y_d = yn;
}
auto Distance = [&](int i, int j) {
long long d = abs(data_points[i].first - xs) +
abs(data_points[i].second - ys) +
abs(data_points[i].first - data_points[j].first) +
abs(data_points[i].second - data_points[j].second);
return d;
};
int n = data_points.size();
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (Distance(i, j) <= t) {
ans = max(abs(j - i) + 1, ans);
}
}
}
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
int main() {
double n, vb, vs;
cin >> n >> vb >> vs;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
double x, y;
cin >> x >> y;
long long ans;
double dis, t = 1e9, dis1;
for (int i = 1; i < n; i++) {
dis = sqrt((y) * (y) + (x - a[i]) * (x - a[i]));
if (t > (double)(dis / vs) + (double)((a[i]) / vb)) {
t = (double)(dis / vs) + (double)((a[i]) / vb);
ans = i + 1;
dis1 = dis;
}
if (abs(t - ((double)(dis / vs) + (double)((a[i]) / vb))) <= 1e-9) {
if (dis1 > dis) {
ans = i + 1;
dis1 = dis;
}
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
double a, b;
scanf("%lf%lf", &a, &b);
double res = 0.0;
double tmp;
bool find = false;
int i = int(a / b - 1);
if (i % 2 == 1) i--;
if (i >= 2) {
tmp = (a - b) / (double)i;
if (tmp > 0) {
res = tmp;
find = true;
}
}
i = int(a / b);
if (i % 2 == 0) i--;
if (i >= 1) {
tmp = (a + b) / (double)(i + 1);
if (tmp > 0) {
if (find) {
res = tmp < res ? tmp : res;
} else {
res = tmp;
find = true;
}
}
}
if (find) {
printf("%.12lf\n", res);
} else {
printf("-1\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int btod(vector<int> &b) {
int t = 1;
int ans = 0;
for (int i = 0; i < b.size(); i++) {
ans += b[i] * t;
t *= 2;
}
return ans;
}
vector<int> dtob(int d) {
vector<int> b(10, 0);
for (int i = 0; i < 10; i++) {
b[i] = d % 2;
d = d / 2;
if (d == 0) break;
}
return b;
}
int main() {
scanf("%d", &n);
vector<int> zero(10, 0), one(10, 0);
vector<int> num(n, 0);
vector<int> op(n, 0);
string s;
for (int i = 0; i < n; i++) {
cin >> s;
if (s[0] == '|')
op[i] = 1;
else if (s[0] == '^')
op[i] = 2;
cin >> s;
num[i] = stoi(s);
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (op[i] == 0)
ans = ans & num[i];
else if (op[i] == 1)
ans = ans | num[i];
else
ans = ans ^ num[i];
}
zero = dtob(ans);
ans = 1023;
for (int i = 0; i < n; i++) {
if (op[i] == 0)
ans = ans & num[i];
else if (op[i] == 1)
ans = ans | num[i];
else
ans = ans ^ num[i];
}
one = dtob(ans);
vector<int> bits(10, 0), op2(10, 0);
vector<int> AND(10, 0), OR(10, 0), XOR(10, 0);
for (int i = 0; i < 10; i++) {
if (zero[i] == 0 && one[i] == 0) {
} else if (zero[i] == 1 && one[i] == 1) {
OR[i] = 1;
AND[i] = 1;
XOR[i] = 0;
} else if (zero[i] == 1 && one[i] == 0) {
AND[i] = 1;
XOR[i] = 1;
} else {
AND[i] = 1;
}
}
cout << 3 << endl;
cout << "| " << btod(OR) << endl;
cout << "& " << btod(AND) << endl;
cout << "^ " << btod(XOR) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int const inf = 1000 * 1000 * 1000;
long long const inf64 = 1ll * inf * inf;
int const N = 1e5 + 5;
int n, m;
int f[N];
int dist[N][3];
vector<int> g[N];
vector<int> rg[N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &f[i]);
}
for (int u, v, i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
g[u].push_back(v);
rg[v].push_back(u);
}
for (int t = 1; t <= 2; t++) {
queue<int> q;
for (int i = 1; i <= n; i++) {
if (f[i] == t) {
dist[i][t] = 0;
q.push(i);
} else {
dist[i][t] = inf;
}
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (int to : g[v]) {
if (dist[to][t] > dist[v][t] + 1) {
dist[to][t] = dist[v][t] + 1;
if (f[to] != 1) {
q.push(to);
}
}
}
}
for (int i = 1; i <= n; i++) {
g[i] = rg[i];
}
}
for (int i = 1; i <= n; i++) {
if (dist[i][1] != inf && dist[i][2] != inf) {
puts("1");
} else {
puts("0");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma G++ optimize("O3")
using namespace std;
const long long llINF = 9223372036854775807;
const int INF = 2147483647;
const int maxn = 2e5 + 7;
const int maxm = 2e4 + 7;
const int mod = 1e9 + 7;
const double pi = acos(-1.0);
const double eps = 1e-9;
int n;
int pic[11][11];
int dp[11][11][3][201][101];
int sx, sy, tx, ty;
int ans;
int d0[8][2] = {{-2, -1}, {-2, 1}, {2, -1}, {2, 1},
{-1, -2}, {-1, 2}, {1, -2}, {1, 2}};
int d1[4][2] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1}};
int d2[4][2] = {{-1, -1}, {-1, 1}, {1, -1}, {1, 1}};
struct node {
int x, y, id, change, num;
};
queue<node> Q;
bool check(int x, int y) { return x >= 1 && x <= n && y >= 1 && y <= n; }
void bfs() {
for (int id = 0; id < 3; id++) {
dp[sx][sy][id][0][1] = 0;
Q.push(node{sx, sy, id, 0, 1});
}
while (!Q.empty()) {
node now = Q.front();
Q.pop();
int x = now.x, y = now.y, id = now.id, change = now.change, num = now.num;
for (int i = 0; i < 3; i++) {
if (i == id) continue;
if (dp[x][y][i][change + 1][num] != -1) continue;
dp[x][y][i][change + 1][num] = dp[x][y][id][change][num] + 1;
Q.push(node{x, y, i, change + 1, num});
}
if (id == 0) {
for (int i = 0; i < 8; i++) {
int nxt_x = x + d0[i][0], nxt_y = y + d0[i][1], nxt_num = num;
if (check(nxt_x, nxt_y)) {
if (pic[nxt_x][nxt_y] == num + 1) nxt_num++;
if (dp[nxt_x][nxt_y][id][change][nxt_num] != -1) continue;
dp[nxt_x][nxt_y][id][change][nxt_num] = dp[x][y][id][change][num] + 1;
Q.push(node{nxt_x, nxt_y, id, change, nxt_num});
}
}
}
if (id == 1) {
for (int j = 1; j <= 10; j++) {
for (int i = 0; i < 4; i++) {
int nxt_x = x + j * d1[i][0], nxt_y = y + j * d1[i][1], nxt_num = num;
if (check(nxt_x, nxt_y)) {
if (pic[nxt_x][nxt_y] == num + 1) nxt_num++;
if (dp[nxt_x][nxt_y][id][change][nxt_num] != -1) continue;
dp[nxt_x][nxt_y][id][change][nxt_num] =
dp[x][y][id][change][num] + 1;
Q.push(node{nxt_x, nxt_y, id, change, nxt_num});
}
}
}
}
if (id == 2) {
for (int j = 1; j <= 10; j++) {
for (int i = 0; i < 4; i++) {
int nxt_x = x + j * d2[i][0], nxt_y = y + j * d2[i][1], nxt_num = num;
if (check(nxt_x, nxt_y)) {
if (pic[nxt_x][nxt_y] == num + 1) nxt_num++;
if (dp[nxt_x][nxt_y][id][change][nxt_num] != -1) continue;
dp[nxt_x][nxt_y][id][change][nxt_num] =
dp[x][y][id][change][num] + 1;
Q.push(node{nxt_x, nxt_y, id, change, nxt_num});
}
}
}
}
}
}
int main(int argc, char const *argv[]) {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
scanf("%d", &pic[i][j]);
if (pic[i][j] == 1) {
sx = i;
sy = j;
}
if (pic[i][j] == n * n) {
tx = i;
ty = j;
}
}
memset(dp, -1, sizeof(dp));
bfs();
ans = INF;
for (int id = 0; id < 3; id++)
for (int change = 0; change <= 200; change++)
if (dp[tx][ty][id][change][n * n] != -1)
ans = min(ans, dp[tx][ty][id][change][n * n]);
for (int change = 0; change <= 200; change++)
for (int id = 0; id < 3; id++)
if (dp[tx][ty][id][change][n * n] == ans) {
printf("%d %d\n", ans, change);
return 0;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
const int mod = 1e9 + 7;
const int logN = 17;
const int inf = 1e9;
const int N = 1e5 + 5;
int n, m, x, y, depth[N], mx[N][3], rmq[N][logN + 1], lca[N][logN + 1],
lp[N][logN + 1], start[N], finish[N], T;
int LOG[N], lp2[N][logN + 1];
vector<int> v[N];
int get(int x, int y) {
if (x > y) return 0;
int t = LOG[y - x + 1];
return max(rmq[x][t], rmq[y - (1 << t) + 1][t]);
}
int take(int x, int t) {
int ans = 0, y = x;
if (t <= 0) return 0;
for (int i = 0; i <= logN; i++)
if (t & (1 << i)) {
ans = max(ans, lp[x][i] + depth[y] - depth[x]);
x = lca[x][i];
}
return ans;
}
int take2(int x, int t) {
int ans = 0, tt = depth[x] - t;
if (t <= 0) return -inf;
for (int i = 0; i <= logN; i++)
if (t & (1 << i)) {
ans = max(ans, lp2[x][i] + (depth[x] - (1 << i)) - tt);
x = lca[x][i];
}
return ans;
}
int w1(int node, int x) {
if (node == x) return 0;
return max(get(start[node], start[x] - 1), get(finish[x] + 1, finish[node])) -
depth[node];
}
int w2(int node, int x, int y) {
if (node == x || node == y) return 0;
if (start[x] > start[y]) swap(x, y);
return max(get(start[node], start[x] - 1),
max(get(finish[x] + 1, start[y] - 1),
get(finish[y] + 1, finish[node]))) -
depth[node];
}
int calc(int x, int t) {
for (int i = 0; i <= logN; i++)
if (t & (1 << i)) x = lca[x][i];
return x;
}
int bef(int node, int x) { return calc(node, depth[node] - depth[x] - 1); }
int take_max(int node) {
int root = lca[node][0];
if (mx[root][1] == mx[node][1] + 1) return mx[root][2] + 1;
return mx[root][1] + 1;
}
int LCA(int x, int y) {
if (depth[x] < depth[y]) swap(x, y);
int diff = depth[x] - depth[y];
for (int i = 0; i <= logN; i++)
if (diff & (1 << i)) x = lca[x][i];
if (x == y) return x;
for (int i = logN; i >= 0; i--)
if (lca[x][i] != lca[y][i]) x = lca[x][i], y = lca[y][i];
return lca[x][0];
}
int solve(int x, int y) {
int l = LCA(x, y);
int dist = depth[x] + depth[y] - 2 * depth[l];
dist >>= 1;
if (depth[x] == depth[y] || (depth[x] + 1 == depth[y] && l != x)) {
int ans =
max(take(x, depth[x] - depth[l] - 1),
max(mx[x][1], w2(l, bef(x, l), bef(y, l)) + depth[x] - depth[l]));
ans = max(max(ans, take(l, depth[l]) + depth[x] - depth[l]),
max(mx[y][1], take(y, depth[y] - depth[l] - 1)));
return ans;
}
if (depth[x] - depth[l] > dist) {
int ans = max(take(x, dist), mx[x][1]), node = calc(x, dist);
int t = max(take2(node, depth[node] - depth[l] - 1) + 1,
max(take(l, depth[l]), w2(l, bef(x, l), bef(y, l)))) +
depth[y] - depth[l];
if (l != y)
ans = max(max(max(ans, take(y, depth[y] - depth[l] - 1)), mx[y][1]), t);
else
ans = max(max(w1(y, node), ans), take(y, depth[y]));
return ans;
}
return solve(y, x);
}
void dfs(int node, int root) {
lca[node][0] = root;
start[node] = ++T;
depth[node] = depth[root] + 1;
for (__typeof(v[node].begin()) it = v[node].begin(); it != v[node].end();
it++)
if (*it != root) {
int c = *it;
dfs(c, node);
if (mx[c][1] + 1 >= mx[node][1]) {
mx[node][2] = mx[node][1];
mx[node][1] = mx[c][1] + 1;
} else if (mx[c][1] + 1 > mx[node][2])
mx[node][2] = mx[c][1] + 1;
}
rmq[start[node]][0] = depth[node];
finish[node] = T;
}
int main() {
ios_base::sync_with_stdio(false);
for (int i = 1; i <= N - 1; i++) LOG[i] = log2(i);
cin >> n;
for (int i = 2; i <= n; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
depth[0] = -1;
dfs(1, 0);
for (int i = 2; i <= n; i++) {
lp[i][0] = take_max(i);
lp2[i][0] = lp[i][0] - 1;
}
for (int j = 1; j <= logN; j++)
for (int i = 1; i <= n; i++) {
lca[i][j] = lca[lca[i][j - 1]][j - 1];
lp[i][j] = max(lp[i][j - 1], lp[lca[i][j - 1]][j - 1] + (1 << j - 1));
lp2[i][j] = max(lp2[i][j - 1] + (1 << j - 1), lp2[lca[i][j - 1]][j - 1]);
rmq[i][j] = max(rmq[i][j - 1], rmq[min(n, i + (1 << j - 1))][j - 1]);
}
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
cout << solve(y, x) << '\n';
}
return 0;
}
| 10 |
/** @file
* @date 2021-01-14
* @url https://url.com
* @tags math, sorting
* @status AC
* @score 0
* @difficulty 0
* @editorial no
* @reading_time 000
* @thinking_time 000
* @coding_time 000
* @time_complexity O(n)
* @memory_complexity O(n)
* @idea
*
*
* @endidea
*/
#ifdef DBG_MACRO_NO_WARNING
#include <dbg.h>
#else
#define dbg(...) ((void)0)
#endif
#include <algorithm>
#include <cassert>
#include <vector>
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n)) x++;
return x;
}
int bsf(unsigned int n) {
#ifdef _MSC_VER
unsigned long index;
_BitScanForward(&index, n);
return index;
#else
return __builtin_ctz(n);
#endif
}
} // namespace internal
} // namespace atcoder
namespace atcoder {
template <class S, S (*op)(S, S), S (*e)()> struct segtree {
public:
segtree() : segtree(0) {}
segtree(int n) : segtree(std::vector<S>(n, e())) {}
segtree(const std::vector<S>& v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
for (int i = 0; i < _n; i++) d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
d[p] = x;
for (int i = 1; i <= log; i++) update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
return d[p + size];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
S sml = e(), smr = e();
l += size;
r += size;
while (l < r) {
if (l & 1) sml = op(sml, d[l++]);
if (r & 1) smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
template <bool (*f)(S)> int max_right(int l) {
return max_right(l, [](S x) { return f(x); });
}
template <class F> int max_right(int l, F f) {
assert(0 <= l && l <= _n);
assert(f(e()));
if (l == _n) return _n;
l += size;
S sm = e();
do {
while (l % 2 == 0) l >>= 1;
if (!f(op(sm, d[l]))) {
while (l < size) {
l = (2 * l);
if (f(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*f)(S)> int min_left(int r) {
return min_left(r, [](S x) { return f(x); });
}
template <class F> int min_left(int r, F f) {
assert(0 <= r && r <= _n);
assert(f(e()));
if (r == 0) return 0;
r += size;
S sm = e();
do {
r--;
while (r > 1 && (r % 2)) r >>= 1;
if (!f(op(d[r], sm))) {
while (r < size) {
r = (2 * r + 1);
if (f(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};
} // namespace atcoder
#include <bits/stdc++.h>
#define all(c) begin(c), end(c)
#define isz(c) (int)(c).size()
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using vi = vector<int>;
ll const INF = 1e15;
struct S
{
ll mn, mx, delta;
bool operator==(S other)
{
return mn == other.mn and mx == other.mx and delta == other.delta;
}
};
S op(S a, S b) { return {min(a.mn, b.mn), max(a.mx, b.mx), a.delta + b.delta}; }
S e() { return {INF, -INF, 0}; };
int main(void)
{
ios::sync_with_stdio(false), cin.tie(NULL);
int t;
cin >> t;
while (t--)
{
int n, m;
cin >> n >> m;
string s;
cin >> s;
using SegmentTree = atcoder::segtree<S, op, e>;
vector<S> a(n);
int cur = 0, delta;
for (int i = 0; i < n; ++i)
{
delta = (s[i] == '+' ? +1 : -1);
cur += delta;
a[i] = {cur, cur, delta};
}
SegmentTree st(a);
// auto print = [](S s) {
// cout << s.mn << " " << s.mx << " " << s.delta << endl;
// };
//
using pll = pair<ll, ll>;
auto intersect = [](pll a, pll b) {
if (a.first > b.first)
swap(a, b);
return a.second >= b.first;
};
while (m--)
{
int l, r;
cin >> l >> r, l--;
S left = st.prod(0, l), mid = st.prod(l, r), right = st.prod(r, n);
vector<pll> intervals;
if (!(left == e()))
intervals.emplace_back(left.mn, left.mx);
if (!(right == e()))
intervals.emplace_back(right.mn - mid.delta,
right.mx - mid.delta);
// dbg(intervals);
ll ans = 0;
if (none_of(all(intervals),
[](ii lr) { return lr.first <= 0 and 0 <= lr.second; }))
ans += 1;
if (intervals.size() >= 2 and intersect(intervals[0], intervals[1]))
{
intervals[0] = {min(intervals[0].first, intervals[1].first),
max(intervals[0].second, intervals[1].second)};
intervals.pop_back();
}
// dbg(intervals);
for (auto [ll, rr] : intervals)
ans += rr - ll + 1;
cout << ans << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node_qry {
int l, r, indx, bucket_indx;
long long res;
};
node_qry qry[200005];
long long a[200005], cnt[1000005], ans;
int bucket_size, n, q;
bool comp1(node_qry na, node_qry nb) {
if (na.bucket_indx == nb.bucket_indx) return (na.r < nb.r);
return (na.bucket_indx < nb.bucket_indx);
}
bool comp2(node_qry na, node_qry nb) { return (na.indx < nb.indx); }
void ADD(long long x) {
long long temp = cnt[x] * cnt[x];
temp *= x;
ans -= temp;
cnt[x]++;
temp = cnt[x] * cnt[x];
temp *= x;
ans += temp;
return;
}
void REMOVE(long long x) {
long long temp = cnt[x] * cnt[x];
temp *= x;
ans -= temp;
cnt[x]--;
temp = cnt[x] * cnt[x];
temp *= x;
ans += temp;
return;
}
void MO_s_algo() {
sort(qry, qry + q, comp1);
int l = qry[0].l, r = qry[0].r;
ans = 0;
for (int i = 0; i < q; i++) {
while (l < qry[i].l) {
REMOVE(a[l]);
l++;
}
while (l > qry[i].l) {
l--;
ADD(a[l]);
}
while (r < qry[i].r) {
r++;
ADD(a[r]);
}
while (r > qry[i].r) {
REMOVE(a[r]);
r--;
}
if (i == 0) {
for (int j = l; j <= r; j++) {
ADD(a[j]);
}
}
qry[i].res = ans;
}
sort(qry, qry + q, comp2);
return;
}
int main() {
int i;
scanf("%d %d", &n, &q);
for (i = 0; i < n; i++) scanf("%lld", &a[i]);
bucket_size = sqrt(n);
for (i = 0; i < q; i++) {
scanf("%d %d", &qry[i].l, &qry[i].r);
qry[i].l--;
qry[i].r--;
qry[i].indx = i;
qry[i].bucket_indx = (qry[i].l + 1) / bucket_size;
}
MO_s_algo();
for (i = 0; i < q; i++) printf("%lld\n", qry[i].res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (n % 2 == 0) {
for (int i = 0; i * 2 < n; i++) {
cout << "1";
}
cout << endl;
} else {
cout << "7";
for (int i = 1; i * 2 < n - 1; i++) {
cout << "1";
}
cout << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 1e18;
const long long minN = -1e18;
const long long MOD = 1e9 + 7;
const long long MOD1 = 998244353;
const int baseHash = 331;
const int bigNumLength = 5000;
const long double PI = acos(-1);
const long long limit = 2e5 + 5;
const long long limit1 = 1e6 + 5;
const long long limit2 = 1e3 + 5;
string s;
string s1, s2;
long long a[limit];
bool check[limit];
long long ans = maxN;
long long t2, t3, t, t1;
bool ok = false;
void process() {
t = t2, t1 = t3;
for (int i = (1); i <= (6); ++i) {
if (a[i] == 1) {
if (i <= 3 && ok)
t += 9 - s[i - 1] + '0';
else if (i > 3 && ok)
t1 -= s[i - 1] - '0';
if (i <= 3 && !ok)
t -= s[i - 1] - '0';
else if (i > 3 && !ok)
t1 += 9 - s[i - 1] + '0';
if ((t >= t1 && ok) || (t <= t1 && !ok)) {
ans = min(ans, 1LL);
return;
} else
for (int j = (1); j <= (6); ++j) {
if (a[j] == 2) {
if (j <= 3 && ok)
t += 9 - s[j - 1] + '0';
else if (j > 3 && ok)
t1 -= s[j - 1] - '0';
if (j <= 3 && !ok)
t -= s[j - 1] - '0';
else if (j > 3 && !ok)
t1 += 9 - s[j - 1] + '0';
if ((t >= t1 && ok) || (t <= t1 && !ok)) {
ans = min(ans, 2LL);
return;
} else
for (int k = (1); k <= (6); ++k) {
if (a[k] == 3) {
if (k <= 3 && ok)
t += 9 - s[k - 1] + '0';
else if (k > 3 && ok)
t1 -= s[k - 1] - '0';
if (k <= 3 && !ok)
t -= s[k - 1] - '0';
else if (k > 3 && !ok)
t1 += 9 - s[k - 1] + '0';
if ((t >= t1 && ok) || (t <= t1 && !ok)) {
ans = min(ans, 3LL);
return;
}
}
}
}
}
}
}
for (int i = (1); i <= (6); ++i) {
if (a[i] == 4) {
if (i <= 3 && ok)
t += 9 - s[i - 1] + '0';
else if (i > 3 && ok)
t1 -= s[i - 1] - '0';
if (i <= 3 && !ok)
t -= s[i - 1] - '0';
else if (i > 3 && !ok)
t1 += 9 - s[i - 1] + '0';
if ((t >= t1 && ok) || (t <= t1 && !ok)) {
ans = min(ans, 4LL);
return;
} else
for (int j = (1); j <= (6); ++j) {
if (a[j] == 5) {
if (j <= 3 && ok)
t += 9 - s[j - 1] + '0';
else if (j > 3 && ok)
t1 -= s[j - 1] - '0';
if (j <= 3 && !ok)
t -= s[j - 1] - '0';
else if (j > 3 && !ok)
t1 += 9 - s[j - 1] + '0';
if ((t >= t1 && ok) || (t <= t1 && !ok)) {
ans = min(ans, 5LL);
return;
} else
for (int k = (1); k <= (6); ++k) {
if (a[k] == 6) {
if (k <= 3 && ok)
t += 9 - s[k - 1] + '0';
else if (k > 3 && ok)
t1 -= s[k - 1] - '0';
if (k <= 3 && !ok)
t -= s[k - 1] - '0';
else if (k > 3 && !ok)
t1 += 9 - s[k - 1] + '0';
if ((t >= t1 && ok) || (t <= t1 && !ok)) {
ans = min(ans, 6LL);
return;
}
}
}
}
}
}
}
}
void backtrack(long long i) {
for (int j = (1); j <= (6); ++j) {
if (!check[j]) {
a[i] = j;
check[j] = true;
if (i == 6)
process();
else
backtrack(i + 1);
check[j] = false;
}
}
}
void solveProblem() {
t = s[0] - '0' + s[1] - '0' + s[2] - '0';
t1 = s[3] - '0' + s[4] - '0' + s[5] - '0';
s1 = "", s2 = "";
for (int i = (0); i < (3); ++i) s1 += s[i], s2 += s[i + 3];
if (t == t1) {
cout << 0 << '\n';
return;
}
if (t < t1) ok = true;
t2 = t, t3 = t1;
backtrack(1);
cout << ans << '\n';
}
void fastInput() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void readInput() { cin >> s; }
int main() {
fastInput();
readInput();
solveProblem();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[1000];
int x;
int main() {
scanf(" %d", &x);
while (!(x % 10)) x /= 10;
int n = 0;
while (x) s[++n] = x % 10, x /= 10;
for (int i = 1; i <= n; i++)
if (s[i] != s[n - i + 1]) {
printf("NO\n");
return 0;
}
printf("YES\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long cnt[200100][5], tot[200100], ans = 0;
int k, n;
vector<int> g[200100];
void dfs(int u, int p, int d) {
int dmodk, res;
tot[u] = cnt[u][d % k] = 1;
for (int i = 0; i < g[u].size(); i++) {
if (g[u][i] != p) {
dfs(g[u][i], u, d + 1);
for (int j = 0; j < k; j++) {
for (int l = 0; l < k; l++) {
dmodk = ((j + l - 2 * d) % k + k) % k;
res = (((k - dmodk) % k) + k) % k;
ans += 1ll * res * cnt[u][j] * cnt[g[u][i]][l];
}
}
for (int j = 0; j < k; j++) cnt[u][j] += cnt[g[u][i]][j];
tot[u] += tot[g[u][i]];
}
}
ans += tot[u] * (n - tot[u]);
}
int main() {
int i, u, v;
scanf("%d%d", &n, &k);
for (i = 0; i < n - 1; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0, 0);
printf("%I64d\n", ans / k);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int T, n, a[N];
int check() {
for (int k = 30; k >= 0; k--) {
int cnt0 = 0, cnt1 = 0;
for (int i = 1; i <= n; i++) {
if (a[i] & (1 << k))
cnt1++;
else
cnt0++;
}
if (!(cnt1 & 1)) continue;
if ((n & 1) && (cnt1 % 4 == 3)) return -1;
return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> T;
while (T--) {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int ans = check();
if (ans == 1)
cout << "WIN\n";
else if (ans == -1)
cout << "LOSE\n";
else
cout << "DRAW\n";
}
getchar();
getchar();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c;
string s;
int main() {
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'o')
b += a;
else if (s[i - 1] == 'v')
a++, c += b;
}
cout << c;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a, b, c, t;
cin >> n >> a >> b >> c >> t;
long long int ans = 0, k = 0;
for (int i = 0; i < n; i++) {
long long int x;
scanf("%lld", &x);
if (x == t) {
ans += a;
continue;
}
if (a - b + c > a)
ans += a + (t - x) * (c - b);
else
ans += a;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const int MAXN = 1e5 + 5;
const long long INF = 1e9;
struct maxFlow {
vector<pair<int, int> > e[MAXN];
vector<long long> cap[MAXN];
int level[MAXN];
int nxt[MAXN];
int s, t;
int N;
queue<int> q;
void init(int n) {
N = n;
for (int i = 0; i < N; i++) e[i].clear(), cap[i].clear();
}
void addEdge(int x, int y, long long cxy, long long cyx) {
e[x].push_back({y, cap[y].size()});
e[y].push_back({x, cap[x].size()});
cap[x].push_back(cxy);
cap[y].push_back(cyx);
}
bool bfs() {
while (!q.empty()) q.pop();
for (int i = 0; i < N; i++) level[i] = -1;
level[s] = 0;
q.push(s);
while (!q.empty()) {
int p = q.front();
q.pop();
if (p == t) return true;
for (int i = 0; i < (int)e[p].size(); i++) {
int x = e[p][i].first;
if (level[x] == -1 && cap[p][i] != 0) {
level[x] = level[p] + 1;
q.push(x);
}
}
}
return false;
}
long long augment(int x, long long c) {
if (x == t) return c;
for (int &i = nxt[x]; i < (int)e[x].size(); i++) {
int y = e[x][i].first;
if (cap[x][i] > 0 && level[y] == level[x] + 1) {
long long tempFlow = augment(y, min(c, cap[x][i]));
if (tempFlow > 0) {
cap[x][i] -= tempFlow;
cap[y][e[x][i].second] += tempFlow;
return tempFlow;
}
}
}
return 0;
}
long long solve(int source, int sink) {
s = source, t = sink;
long long ans = 0;
while (bfs()) {
long long flow = 0;
for (int i = 0; i < N; i++) nxt[i] = 0;
while (flow = augment(s, INF)) ans += flow;
}
return ans;
}
};
int nn, mm;
vector<int> dx = {-3, 0, 2, 2, -2, -2, 1, 1, -1, -1, 3, 0};
vector<int> dy = {0, -3, -1, 1, 1, -1, 2, -2, 2, -2, 0, 3};
int getId(int x, int y) { return (x * mm + y); }
bool isValid(int x, int y) { return (x >= 0 && y >= 0 && x < nn && y < mm); }
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
nn = n % 300, mm = m % 300;
maxFlow flowGraph;
flowGraph.init(nn * mm + 2);
int source = nn * mm, sink = source + 1;
for (int i = 0; i < nn; i++) {
for (int j = 0; j < mm; j++) {
if ((i + j) & 1) {
flowGraph.addEdge(source, getId(i, j), 2, 0);
for (int k = 0; k < 12; k++) {
int newX = i + dx[k], newY = j + dy[k];
if (isValid(newX, newY)) {
flowGraph.addEdge(getId(i, j), getId(newX, newY), INF, 0);
}
}
} else {
flowGraph.addEdge(getId(i, j), sink, 2, 0);
}
}
}
cout << n * m - (nn * mm - flowGraph.solve(source, sink));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400000;
int a[N], n, b[N];
long long mx = -100000000000000000ll, s[N];
long long get(long long l, long long r) {
if (l > r) return 0ll;
return s[r] - s[l - 1];
}
map<int, int> q;
int id = 0, k = 0, ans[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
s[i] = s[i - 1];
if (a[i] > 0) s[i] += a[i];
}
for (int i = n; i > 0; i--) {
if (!q[a[i]]) q[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
b[i] = q[a[i]];
}
for (int i = 1; i <= n; i++) {
if (i < b[i] && mx < get(i + 1, b[i] - 1) + a[i] + a[i]) {
mx = get(i + 1, b[i] - 1) + a[i] + a[i];
id = i;
}
}
for (int i = 1; i < id; i++) ans[++k] = i;
for (int i = b[id] + 1; i <= n; i++) ans[++k] = i;
for (int i = id + 1; i < b[id]; i++) {
if (a[i] < 0) ans[++k] = i;
}
cout << mx << " " << k << endl;
sort(ans + 1, ans + 1 + k);
for (int i = 1; i <= k; i++) cout << ans[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
const bool debug = false;
using namespace std;
long long powmod(long long a, long long b, long long MOD) {
long long res = 1;
a %= MOD;
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
void buginfo(const char* f, ...) {
if (!debug) return;
va_list al;
va_start(al, f);
vprintf(f, al);
va_end(al);
}
const int maxn = 2e5 + 10;
char s[maxn];
int n, t, dot, sp;
int main() {
scanf("%d%d%s", &n, &t, s + 1);
s[0] = '0';
while (dot < n + 1 && s[dot] != '.') ++dot;
sp = dot + 1;
while (sp < n + 1 && s[sp] < '5') ++sp;
while (sp > dot && t--) {
if (s[sp] < '5') break;
s[sp] = 0;
int pre = sp - 1;
while (pre >= 0) {
if (s[pre] == '.') {
--pre;
continue;
}
if (s[pre] == '9') {
s[pre] = '0';
--pre;
continue;
} else {
++s[pre];
break;
}
}
sp = pre;
}
int q = dot - 1;
while (q >= 0 && !s[q]) s[q--] = '0';
if (s[dot + 1] == 0) s[dot] = 0;
if (s[0] != '0')
printf("%s\n", s);
else
printf("%s\n", s + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class C_ {};
template <typename T>
C_& operator<<(C_& __m, const T& __s) {
if (!1) cerr << "\E[91m" << __s << "\E[0m";
return __m;
}
C_ merr;
struct __s {
__s() {
if (1) {
ios_base::Init i;
cin.sync_with_stdio(0);
cin.tie(0);
}
}
~__s() {
merr << "Execution time: " << (double)clock() / CLOCKS_PER_SEC << " s.\n";
}
} __S;
bool E[1111111];
unsigned long long P[411111];
unsigned long long lp[1111111];
unsigned long long plen;
void eratosphen() {
E[0] = E[1] = 1;
for (unsigned long long i = 0; i < 1111111; i++) {
if (E[i]) continue;
for (unsigned long long j = i * i; j < 1111111; j += i) {
E[j] = 1;
lp[j] = i;
}
P[plen++] = i;
lp[i] = i;
}
}
unsigned long long A[555555];
int main(void) {
eratosphen();
unsigned long long n, x, y;
merr << "Done" << '\n';
cin >> n >> x >> y;
for (unsigned long long i = 0; i < n; i++) {
cin >> A[i];
}
merr << "Execution time: " << (double)clock() / CLOCKS_PER_SEC << " s.\n";
set<unsigned long long> tocheck{2, 3, 5};
map<unsigned long long, unsigned long long> mp;
for (unsigned long long i = 0; i < n; i++) {
unsigned long long nn = A[i];
while (lp[nn] != 0) {
unsigned long long p = lp[nn];
tocheck.insert(p);
mp[p]++;
nn /= p;
}
}
merr << "Execution time: " << (double)clock() / CLOCKS_PER_SEC << " s.\n";
vector<pair<unsigned long long, unsigned long long>> V;
for (auto p : mp) {
V.push_back({p.second, p.first});
}
merr << "Execution time: " << (double)clock() / CLOCKS_PER_SEC << " s.\n";
sort(V.begin(), V.end(),
greater<pair<unsigned long long, unsigned long long>>());
merr << "Execution time: " << (double)clock() / CLOCKS_PER_SEC << " s.\n";
set<unsigned long long> S{2, 3, 5, 7, 11, 13};
for (unsigned long long i = 0; i < 2 && i < V.size(); i++) {
S.insert(V[i].second);
}
merr << "Execution time: " << (double)clock() / CLOCKS_PER_SEC << " s.\n";
for (auto p : tocheck) {
S.insert(p);
if (S.size() > 15) break;
}
merr << "Execution time: " << (double)clock() / CLOCKS_PER_SEC << " s.\n";
unsigned long long ans = min(x * n, y * n);
tocheck = S;
merr << tocheck.size() << '\n';
unsigned long long idx = 0;
for (auto p : tocheck) {
unsigned long long res = 0;
for (unsigned long long i = 0; i < n && res < ans; i++) {
unsigned long long xx = A[i];
res += min(x, ((p - xx % p) % p) * y);
}
if (res < ans) {
ans = res;
}
idx++;
if (idx > 15) break;
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 10;
int r, c, n, k, p[N], q[N];
pair<int, int> a[N];
vector<pair<int, int> > R[N], C[N];
long long ans, sum, cnt[N];
int main() {
cin >> r >> c >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
R[a[i].first].push_back(make_pair(a[i].second, i));
C[a[i].second].push_back(make_pair(a[i].first, i));
}
for (int i = 1; i <= r; i++) sort(R[i].begin(), R[i].end());
for (int i = 1; i <= c; i++) sort(C[i].begin(), C[i].end());
for (int u = 1; u <= r; u++) {
for (int i = 0; i <= n + 1; i++) p[i] = q[i] = cnt[i] = 0;
int o = 0;
long long t = 0;
sum = 0;
for (int i = 1; i <= c; i++) {
for (auto j : C[i])
if (j.first >= u) p[j.second] = o, q[o] = j.second, o = q[o];
int j = o;
for (int m = 1; m < k; m++) j = p[j];
if (j) cnt[j]++, sum += a[j].second;
}
q[o] = n + 1, p[n + 1] = o;
for (int d = r; d >= u; d--) {
ans += sum;
for (auto i : R[d]) {
o = i.second;
t = cnt[o];
sum -= cnt[o] * a[o].second;
for (int m = 1; m <= k; m++) {
o = p[o];
if (!o) break;
if (m < k)
sum += (t - cnt[o]) * a[o].second, swap(t, cnt[o]);
else
sum += t * a[o].second, cnt[o] += t;
}
int o1 = p[i.second], o2 = q[i.second];
q[o1] = o2, p[o2] = o1;
}
}
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long mod = pow(10, 9) + 7;
int gcdExtended(int a, int b, int *x, int *y);
int modInverse(int b, int m) {
int x, y;
int g = gcdExtended(b, m, &x, &y);
if (g != 1) return -1;
return (x % m + m) % m;
}
int gcdExtended(int a, int b, int *x, int *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
int x1, y1;
int gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
string decimalToBinary(int n) {
string s = bitset<64>(n).to_string();
const auto loc1 = s.find('1');
if (loc1 != string::npos) return s.substr(loc1);
return "0";
}
int binaryToDecimal(string n) {
string num = n;
int dec_value = 0;
int base = 1;
int len = num.length();
for (int i = len - 1; i >= 0; i--) {
if (num[i] == '1') dec_value += base;
base = base * 2;
}
return dec_value;
}
unsigned long long sumbincoef(int N, int k) {
unsigned long long bincoef = 1, sum = 1;
int i;
for (i = 1; i < k; ++i) {
bincoef = (bincoef * (N - i + 1) / i);
sum += bincoef;
}
return sum;
}
bool is_prime(long long n) {
if (n == 1) {
return false;
}
long long i = 2;
while (i * i <= n) {
if (n % i == 0) {
return false;
}
i += 1;
}
return true;
}
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int nCrModp(int n, int r, int p) {
if (r > n - r) r = n - r;
int C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = min(i, r); j > 0; j--) C[j] = (C[j] + C[j - 1]) % p;
}
return C[r];
}
bool is_palindrome(string s) {
int n = s.size();
for (int i = 0; i < (int)n / 2; i++) {
if (s[i] == s[n - 1 - i]) {
} else {
return false;
}
}
return true;
}
const int N = 200000 + 10;
long long factorialNumInverse[N + 1];
long long naturalNumInverse[N + 1];
long long fact[N + 1];
void InverseofNumber(long long p) {
naturalNumInverse[0] = naturalNumInverse[1] = 1;
for (int i = 2; i <= N; i++)
naturalNumInverse[i] = naturalNumInverse[p % i] * (p - p / i) % p;
}
void InverseofFactorial(long long p) {
factorialNumInverse[0] = factorialNumInverse[1] = 1;
for (int i = 2; i <= N; i++)
factorialNumInverse[i] =
(naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
}
void factorial(long long p) {
fact[0] = 1;
for (int i = 1; i <= N; i++) {
fact[i] = (fact[i - 1] * i) % p;
}
}
long long Binomial(long long N, long long R, long long p) {
long long ans =
((fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[N - R]) % p;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
mt19937 rng(
(unsigned int)chrono::steady_clock::now().time_since_epoch().count());
long long p = mod;
InverseofNumber(p);
InverseofFactorial(p);
factorial(p);
int t = 1;
while (t > 0) {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
int ans = 0;
for (int i = 0; i < n; i++) {
if (k % a[i] == 0) {
ans = k / a[i];
}
}
cout << ans << endl;
t--;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, i;
string s;
cin >> n >> a >> b >> s;
if (s[a - 1] == s[b - 1]) {
cout << 0;
} else {
cout << 1;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int t, s, q, nr;
int main() {
cin >> t >> s >> q;
while (s < t) {
s += s * (q - 1);
nr++;
}
cout << nr;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3003;
vector<int> g[N];
bool cycle[N];
int road[N], vis[N];
void dfs(int u, int p) {
vis[u]++;
if (vis[u] == 3) cycle[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
int to = g[u][i];
if (to != p && vis[to] < 3) dfs(to, u);
}
vis[u]--;
}
void dfs2(int u, int p, int dis) {
road[u] = dis;
for (int i = 0; i < g[u].size(); i++) {
int to = g[u][i];
if (to == p || cycle[to]) continue;
dfs2(to, u, dis + 1);
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
memset(cycle, 0, sizeof cycle);
dfs(1, -1);
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; i++) {
if (cycle[i]) {
road[i] = 0;
dfs2(i, -1, 0);
}
}
for (int i = 1; i <= n; i++) cout << road[i] << " ";
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005], k[100005], sumk[100005];
long long segtree[400005], lazy[400005];
int n;
void update(int o, long long u, int l, int r) {
lazy[o] = u;
segtree[o] = u * (r - l + 1);
}
void pushup(int o) { segtree[o] = segtree[o << 1] + segtree[o << 1 | 1]; }
void pushdown(int o, int l, int r) {
if (lazy[o] != LLONG_MAX) {
int mid = (r - l) / 2 + l;
update(o << 1, lazy[o], l, mid);
update(o << 1 | 1, lazy[o], mid + 1, r);
lazy[o] = LLONG_MAX;
}
}
void build(int o, int l, int r) {
lazy[o] = LLONG_MAX;
if (l == r) {
segtree[o] = a[l] - k[l - 1];
return;
}
int mid = (r - l) / 2 + l;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
pushup(o);
}
void Replace(int o, int l, int r, int L, int R, long long u) {
if (L > R) return;
if (L <= l && r <= R) {
update(o, u, l, r);
return;
}
pushdown(o, l, r);
int mid = (r - l) / 2 + l;
if (mid >= L) Replace(o << 1, l, mid, L, R, u);
if (mid < R) Replace(o << 1 | 1, mid + 1, r, L, R, u);
pushup(o);
}
long long query(int o, int l, int r, int L, int R) {
if (L > R) return 0;
if (L <= l && r <= R) return segtree[o];
pushdown(o, l, r);
int mid = (r - l) / 2 + l;
long long q1 = 0, q2 = 0;
if (mid >= L) q1 = query(o << 1, l, mid, L, R);
if (mid < R) q2 = query(o << 1 | 1, mid + 1, r, L, R);
return q1 + q2;
}
int binary(int l, int r, long long u) {
if (l == r) return l;
int mid = (r - l) / 2 + l;
long long M = query(1, 1, n, mid, mid);
if (M >= u) return binary(l, mid, u);
return binary(mid + 1, r, u);
}
void solve() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
k[0] = 0;
for (int i = 1; i <= n - 1; i++) {
scanf("%lld", &k[i]);
if (i > 1) k[i] += k[i - 1];
}
sumk[0] = 0;
for (int i = 1; i <= n - 1; i++) sumk[i] = sumk[i - 1] + k[i];
build(1, 1, n);
int q;
scanf("%d", &q);
while (q--) {
char s[5];
int l, r;
scanf("%s%d%d", s, &l, &r);
if (s[0] == 's')
printf("%lld\n",
query(1, 1, n, l, r) + sumk[r - 1] - (l >= 2 ? sumk[l - 2] : 0));
else {
a[l] = query(1, 1, n, l, l) + r;
int o = binary(l, n, a[l]);
if (query(1, 1, n, o, o) >= a[l]) o--;
Replace(1, 1, n, l, o, a[l]);
}
}
}
int main() {
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50005;
int n, m;
int p[N], a[N];
struct LCT {
int fa[N], ch[N][2], siz[N], sv[N];
long long sv2[N], sav[N], san[N], sa[N];
int nroot(int u) { return ch[fa[u]][0] == u || ch[fa[u]][1] == u; }
void pushup(int u) {
siz[u] = siz[ch[u][0]] + siz[ch[u][1]] + sv[u];
san[u] = san[ch[u][0]] + san[ch[u][1]] + 1ll * a[u] * sv[u];
sa[u] =
sa[ch[u][0]] + sa[ch[u][1]] + sav[u] +
(1ll * sv[u] * sv[u] - sv2[u] + 2ll * siz[ch[u][1]] * sv[u]) * a[u] +
2 * san[ch[u][0]] * (siz[ch[u][1]] + sv[u]);
}
void rot(int u) {
int v = fa[u], t = fa[v], d = (u == ch[v][1]);
if (nroot(v)) ch[t][v == ch[t][1]] = u;
fa[u] = t;
fa[ch[u][d ^ 1]] = v;
ch[v][d] = ch[u][d ^ 1];
fa[v] = u;
ch[u][d ^ 1] = v;
pushup(v);
pushup(u);
}
void splay(int u) {
while (nroot(u)) {
int v = fa[u];
if (nroot(v)) rot(u == ch[v][1] ^ v == ch[fa[v]][1] ? u : v);
rot(u);
}
}
int access(int u) {
int v = 0;
for (; u; v = u, u = fa[u]) {
splay(u);
sv[u] += siz[ch[u][1]] - siz[v];
sv2[u] += 1ll * siz[ch[u][1]] * siz[ch[u][1]] - 1ll * siz[v] * siz[v];
sav[u] += sa[ch[u][1]] - sa[v];
ch[u][1] = v;
pushup(u);
}
return v;
}
int lca(int u, int v) {
access(u);
return access(v);
}
void makeroot(int u) {
access(u);
splay(u);
}
void Link(int u, int v) {
makeroot(u);
makeroot(v);
fa[u] = v;
sv[v] += siz[u];
sv2[v] += 1ll * siz[u] * siz[u];
sav[v] += sa[u];
pushup(v);
}
void Cut(int u, int v) {
access(u);
splay(v);
ch[v][1] = fa[u] = 0;
pushup(v);
}
} lt;
void query() {
lt.splay(1);
printf("%.12lf\n", 1.0 * lt.sa[1] / n / n);
}
int main() {
int x, y;
char ty;
scanf("%d", &n);
for (int i = 2; i <= n; i++) scanf("%d", p + i);
for (int i = 1; i <= n; i++)
scanf("%d", a + i), lt.siz[i] = lt.sv[i] = 1, lt.san[i] = lt.sa[i] = a[i];
for (int i = 2; i <= n; i++) lt.Link(i, p[i]);
scanf("%d", &m);
query();
while (m--) {
do ty = getchar();
while (ty != 'P' && ty != 'V');
scanf("%d%d", &x, &y);
if (ty == 'P') {
if (lt.lca(x, y) == x) swap(x, y);
lt.Cut(x, p[x]);
lt.Link(x, p[x] = y);
} else
lt.makeroot(x), a[x] = y, lt.pushup(x);
query();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int per[250000];
bool visited[250000];
void dfs(int s) {
visited[s] = true;
if (!visited[per[s]]) dfs(per[s]);
}
int main() {
int n;
cin >> n;
for (long long i = 1; i < n + 1; i++) cin >> per[i];
bool b[n + 1];
for (long long i = 1; i < n + 1; i++) cin >> b[i];
int count = 0, tot = 0;
memset(visited, false, sizeof(visited));
for (long long i = 1; i < n + 1; i++) {
if (!visited[i]) {
dfs(i);
count++;
}
}
if (count == 1)
tot = 0;
else
tot = count;
int c1 = 0;
for (long long i = 1; i < n + 1; i++) c1 += b[i];
if (c1 % 2 == 0) tot++;
cout << tot;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, vis[200005];
vector<int> adj[200005];
int bfs(int node) {
for (int i = 1; i < n + 1; i++) vis[i] = 0;
int restr = a + b - node;
queue<int> q;
q.push(node);
vis[node] = 1;
while (!q.empty()) {
int d = q.front();
q.pop();
for (auto i : adj[d]) {
if (vis[i] or i == restr) continue;
q.push(i);
vis[i] = 1;
}
}
int w = 0;
for (int i = 1; i < n + 1; i++) w += (vis[i] == 0);
return w - 1;
}
void solve() {
cin >> n >> m >> a >> b;
for (int i = 1; i < n + 1; i++) adj[i].clear();
for (int i = 0; i < m; i++) {
int first, second;
cin >> first >> second;
adj[first].push_back(second);
adj[second].push_back(first);
}
int cnta = bfs(a);
int cntb = bfs(b);
cout << 1LL * cnta * cntb << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct data {
long long vol_o;
long long vol_h;
long long conf;
};
vector<long long> ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, i, j, temp_1, temp_2, zero = 0;
cin >> n;
data a[n];
for (i = 0; i < n; i++) cin >> a[i].vol_o >> a[i].vol_h >> a[i].conf;
for (i = 0; i < n; i++) {
if (a[i].conf >= 0) {
ans.push_back(i + 1);
temp_1 = a[i].vol_o;
temp_2 = 0;
for (j = i + 1; j < n; j++) {
if (a[j].conf >= 0) {
a[j].conf -= (temp_1 + temp_2);
if (a[j].conf < 0) temp_2 += a[j].vol_h;
temp_1--;
temp_1 = max(temp_1, zero);
}
}
}
}
cout << ans.size() << "\n";
for (i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T = int>
T read() {
T x = 0;
char ch = 0;
bool f = false;
while (!isdigit(ch)) f |= (ch = getchar()) == '-';
for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ '0');
return f ? -x : x;
}
const int N = 2.1e5;
const int L = 18;
const int X = 1 << L;
void dmax(int &a, int b) { a = max(a, b); }
struct P {
int val, id;
};
bool operator<(P a, P b) { return a.val < b.val; }
void ins(P a[2], P b) {
if (b.id == -1) return;
for (int i = 0; i < (int)(2); i++) {
if (b.id == a[i].id) {
dmax(a[i].val, b.val);
return;
}
}
for (int i = 0; i < (int)(2); i++)
if (a[i] < b) swap(a[i], b);
}
void ins2(P a[2], P b[2]) {
for (int i = 0; i < (int)(2); i++) ins(a, b[i]);
}
P q(P a[2], int id) { return a[id == a[0].id]; }
P sols[X][2];
void qaq() {
for (int i = 0; i < (int)(L); i++) {
int v = 1 << i;
int v2 = v << 1;
for (int j = 0; j < X; j += v2) {
for (int k = 0; k < (int)(v); k++) ins2(sols[j + k + v], sols[j + k]);
}
}
}
struct U {
int fa[N];
int f(int x) { return fa[x] ? fa[x] = f(fa[x]) : x; }
bool u(int x, int y) {
x = f(x);
y = f(y);
if (x == y) return false;
fa[x] = y;
return true;
}
} u;
long long ans = 0;
P b[N];
int a[N];
int main() {
int n = read();
for (int i = (int)(1); i <= (int)(n); i++) a[i] = read();
n++;
while (true) {
vector<int> nd;
for (int i = (int)(1); i <= (int)(n); i++)
if (u.f(i) == i) nd.push_back(i);
if (nd.size() == 1) break;
for (int i = 0; i < (int)(X); i++)
for (int j = 0; j < (int)(2); j++) sols[i][j] = {-1, -1};
for (int i = (int)(1); i <= (int)(n); i++) ins(sols[a[i]], {a[i], u.f(i)});
qaq();
for (int i = (int)(1); i <= (int)(n); i++) b[i] = {-1, -1};
for (int i = (int)(1); i <= (int)(n); i++) {
int f = u.f(i);
P p = q(sols[(X - 1) ^ a[i]], f);
if (p.id != -1) b[f] = max(b[f], {p.val + a[i], p.id});
}
for (int v : nd) {
if (b[v].id != -1) {
if (u.u(v, b[v].id)) ans += b[v].val;
}
}
}
for (int i = (int)(1); i <= (int)(n); i++) ans -= a[i];
printf("%lld\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int p = 998244353;
int n, k, m;
int l[500086], r[500086], x[500086];
int f[500086], maxl[500086];
int der[500086];
int ans = 1;
int main() {
scanf("%d%d%d", &n, &k, &m);
k--;
for (int i = 1; i <= m; i++) scanf("%d%d%d", &l[i], &r[i], &x[i]);
for (int s = 1 << k; s; s >>= 1) {
memset(der, 0, sizeof(der));
memset(maxl, 0, sizeof(maxl));
memset(f, 0, sizeof(f));
for (int i = 1; i <= m; i++) {
if (x[i] & s) {
der[l[i]]++, der[r[i] + 1]--;
} else {
maxl[r[i] + 1] = max(maxl[r[i] + 1], l[i]);
}
}
for (int i = 1; i <= n + 1; i++) der[i] += der[i - 1];
for (int i = 1; i <= n + 1; i++) maxl[i] = max(maxl[i], maxl[i - 1]);
f[0] = 1;
int j = 0, sum = 1;
for (int i = 1; i <= n + 1; i++) {
if (der[i]) continue;
while (j < maxl[i]) {
sum += p - f[j++];
if (sum >= p) sum -= p;
}
f[i] = sum;
sum += f[i];
if (sum >= p) sum -= p;
}
ans = 1ll * ans * f[n + 1] % p;
}
printf("%d", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, minv, maxv, i, match = 0, minm, maxm;
cin >> n >> m >> minv >> maxv;
int a[m];
for (i = 0; i < m; i++) cin >> a[i];
string s;
for (i = 0; i < m; i++) {
if (a[i] == minv) {
match++;
break;
}
}
for (i = 0; i < m; i++) {
if (a[i] == maxv) {
match++;
break;
}
}
minm = a[0];
maxm = a[0];
for (i = 0; i < m; i++) {
if (minm > a[i]) minm = a[i];
if (maxm < a[i]) maxm = a[i];
}
if (match == 0) {
if (m + 2 <= n && minm >= minv && maxm <= maxv)
s = "Correct";
else
s = "Incorrect";
} else if (match == 1) {
if (m + 1 <= n && minm >= minv && maxm <= maxv)
s = "Correct";
else
s = "Incorrect";
} else if (match == 2) {
if (minm >= minv && maxm <= maxv)
s = "Correct";
else
s = "Incorrect";
}
cout << s;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
long long ans, a[N];
int n, c, fh, i, t, x;
inline void read(int &x) {
c = getchar();
fh = 1;
while ((c < 48) || (c > 57)) {
if (c == '-') {
c = getchar();
fh = -1;
break;
}
c = getchar();
}
x = c ^ 48;
c = getchar();
while ((c >= 48) && (c <= 57)) {
x = x * 10 + (c ^ 48);
c = getchar();
}
x *= fh;
}
int main() {
read(t);
while (t--) {
read(n);
ans = 0;
for (i = 1; i <= n; i++) {
read(x);
a[i] = x;
}
for (i = 1; i < n; i++)
if (a[i] < 0)
ans += -a[i];
else
a[i + 1] += a[i];
printf("%lld\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c = getchar();
int t = 0, f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
t = (t << 3) + (t << 1) + (c ^ 48);
c = getchar();
}
return t * f;
}
int mp[55][55];
int n, m, g[55], s[55], c[55], fast[55], low[55], g1, g2, s1, s2;
long long f[55][55], ans;
int main() {
n = read(), m = read();
memset(mp, 0x3f, sizeof(mp));
memset(fast, 0x3f, sizeof(fast));
for (int i = 1; i <= m; i++) {
int a = read(), b = read(), c = read();
mp[a][b] = min(mp[a][b], c);
mp[b][a] = mp[a][b];
}
g1 = read(), g2 = read(), s1 = read(), s2 = read();
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
if (i == k) continue;
for (int j = 1; j <= n; j++) {
if (i == j || j == k) continue;
mp[i][j] = min(mp[i][j], mp[i][k] + mp[j][k]);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
mp[i][j] = mp[i][j] * 100 + i;
if (i == j) continue;
fast[i] = min(fast[i], mp[i][j]);
low[i] = max(low[i], mp[i][j]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j || fast[i] >= low[j]) continue;
int best = fast[i], worst = low[j];
memset(g, 0, sizeof(g));
memset(s, 0, sizeof(s));
memset(c, 0, sizeof(c));
for (int k = 1; k <= n; k++) {
if (k == i || k == j) continue;
if (fast[k] <= best) g[k] = 1;
if (low[k] >= worst) c[k] = 1;
for (int u = 1; u <= n; u++) {
if (k != u && mp[k][u] > best && mp[k][u] < worst) {
s[k] = 1;
break;
}
}
}
g[i] = 1;
c[j] = 1;
memset(f, 0, sizeof(f));
f[0][0] = 1;
for (int k = 1; k <= n; k++) {
for (int g1 = k; g1 >= 0; g1--) {
for (int s1 = k - g1; s1 >= 0; s1--) {
if (f[g1][s1] == 0) continue;
if (g[k]) f[g1 + 1][s1] = f[g1 + 1][s1] + f[g1][s1];
if (s[k]) f[g1][s1 + 1] = f[g1][s1 + 1] + f[g1][s1];
if (!c[k]) f[g1][s1] = 0;
}
}
}
long long tmp = 0;
for (int k = g1; k <= g2; k++)
for (int u = s1; u <= s2; u++) {
tmp += f[k][u];
}
ans += tmp;
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using lint = int64_t;
using ulint = uint64_t;
using ivec = std::vector<int>;
using lvec = std::vector<lint>;
using ulvec = std::vector<ulint>;
using namespace std;
int main() {
lint n, k, m;
cin >> n >> k >> m;
lvec heroes(n);
for (auto& h : heroes) {
cin >> h;
}
double s0 = accumulate(begin(heroes), end(heroes), lint{});
double avg = (s0 + min(m, k * n)) / n;
lint rest = 0;
sort(begin(heroes), end(heroes));
for (int m1 = 1; m1 < min(n, m + 1); ++m1) {
rest += heroes[m1 - 1];
lint m2 = min(m - m1, k * (n - m1));
avg = max(avg, (s0 - rest + m2) / (n - m1));
}
cout << fixed << setprecision(20) << avg;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
n = m = 5;
long long a[10][10];
int d[10];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cin >> a[i][j];
d[i] = i;
}
long long ans = 0;
for (int i = 0; i < 120; i++) {
long long sum = 0;
sum += a[d[0]][d[1]] + a[d[1]][d[0]] + a[d[2]][d[3]] + a[d[3]][d[2]];
sum += a[d[1]][d[2]] + a[d[2]][d[1]] + a[d[3]][d[4]] + a[d[4]][d[3]];
sum += a[d[2]][d[3]] + a[d[3]][d[2]];
sum += a[d[3]][d[4]] + a[d[4]][d[3]];
ans = max(ans, sum);
next_permutation(d, d + 5);
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct dot {
int x, y;
} d[3005];
inline bool cmp(dot aa, dot bb) { return aa.x < bb.x; }
int now = 1, k, C, n, l[3005], r[3005], cnt, pos[3005], c[3005], nowans,
np[3005];
void cal() {
for (int i = 1; i <= cnt; ++i) c[pos[i]] = i, l[i] = i - 1, r[i] = i + 1;
r[cnt] = nowans = 0;
pos[cnt + 1] = C + 1;
for (int i = k; i <= cnt; ++i)
nowans += (pos[i + 1] - pos[i]) * pos[i - k + 1];
}
void del(int val) {
int now = c[val], i, L = k + 1, R = k + 1, p;
if (pos[l[now]] == val) c[val] = now - 1;
p = l[now];
while (p && L > 1) np[--L] = pos[p], p = l[p];
np[k + 1] = val;
p = r[now];
while (p && R <= k + k + 2) np[++R] = pos[p], p = r[p];
if (R <= k + k + 2) np[++R] = C + 1;
for (i = L + k - 1; i < R; ++i) nowans -= (np[i + 1] - np[i]) * np[i - k + 1];
for (i = k + 1; i < R; ++i) np[i] = np[i + 1];
--R;
for (i = L + k - 1; i < R; ++i) nowans += (np[i + 1] - np[i]) * np[i - k + 1];
L = l[now];
R = r[now];
r[L] = R;
l[R] = L;
}
int R, i, j, las;
long long ans;
int main() {
cin >> R >> C >> n >> k;
for (i = 1; i <= n; ++i) cin >> d[i].x >> d[i].y;
sort(d + 1, d + n + 1, cmp);
for (i = 1; i <= R; ++i) {
while (d[now].x < i) ++now;
for (cnt = 0, j = now; j <= n; ++j) pos[++cnt] = d[j].y;
if (cnt >= k) {
sort(pos + 1, pos + cnt + 1);
cal();
las = n;
for (j = R; cnt >= k; --j) {
ans += nowans;
while (d[las].x == j) del(d[las].y), --las, --cnt;
}
}
}
cout << ans;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int cnt = 0;
std::vector<int> v;
for (int i = n - 1; i > 0; --i) {
if (a[i] != 10000) {
for (int j = i - 1; j >= 0; --j) {
if (a[j] == a[i]) {
a[j] = 10000;
}
}
v.push_back(a[i]);
}
}
if (a[0] != 10000) {
v.push_back(a[0]);
}
cout << v.size() << endl;
for (int i = v.size() - 1; i >= 0; --i) {
cout << v[i] << ' ';
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int n, l, r, ql, qr, a;
long long int pre[(long long int)(1e6) + 5], suff[(long long int)(1e6) + 5];
vector<long long int> v;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> l >> r >> ql >> qr;
for (long long int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
for (long long int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + v[i - 1];
suff[n - i + 1] = suff[n - i + 2] + v[n - i];
}
long long int ans = INT_MAX;
for (long long int i = 0; i <= n; i++) {
ans = min(ans, pre[i] * l + suff[i + 1] * r +
((i > n - i) ? max(1LL * 0, (i - n + i - 1) * ql)
: max(1LL * 0, (n - i - i - 1) * qr)));
}
cout << ans << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
int main() {
int n, m;
cin >> n >> m;
int mx = 0;
int mn = 0;
vector<vector<int>> v(n, vector<int>(m));
bool b = true;
int sum = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> v[i][j];
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (v[i][j] == 0) {
mx = min(v[i][j + 1], v[i + 1][j]);
mn = max(v[i][j - 1], v[i - 1][j]);
if (mx - mn > 1)
v[i][j] = mx - 1;
else {
b = false;
break;
}
} else {
if (i == 0 && j == 0) {
mx = min(v[i][j + 1], v[i + 1][j]);
if (v[i][j] >= mx) {
b = false;
break;
}
}
if (i != 0 && i != n - 1 && j == 0) {
mn = v[i - 1][j];
mx = min(v[i][j + 1], v[i + 1][j]);
if (v[i][j] >= mx || v[i][j] <= mn) {
b = false;
break;
}
}
if (i == n - 1 && j == 0) {
mn = v[i - 1][j];
mx = v[i][j + 1];
if (v[i][j] >= mx || v[i][j] <= mn) {
b = false;
break;
}
}
if (i == n - 1 && j != 0 && j != m - 1) {
mn = max(v[i][j - 1], v[i - 1][j]);
mx = v[i][j + 1];
if (v[i][j] >= mx || v[i][j] <= mn) {
b = false;
break;
}
}
if (i == n - 1 && j == m - 1) {
mn = max(v[i][j - 1], v[i - 1][j]);
if (v[i][j] <= mn) {
b = false;
break;
}
}
if (i != 0 && i != n - 1 && j == m - 1) {
mn = max(v[i][j - 1], v[i - 1][j]);
mx = v[i + 1][j];
if (v[i][j] >= mx || v[i][j] <= mn) {
b = false;
break;
}
}
if (i == 0 && j == m - 1) {
mn = v[i][j - 1];
mx = v[i + 1][j];
if (v[i][j] >= mx || v[i][j] <= mn) {
b = false;
break;
}
}
if (i == 0 && j != 0 && j != m - 1) {
mn = v[i][j - 1];
mx = min(v[i][j + 1], v[i + 1][j]);
if (v[i][j] >= mx || v[i][j] <= mn) {
b = false;
break;
}
}
}
}
if (b == false) break;
}
if (b == false)
cout << -1;
else {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
sum += v[i][j];
}
}
cout << sum;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc;
cin >> tc;
while (tc--) {
bool ch = false;
int n;
cin >> n;
map<int, int> mp;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
if (mp[a] == 0)
mp[a] = i;
else {
if (i - mp[a] > 1) {
ch = true;
}
}
}
cout << ((ch) ? "YES" : "NO") << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "{" << p.first << "," << p.second << "}";
return os;
}
const long long N = 2e5 + 5;
const long long oo = 1e9 + 7;
long long n, ans = LONG_MIN;
vector<long long> g[N];
long long a[N];
long long mx[N];
long long dfs(long long u, long long p = -1) {
vector<long long> vc;
mx[u] = LONG_MIN;
for (long long v : g[u]) {
if (p != v) {
a[u] += dfs(v, u);
mx[u] = max(mx[u], mx[v]);
vc.emplace_back(mx[v]);
}
}
mx[u] = max(mx[u], a[u]);
sort(vc.begin(), vc.end());
if (vc.size() >= 2) {
ans = max(ans, vc.back() + vc[vc.size() - 2]);
}
return a[u];
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i < n; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
if (ans != LONG_MIN)
cout << ans;
else
cout << "Impossible";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp;
long long comp(long long a, long long b) { return (a > b); }
bool prime(long long n) {
if (n == 0 or n == 1) return false;
if (n == 2)
return true;
else if (n % 2 == 0)
return false;
for (long long i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
long long binCo(long long n, long long r) {
long long C[n + 1][r + 1];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j <= min(i, r); j++) {
if (j == 0 or j == i)
C[i][j] = 1;
else
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
}
}
return C[n][r];
}
long long power(long long x, long long y, long long MODL) {
long long res = 1;
x = x % MODL;
while (y > 0) {
if (y & 1) res = (res * x) % MODL;
y = y >> 1;
x = (x * x) % MODL;
}
return res;
}
long long modInverse(long long a, long long m) { return power(a, m - 2, m); }
long long binSearch(long long arr[], long long n, long long x) {
long long l = 0, r = n - 1;
while (l <= r) {
long long mid = (l + r) / 2;
if (x == arr[mid]) return mid;
if (x > arr[mid]) {
l = mid + 1;
} else if (x < arr[mid]) {
r = mid - 1;
}
}
return -1;
}
long long n, k, t;
void solve() {
long long n, k, t;
cin >> n >> k >> t;
t = n * k * t / 100;
while (n--) {
cout << min(t, k) << " ", t -= min(t, k);
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> v;
vector<long long> fact;
long long ans = 1;
const long long MOD = 998244353;
void dfs(int u, int pr = -1) {
for (int i = 0; i < v[u].size(); i++) {
if (v[u][i] != pr) {
dfs(v[u][i], u);
}
}
ans *= fact[v[u].size()];
ans %= MOD;
}
int main() {
int n;
cin >> n;
v.resize(n);
fact.resize(n + 1);
fact[0] = 1;
for (long long i = 1; i <= n; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= MOD;
if (fact[i] < 0) {
fact[i] += MOD;
}
}
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
v[a - 1].push_back(b - 1);
v[b - 1].push_back(a - 1);
}
dfs(0);
ans *= n;
ans %= MOD;
if (ans < 0) {
ans += MOD;
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int a, b, c;
scanf("%d%d", &a, &b);
if (a >= 1 && a <= 100 && b <= 100 && b >= 1) {
if (a > b) {
printf("%d ", b);
c = a - b;
if (c > 1)
printf("%d\n", c / 2);
else
printf("0");
} else if (b > a) {
printf("%d ", a);
c = b - a;
if (c > 1)
printf("%d\n", c / 2);
else
printf("0");
} else {
printf("%d ", a);
printf("0");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> g;
vector<pair<int, long long int>> d1;
vector<pair<int, long long int>> d2;
vector<long long int> t;
vector<int> h;
pair<int, long long int> add(pair<int, long long int> a,
pair<int, long long int> b) {
return {a.first + b.first, a.second + b.second};
}
pair<int, long long int> sub(pair<int, long long int> a,
pair<int, long long int> b) {
return {a.first - b.first, a.second - b.second};
}
void dfs(int x, int p) {
vector<pair<int, long long int>> a;
pair<int, long long int> s;
for (int i = 0; i < g[x].size(); i++) {
int y = g[x][i];
if (y != p) {
dfs(y, x);
s = add(s, d1[y]);
a.push_back(sub(d2[y], d1[y]));
}
}
sort(a.begin(), a.end());
d1[x] = {1, 0};
d2[x] = {1, 0};
for (int q = 0; q <= a.size(); q++) {
int w = a.size() - q;
if (s.first == 0) {
if (p == -1) {
long long int z = max(q, w) * t[x] + s.second;
if (d1[x].first || z < d1[x].second) {
d1[x] = {0, z};
}
} else {
if (h[p] >= h[x]) {
long long int z = max(q + 1, w) * t[x] + s.second;
if (d1[x].first || z < d1[x].second) {
d1[x] = {0, z};
}
}
if (h[p] <= h[x]) {
long long int z = max(q, w + 1) * t[x] + s.second;
if (d2[x].first || z < d2[x].second) {
d2[x] = {0, z};
}
}
}
}
if (q < a.size()) {
s = add(s, a[q]);
}
}
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
t.resize(n);
h.resize(n);
for (int i = 0; i < n; i++) cin >> t[i];
for (int i = 0; i < n; i++) cin >> h[i];
g.resize(n);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
d1.resize(n);
d2.resize(n);
dfs(0, -1);
cout << d1[0].second << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b, d = 1000000005;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
d = min(b - a, d);
}
a = 0;
d++;
printf("%d\n", d);
for (int i = 0; i < n; i++) {
printf("%d ", a);
a = (a + 1) % d;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int A[1111];
int X[1111];
int Y[1111];
int ds[1111][1111];
int dk[1111];
bool u[1111];
priority_queue<int> pq;
int main(void) {
int n, d;
memset(dk, 63, sizeof(dk));
cin >> n >> d;
for (int i = 1; i < n - 1; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
cin >> X[i] >> Y[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
ds[i][j] = (abs(X[i] - X[j]) + abs(Y[i] - Y[j])) * d;
}
}
dk[0] = 0;
for (int i = 0; i < n; i++) {
int v = -1;
for (int j = 0; j < n; j++) {
if (!u[j] && (v == -1 || dk[j] < dk[v])) v = j;
}
u[v] = true;
for (int j = 0; j < n; j++) {
if (j == v) continue;
dk[j] = min(dk[j], dk[v] + ds[v][j] - A[j]);
}
}
cout << dk[n - 1] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, q, ar[100001];
inline long long solve(int L, int R) {
long long ret = 0;
stack<int> s;
for (int i = L; i <= R; i++) {
while (s.size() && ar[s.top()] <= ar[i]) {
int m = s.top();
s.pop();
int l = (s.size()) ? (s.top() + 1) : L;
ret += (long long)(m - l + 1) * (i - m) * ar[m];
}
s.push(i);
}
while (s.size()) {
int m = s.top();
s.pop();
int l = (s.size()) ? (s.top() + 1) : L;
ret += (long long)(m - l + 1) * (R - m + 1) * ar[m];
}
return ret;
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
for (int i = 0; i < n - 1; i++) {
ar[i] = abs(ar[i] - ar[i + 1]);
}
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
cout << solve(l - 1, r - 2) << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, p, q = 0, sum = 0;
vector<int> a;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> p;
a.push_back(p);
if (q < p) q = p;
}
for (i = 0; i < n; i++) sum += (q - a[i]);
j = q + m;
m -= sum;
if (m < 0)
cout << q << " " << j << endl;
else if (m % n == 0)
cout << q + (m / n) << " " << j << endl;
else
cout << q + (m / n) + 1 << " " << j << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
scanf("%lld", &n);
if (n % 4 == 0)
printf("4");
else
printf("0");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
using ld = long double;
using ulli = unsigned long long;
using ii = pair<int, int>;
void deb(istream_iterator<string> it) { it = it; }
template <typename T, typename... Args>
void deb(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << '\n';
deb(++it, args...);
}
template <class T>
struct rge {
T b, e;
};
template <class T>
rge<T> range(T i, T j) {
return rge<T>{i, j};
}
template <class A, class B>
ostream &operator<<(ostream &os, pair<A, B> p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream &operator<<(ostream &os, rge<T> d) {
os << "[";
for (auto it = d.b; it != d.e; it++) os << (it == d.b ? "" : ", ") << *it;
return os << "]";
}
const lli mod = 1e8;
const lli N = 1e5 + 5;
const ld inf = 1e9;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
const ld eps = 1e-9;
struct dsu {
vector<int> pr, tot;
vector<vector<int>> k;
dsu(int nn = 0) {
pr.resize(nn + 5);
tot.resize(nn + 5, 1);
k.resize(nn + 5, {});
iota((pr).begin(), (pr).end(), 0);
for (int i = (1); i <= ((nn)); i += (+1)) k[i].push_back(i);
}
int find(int u) { return pr[u] == u ? u : pr[u] = find(pr[u]); }
void unite(int u, int v) {
u = find(u), v = find(v);
if (u != v) {
if (tot[u] < tot[v]) swap(u, v);
pr[v] = u;
tot[u] += tot[v];
for (auto &x : k[v]) k[u].push_back(x);
}
}
};
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr),
cout.precision(15);
;
int n;
cin >> n;
dsu dg(n);
for (int i = (0); i <= ((n)-1); i += (+1)) {
int u, v;
cin >> u >> v;
dg.unite(u, v);
}
for (auto &x : dg.k[dg.find(1)]) cout << x << " ";
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
string xl1(string s1) {
string s2 = "";
vector<int> a;
for (int i = 0; i < s1.length(); i++)
if (s1[i] >= '0' && s1[i] <= '9') {
int x = 0;
while ((s1[i] >= '0' && s1[i] <= '9') && i < s1.length()) {
x = x * 10 + s1[i] - '0';
i++;
}
a.push_back(x);
}
int H = a[0], C = a[1];
while (H > 0) {
s2.insert(0, 1, H % 10 + '0');
H = H / 10;
}
while (C > 0) {
int x1 = C % 26;
if (x1 == 0) {
s2.insert(0, 1, 'Z');
C = C / 26 - 1;
} else {
s2.insert(0, 1, x1 - 1 + 'A');
C /= 26;
}
}
return s2;
}
string xl2(string s1) {
int C = 0, H = 0;
string s2 = "";
for (int i = 0; i < s1.length(); i++) {
if (s1[i] >= 'A' && s1[i] <= 'Z') {
while (s1[i] >= 'A' && s1[i] <= 'Z') {
C = C * 26 + s1[i] - 'A' + 1;
i++;
}
i--;
} else
while ((s1[i] >= '0' && s1[i] <= '9') && i < s1.length()) {
H = H * 10 + s1[i] - '0';
i++;
}
}
while (C > 0) {
s2.insert(0, 1, C % 10 + '0');
C = C / 10;
}
s2 = "C" + s2;
while (H > 0) {
s2.insert(0, 1, H % 10 + '0');
H = H / 10;
}
s2 = "R" + s2;
return s2;
}
bool kt(string s1) {
if (s1[0] != 'R') return 0;
int i = 0;
while ((s1[i] >= 'A' && s1[i] <= 'Z') && i < s1.length()) {
i++;
}
while ((s1[i] >= '0' && s1[i] <= '9') && i < s1.length()) {
i++;
}
if (s1[i] == 'C')
return 1;
else
return 0;
}
int main() {
cin >> n;
while (n--) {
cin >> s;
if (kt(s) == 1)
cout << xl1(s) << endl;
else
cout << xl2(s) << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
int n, m;
vector<pair<int, string> > reg[N];
char str[11];
bool hav[N];
int main() {
scanf("%d%d", &n, &m);
for (int x, y, i = 0; i < n; ++i) {
scanf("%s", str);
scanf("%d%d", &x, &y);
x--;
reg[x].push_back({-y, str});
}
for (int i = 0; i < m; ++i) {
sort(reg[i].begin(), reg[i].end());
if (reg[i].size() > 2 && (reg[i][2].first == reg[i][0].first ||
reg[i][1].first == reg[i][2].first))
puts("?");
else
printf("%s %s\n", reg[i][0].second.c_str(), reg[i][1].second.c_str());
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double px, py, m, n, a, b, c, d;
double ef(double kx, double ky, double dis) {
double l = 0, r = 1000, mid;
for (int i = 1; i <= 100000; i++) {
mid = (l + r) / 2;
if (sqrt(mid * kx * mid * kx + mid * ky * mid * ky) > dis)
r = mid;
else
l = mid;
}
return mid;
}
int main() {
cin >> px >> py >> m >> n >> a >> b >> c >> d;
double mid = ef(m, n, b), tx, ty;
printf("%.11lf %.11lf\n", px + mid * m, py + mid * n);
mid = ef(-n, m, a / 2.0);
printf("%.11lf %.11lf\n", px + mid * (-n), py + mid * m);
mid = ef(-n, m, c / 2.0);
tx = px + mid * (-n);
ty = py + mid * m;
printf("%.11lf %.11lf\n", tx, ty);
mid = ef(-m, -n, d);
printf("%.11lf %.11lf\n", tx + mid * (-m), ty + mid * (-n));
mid = ef(n, -m, c / 2.0);
tx = px + mid * (n);
ty = py + mid * (-m);
mid = ef(-m, -n, d);
printf("%.11lf %.11lf\n", tx + mid * (-m), ty + mid * (-n));
printf("%.11lf %.11lf\n", tx, ty);
mid = ef(n, -m, a / 2.0);
printf("%.11lf %.11lf\n", px + mid * (n), py + mid * (-m));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int sz = 1, n, m, a[220001], tt, x, y;
long long v;
unordered_map<int, long long> f[2];
long long sum(bool v, long long r) {
long long res = 0;
while (r >= 0) {
res += f[v][r];
r = (r & (r + 1)) - 1;
}
return res;
}
void update(bool v, long long r, long long val) {
while (r <= (long long)1e9) f[v][r] += val, r |= r + 1;
}
long long get(bool v, long long l, long long r) {
return sum(v, r) - sum(v, l - 1);
}
bool check(double x) {
long long nx = (long long)(x);
if ((long long)(nx) != x) nx++;
nx = min(nx, (long long)1e9);
long long ls = get(0, 0, nx - 1);
long long mr = get(1, 0, nx - 1);
return ls * x - mr >= v;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
update(0, a[i], 1);
update(1, a[i], a[i]);
}
while (m--) {
scanf("%d", &tt);
if (tt == 1) {
scanf("%d%d", &x, &y);
update(0, a[x], -1);
update(1, a[x], -a[x]);
a[x] = y;
update(0, a[x], 1);
update(1, a[x], a[x]);
} else {
scanf("%I64d", &v);
double l = 0, r = v + 1e9;
for (int it = 0; it < 45; ++it) {
double m = (l + r) * 0.5;
if (check(m))
r = m;
else
l = m;
}
printf("%.7f\n", r);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
inline long long modPow(long long x, long long n) {
if (n == 0) return (1);
long long ret = modPow(x, n / 2);
(ret *= ret) %= mod;
if (n & 1) (ret *= x) %= mod;
return (ret);
}
inline long long modInv(long long a) { return (modPow(a, mod - 2)); }
int N;
vector<int> g[100000], order, child[100000];
long long gg[100000], ki[100000];
void dfs(int idx, int par = -1) {
for (auto &to : g[idx]) {
if (to != par) {
dfs(to, idx);
child[idx].push_back(to);
}
}
order.push_back(idx);
}
int dfs2(int idx, long long pargg) {
int ret = 0;
long long latte = 1;
for (auto &to : child[idx]) (latte *= gg[to]) %= mod;
(latte *= pargg) %= mod;
(ret += latte) %= mod;
(ret += latte) %= mod;
for (auto &to : child[idx]) {
(ret += dfs2(to, (latte + latte) % mod * modInv(gg[to]) % mod)) %= mod;
}
return (ret);
}
int main() {
cin >> N;
for (int i = 1; i < N; i++) {
int a, b;
cin >> a >> b;
--a, --b;
g[a].emplace_back(b);
g[b].emplace_back(a);
}
if (N == 1) {
cout << 0 << endl;
return (0);
} else if (N == 2) {
cout << 4 << endl;
return (0);
}
int root = 0;
for (int i = 0; i < N; i++) {
if (g[i].size() >= 2) root = i;
}
dfs(root);
for (int i : order) {
long long latte = 1;
for (auto &to : child[i]) (latte *= gg[to]) %= mod;
(gg[i] += latte) %= mod;
if (!child[i].empty()) (gg[i] += latte) %= mod;
}
cout << dfs2(root, 1) << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
struct Front_star {
int u, v, nxt;
} e[N << 1];
int cnt = 0;
int first[N];
void add(int u, int v) {
++cnt;
e[cnt].u = u;
e[cnt].v = v;
e[cnt].nxt = first[u];
first[u] = cnt;
}
int n;
double ans = 0;
int fa[N];
double F[N];
double sum[N];
void DFS(int u, int fat) {
for (int i = first[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fat) continue;
fa[v] = u;
DFS(v, u);
sum[u] += (1.0 - F[v]);
}
}
int main() {
scanf("%d", &n);
F[0] = 1;
for (int i = 1; i <= n; ++i) {
scanf("%lf", &F[i]);
}
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
++u;
++v;
add(u, v);
add(v, u);
}
DFS(1, 1);
for (int i = 1; i <= n; ++i) {
ans += (1.0 - F[i]) * (F[fa[i]]);
}
int Q;
scanf("%d", &Q);
while (Q--) {
int pos;
double v;
scanf("%d%lf", &pos, &v);
++pos;
ans -= (1.0 - F[pos]) * (F[fa[pos]]);
ans -= sum[pos] * F[pos];
sum[fa[pos]] -= (1.0 - F[pos]);
F[pos] = v;
ans += sum[pos] * F[pos];
ans += (1.0 - F[pos]) * (F[fa[pos]]);
sum[fa[pos]] += (1.0 - F[pos]);
printf("%6lf\n", ans);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100003;
int n, L, U, Link[maxn], t[maxn * 2], v[maxn * 2], pre[maxn * 2],
tot = 0, lim = 0, s[maxn], tp[maxn], size[maxn];
bool vis[maxn];
int f[maxn], g[maxn], ans, len[maxn], F[maxn], G[maxn], st, ed, S, T;
struct data {
int t, depth;
} Q[maxn];
int get() {
int f = 0, v = 0;
char ch;
while (!isdigit(ch = getchar()))
if (ch == '-') break;
if (ch == '-')
f = 1;
else
v = ch - 48;
while (isdigit(ch = getchar())) v = v * 10 + ch - 48;
if (f == 1)
return -v;
else
return v;
}
int findroot(int x) {
int front = 0, rear = 1;
s[front] = x, vis[x] = 1;
while (front != rear) {
int p = s[front];
for (int i = Link[p]; i > 0; i = pre[i])
if (!vis[t[i]]) s[rear++] = t[i], vis[t[i]] = 1;
front++;
}
if (rear <= L) return -1;
int root, tp, m = n;
for (int i = rear - 1; i >= 0; i--) {
tp = vis[s[i]] = 0;
size[s[i]] = 1;
for (int j = Link[s[i]]; j > 0; j = pre[j])
if (!vis[t[j]]) {
size[s[i]] += size[t[j]];
if (tp == 0 || size[tp] < size[t[j]]) tp = t[j];
}
tp = max(size[tp], rear - size[s[i]]);
if (tp < m) m = tp, root = s[i];
}
return root;
}
int getmaxdepth(int x) {
int front = 0, rear = 1, res = 1;
s[front] = x, tp[front] = 1;
vis[x] = 1;
while (front != rear) {
int p = s[front];
if (tp[front] == U) break;
for (int i = Link[p]; i > 0; i = pre[i])
if (!vis[t[i]]) {
vis[t[i]] = 1;
tp[rear] = tp[front] + 1, s[rear++] = t[i];
res = max(res, tp[rear - 1]);
}
front++;
}
for (int i = rear - 1; i >= 0; i--) vis[s[i]] = 0;
return res;
}
int check(int N, int delta) {
int maxd = 0;
f[0] = 0;
int res = -2000000000;
for (int i = 1; i <= N; i++) {
int x = t[Q[i].t], front = 0, rear = 1, maxd0 = 1;
s[front] = x, tp[front] = 1;
len[front] = g[1] = (v[Q[i].t] - delta) >= 0 ? 1 : -1;
G[1] = x;
vis[x] = 1;
while (front != rear) {
int p = s[front];
if (tp[front] == U) break;
for (int j = Link[p]; j > 0; j = pre[j]) {
if (vis[t[j]]) continue;
vis[t[j]] = 1;
tp[rear] = tp[front] + 1;
len[rear] = len[front] + ((v[j] - delta) >= 0 ? 1 : -1);
if (tp[rear] > maxd0)
g[tp[rear]] = len[rear], G[tp[rear]] = t[j], maxd0 = tp[rear];
else if (len[rear] > g[tp[rear]])
g[tp[rear]] = len[rear], G[tp[rear]] = t[j];
s[rear++] = t[j];
}
front++;
}
for (int i = rear - 1; i >= 0; i--) vis[s[i]] = 0;
int lo, hi, pre = maxd + 1;
front = 0, rear = -1;
for (int j = 0; j <= maxd0; j++) {
lo = max(L - j, 0);
hi = min(U - j, maxd);
for (int k = pre - 1; k >= lo; k--) {
while (front <= rear && f[s[rear]] <= f[k]) rear--;
s[++rear] = k;
}
pre = min(lo, pre);
while (front <= rear && s[front] > hi) front++;
if (front <= rear) {
if (f[s[front]] + g[j] > res) {
res = f[s[front]] + g[j];
st = F[s[front]], ed = G[j];
}
}
}
for (int j = 0; j <= maxd0; j++)
if (j <= maxd) {
if (g[j] > f[j]) f[j] = g[j], F[j] = G[j];
} else
f[j] = g[j], F[j] = G[j];
maxd = max(maxd, maxd0);
}
return res;
}
bool cmp(data a, data b) { return a.depth < b.depth; }
void dfs(int x) {
x = findroot(x);
if (x == -1) return;
vis[x] = 1;
int len = 0;
for (int i = Link[x]; i > 0; i = pre[i])
if (!vis[t[i]]) Q[++len].t = i, Q[len].depth = getmaxdepth(t[i]);
sort(Q + 1, Q + 1 + len, cmp);
int l = ans, r = lim, mid;
G[0] = F[0] = x;
while (l != r) {
mid = (l + r + 1) / 2;
if (check(len, mid) >= 0) {
l = mid;
if (l > ans) ans = l, S = st, T = ed;
} else
r = mid - 1;
}
for (int i = Link[x]; i > 0; i = pre[i])
if (!vis[t[i]]) dfs(t[i]);
}
int main() {
n = get();
L = get(), U = get();
for (int i = 1; i < n; i++) {
int x = get(), y = get(), z = get();
lim = max(lim, z);
pre[++tot] = Link[x];
Link[x] = tot;
t[tot] = y;
v[tot] = z;
pre[++tot] = Link[y];
Link[y] = tot;
t[tot] = x;
v[tot] = z;
}
ans = -1;
dfs(1);
printf("%d %d\n", S, T);
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m;
vector<int> l[1000005], r[1000005];
vector<int> dab;
void sayno() {
printf("IMPOSSIBLE");
exit(0);
}
int cur;
int back(int now, int en) {
int i, j;
cur = now;
if (l[now].size() && l[now][0] <= now) sayno();
if (l[now].size()) {
if (!back(now + 1, l[now].back())) sayno();
}
dab.push_back(now);
if (r[now].size() && r[now][0] <= cur) sayno();
if (r[now].size() || cur < en)
back(cur + 1, max(en, r[now].size() ? r[now].back() : en));
return 1;
}
int main() {
int i, j, k;
cin >> n >> m;
for (i = 0; i < m; i++) {
int x, y;
char a[10];
scanf("%d%d%s", &x, &y, a);
x--, y--;
if (x >= y) sayno();
if (a[0] == 'L')
l[x].push_back(y);
else
r[x].push_back(y);
}
for (i = 0; i < n; i++)
sort(l[i].begin(), l[i].end()), sort(r[i].begin(), r[i].end());
int x = back(0, n - 1);
for (i = x + 1; i < n; i++) dab.push_back(i);
for (i = 0; i < n; i++) printf("%d ", dab[i] + 1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
long long int a[n], i, ans = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
ans += a[i];
}
if (m < n || n == 2) {
cout << "-1\n";
continue;
} else {
cout << 2 * ans << "\n";
for (i = 1; i < n; i++) cout << i << " " << i + 1 << "\n";
if (n != 2) cout << n << " " << 1 << "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma optimization_level 3
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> a(2 * n);
for (int i = 0; i < 2 * n; i++) {
cin >> a[i];
}
if (n == 1) {
cout << 0;
return 0;
}
sort(a.begin(), a.end());
long long pr = 1e18 + 9;
int razn2 = a[2 * n - 1] - a[0];
for (int i = 1; i < n; i++) {
long long razn1 = a[i + n - 1] - a[i];
pr = min(pr, razn1 * razn2);
}
pr = min(pr, (a[n - 1] - a[0]) * (a[2 * n - 1] - a[n]));
cout << pr;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
long long x, y;
pt(long long _x, long long _y) {
x = _x;
y = _y;
}
bool operator<(const pt &p) const {
return make_tuple(x, -y) < make_tuple(p.x, -p.y);
}
pt operator-(const pt &p) const { return pt(x - p.x, y - p.y); }
long long operator^(const pt &p) const {
return (long long)x * p.y - (long long)y * p.x;
}
};
vector<pt> v;
int main() {
long long N, P, Q;
cin >> N >> P >> Q;
long long mxa = 0, mxb = 0;
for (long long Ni = 0; Ni < N; Ni++) {
long long a, b;
cin >> a >> b;
v.push_back(pt(a, b));
mxa = max(mxa, a);
mxb = max(mxb, b);
}
v.push_back(pt(mxa, 0));
v.push_back(pt(0, mxb));
sort(v.begin(), v.end());
vector<pt> p;
p.push_back(v[0]);
p.push_back(v[1]);
for (long long vi = 2; vi < v.size(); vi++) {
while (p.size() >= 2 && ((p[p.size() - 1] - p[p.size() - 2]) ^
(v[vi] - p[p.size() - 1])) >= 0)
p.pop_back();
p.push_back(v[vi]);
}
for (long long pi = 1; pi < p.size(); pi++) {
pt t = pt(P, Q);
if ((p[pi] ^ t) >= 0) {
long long a = t ^ (p[pi - 1]), b = p[pi] ^ t;
double c = (double)(p[pi - 1].x * b + p[pi].x * a) / (a + b);
printf("%.9f\n", P / c);
break;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
int n, m, cnt, head[maxn], vis[maxn], mark[maxn], ans[maxn], tot;
struct edge {
int to, next;
} e[maxn];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
void add(int from, int to) {
e[++cnt] = (edge){to, head[from]};
head[from] = cnt;
}
void dfs(int now, int father, int edge) {
vis[now] = 1;
vector<int> bian;
for (int i = head[now]; i; i = e[i].next) {
int to = e[i].to;
if (!vis[to]) dfs(to, now, i);
}
for (int i = head[now]; i; i = e[i].next) {
int to = e[i].to;
if (to != father && !mark[i]) {
bian.push_back(i);
mark[i] = 1;
if (i & 1)
mark[i + 1] = 1;
else
mark[i - 1] = 1;
}
}
int size = bian.size();
for (int i = 0; i < size; i++) {
if (i & 1) ans[++tot] = now;
ans[++tot] = e[bian[i]].to;
}
if (size & 1) {
if (father)
ans[++tot] = now, ans[++tot] = father, mark[edge] = 1;
else
tot--;
}
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
add(u, v), add(v, u);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i, 0, 0);
printf("%d\n", tot / 3);
for (int i = 1; i <= tot; i++) {
printf("%d ", ans[i]);
if (i % 3 == 0) puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
const long long int mod = 1e9 + 7;
const long long int pinf = ((long long int)2e18);
const long long int ninf = ((long long int)-2e18);
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int te;
cin >> te;
while (te--) {
long long int sum = 0, m, n, k, y, i, l, j;
cin >> n >> m;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum == m) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 10, M = 200000 + 10;
long long MOD = 1e9 + 7, inv2 = (MOD + 1) / 2;
long double eps = 1e-8;
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
long double pi = acos(-1.0L);
int read() {
int v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
long long readll() {
long long v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
struct node {
long long s, tag;
} t[N << 2];
vector<int> in[N], out[N];
long long g[N], P;
int head[N], vet[N], nxt[N], son[N], sz[N], dep[N], flag[N], fa[N], top[N],
l[N], r[N], tid[N], id[N], n, tot, cnt, C;
long long pw(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % MOD;
x = x * x % MOD;
y >>= 1;
}
return res;
}
void add(int a, int b) {
nxt[++tot] = head[a];
vet[tot] = b;
head[a] = tot;
}
void init() {
n = read();
P = 1;
C = 1;
for (int i = (int)1; i <= (int)n; i++)
l[i] = read(), r[i] = read(), g[i] = pw(r[i] - l[i] + 1, MOD - 2) % MOD,
P = P * (r[i] - l[i] + 1) % MOD, C = max(C, r[i]);
for (int i = (int)1; i <= (int)n - 1; i++) {
int x = read(), y = read();
add(x, y);
add(y, x);
}
}
void dfs1(int u) {
flag[u] = 1;
sz[u] = 1;
int mx = 0;
int e = head[u];
while (e) {
int v = vet[e];
if (!flag[v]) {
fa[v] = u;
dep[v] = dep[u] + 1;
dfs1(v);
sz[u] += sz[v];
if (sz[v] > mx) mx = sz[v], son[u] = v;
}
e = nxt[e];
}
}
void dfs2(int u, int ance) {
flag[u] = 1;
tid[u] = ++cnt;
id[cnt] = u;
top[u] = ance;
if (son[u]) dfs2(son[u], ance);
int e = head[u];
while (e) {
int v = vet[e];
if (!flag[v]) dfs2(v, v);
e = nxt[e];
}
}
void pushup(int p) { t[p].s = (t[p << 1].s + t[p << 1 | 1].s) % MOD; }
void pushdown(int l, int r, int p) {
int mid = (l + r) >> 1;
t[p << 1].tag = (t[p << 1].tag + t[p].tag) % MOD;
t[p << 1 | 1].tag = (t[p << 1 | 1].tag + t[p].tag) % MOD;
t[p << 1].s = (t[p << 1].s + t[p].tag * (mid - l + 1) % MOD) % MOD;
t[p << 1 | 1].s = (t[p << 1 | 1].s + t[p].tag * (r - mid) % MOD) % MOD;
t[p].tag = 0;
}
void update(int l, int r, int x, int y, long long z, int p) {
if (x <= l && r <= y) {
t[p].tag = (t[p].tag + z) % MOD;
t[p].s = (t[p].s + z * (r - l + 1) % MOD) % MOD;
return;
}
pushdown(l, r, p);
int mid = (l + r) >> 1;
long long res = 0;
if (x <= mid) update(l, mid, x, y, z, p << 1);
if (y > mid) update(mid + 1, r, x, y, z, p << 1 | 1);
pushup(p);
}
long long query(int l, int r, int x, int y, int p) {
if (x <= l && r <= y) return t[p].s;
pushdown(l, r, p);
int mid = (l + r) >> 1;
long long res = 0;
if (x <= mid) res = (res + query(l, mid, x, y, p << 1)) % MOD;
if (y > mid) res = (res + query(mid + 1, r, x, y, p << 1 | 1)) % MOD;
return res;
}
long long qsum(int x, int y) {
long long ans = 0;
int f1 = top[x], f2 = top[y];
while (f1 != f2) {
if (dep[f1] < dep[f2]) swap(f1, f2), swap(x, y);
ans = (ans + query(1, n, tid[f1], tid[x], 1)) % MOD;
x = fa[f1];
f1 = top[x];
}
if (dep[x] > dep[y]) swap(x, y);
ans = (ans + query(1, n, tid[x], tid[y], 1)) % MOD;
return ans;
}
void tadd(int x, int y, long long z) {
int f1 = top[x], f2 = top[y];
while (f1 != f2) {
if (dep[f1] < dep[f2]) swap(f1, f2), swap(x, y);
update(1, n, tid[f1], tid[x], z, 1);
x = fa[f1];
f1 = top[x];
}
if (dep[x] > dep[y]) swap(x, y);
update(1, n, tid[x], tid[y], z, 1);
}
void solve() {
cnt = 0;
dfs1(1);
memset(flag, 0, sizeof(flag));
dfs2(1, 1);
for (int i = (int)1; i <= (int)n; i++) {
in[l[i]].push_back(i);
out[r[i] + 1].push_back(i);
}
long long ans = 0, res = 0, d1 = 0, d2 = 0, d3 = 0;
for (int i = (int)1; i <= (int)C; i++) {
for (auto v : out[i]) {
d1 = (d1 - 1ll * dep[v] * g[v] % MOD + MOD) % MOD;
d2 = (d2 - g[v] + MOD) % MOD;
d3 = (d3 - 1ll * dep[v] * g[v] % MOD * g[v] % MOD + MOD) % MOD;
tadd(1, v, MOD - g[v]);
res = (res - 1ll * g[v] * (qsum(1, v) - qsum(1, 1) + MOD) % MOD + MOD) %
MOD;
}
for (auto v : in[i]) {
d1 = (d1 + 1ll * dep[v] * g[v] % MOD) % MOD;
d2 = (d2 + g[v]) % MOD;
d3 = (d3 + 1ll * dep[v] * g[v] % MOD * g[v] % MOD) % MOD;
res = (res + 1ll * g[v] * (qsum(1, v) - qsum(1, 1) + MOD) % MOD) % MOD;
tadd(1, v, g[v]);
}
ans = (ans + 1ll * d1 * d2 % MOD - 2ll * res - d3) % MOD;
ans = (ans + MOD) % MOD;
}
ans = ans * P % MOD;
printf("%I64d\n", ans);
}
int main() {
init();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string cmd;
while (true) {
cin >> cmd;
if (cmd != "start") break;
int start = 1;
int diff = 1;
int ub = 2000000000;
string res;
int cnt = 0;
while (diff > 0) {
cout << "? " << start << " " << start + diff << endl;
cnt++;
cin >> res;
if (res == "y") {
start += diff;
diff += diff;
while (start + diff >= ub) {
diff /= 2;
}
} else if (res == "e") {
return 0;
} else {
ub = min(ub, start + diff);
diff /= 2;
}
}
if (start == 1) {
cout << "? 2 1" << endl;
cnt++;
cin >> res;
if (res == "y")
cout << "! 2" << endl;
else
cout << "! 1" << endl;
} else
cout << "! " << start + 1 << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int x[5], y[5];
int main() {
scanf("%d%d%d%d", &x[1], &y[1], &x[2], &y[2]);
if (x[1] == x[2])
x[3] = x[4] = x[1] + (y[1] - y[2]), y[3] = y[1], y[4] = y[2];
else if (y[1] == y[2])
y[3] = y[4] = y[1] + (x[1] - x[2]), x[3] = x[1], x[4] = x[2];
else
x[3] = x[1], y[3] = y[2], x[4] = x[2], y[4] = y[1];
if (abs(max(x[3], max(x[1], x[2])) - min(x[3], min(x[1], x[2]))) !=
abs(max(y[3], max(y[1], y[2])) - min(y[3], min(y[1], y[2])))) {
printf("-1\n");
return 0;
}
printf("%d %d %d %d\n", x[3], y[3], x[4], y[4]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 346346;
int n, k;
int a[N];
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
long long sum = 0;
vector<long long> v;
for (int i = n - 1; i >= 0; --i) {
sum += a[i];
if (i > 0) v.push_back(sum);
}
long long res = sum;
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
for (int i = 0; i < k - 1; ++i) {
res += v[i];
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <class T, class U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
char s[600011];
int val[600011], sval[600011];
int ht[600011], mn[600011][23];
int sa[600011], rk[600011];
namespace SA {
int head[600011 * 2];
pair<pair<int, int>, int> pos[600011 * 2], buf[600011 << 1], tbuf[600011 << 1];
int nxt[600011 * 2];
void bucket_sort(int ok, int n) {
int i, u, j, deg, E, K;
for (i = E = K = 0; i < max(222, n + 10); i++) head[i] = -1;
for (i = 0; i < n; i++) {
if (ok)
u = pos[i].first.first + 1;
else
u = pos[i].first.second + 1;
buf[E] = pos[i];
nxt[E] = head[u];
head[u] = E++;
}
for (int i = 0; i < max(n + 10, 222); i++) {
for (deg = 0, j = head[i]; ~j; j = nxt[j]) {
tbuf[deg++] = buf[j];
}
while (deg) pos[K++] = tbuf[--deg];
}
}
void LCP(int n) {
for (int i = 1; i <= n; i++) mn[i][0] = ht[i];
for (int j = 1; j < 23; j++) {
for (int i = 1; i <= n; i++) {
mn[i][j] = min(mn[i][j - 1], mn[min(n, i + (1 << j - 1))][j - 1]);
}
}
}
void height(int n) {
int h = 0, i;
for (i = 0; i < n; i++) sa[rk[i]] = i;
for (i = 0; i < n; i++) {
if (rk[i] == 1) continue;
h = max(0, h - 1);
for (int j = sa[rk[i] - 1]; s[i + h] == s[j + h]; h++)
;
ht[rk[i]] = h;
}
}
void buildSA(int n) {
int i, j, cnt, u;
for (i = 0; i < n; i++) rk[i] = s[i];
rk[n] = 0;
for (i = 0; i < 23; i++) {
for (j = 0; j < n; j++)
pos[j] = pair<pair<int, int>, int>(
pair<int, int>(rk[j], rk[min(n, j + (1 << i))]), j);
bucket_sort(0, n);
bucket_sort(1, n);
pos[n] = pair<pair<int, int>, int>(pair<int, int>(-1, -1), -1);
for (cnt = j = 0; j < n; j++) {
rk[pos[j].second] = cnt + 1;
cnt += (pos[j].first != pos[j + 1].first);
}
if (cnt == n) break;
}
height(n);
LCP(n);
}
int calc(int u, int v) {
if (u == v) return 0x3f3f3f3f;
if (u > v) swap(u, v);
u++;
int l = 31 - (__builtin_clz(v - u + 1));
return min(mn[u][l], mn[v - (1 << l) + 1][l]);
}
} // namespace SA
struct data {
int l, r, L, R, id;
data() : l(0), r(0), L(0), R(0), id(0) {}
data(int l, int r, int L, int R, int id) : l(l), r(r), L(L), R(R), id(id) {}
bool operator<(const data &u) const {
int xL = (L + 333 - 1) / 333;
int yL = (u.L + 333 - 1) / 333;
if (xL == yL) return R < u.R;
return xL < yL;
}
void print() { printf("%d %d %d %d %d\n", l, r, L, R, id); }
} query[600011];
struct res {
int mx, pos;
res() : mx(0), pos(0) {}
res(int val, int pos) : mx(val), pos(pos) {}
bool operator>(const res &u) const {
if (mx == u.mx) return pos < u.pos;
return mx > u.mx;
}
bool operator<(const res &u) const { return u > *this; }
void print() { printf("%d %d\n", mx, pos); }
} ans[600011];
class RMQ_TREE {
private:
int n;
res mem[600011 << 1];
public:
void build(int m) {
n = m;
for (int i = 0; i < n; i++) mem[i + n] = res(0, i + 1);
for (int i = n - 1; i; i--) mem[i] = max(mem[i << 1], mem[i << 1 | 1]);
}
void update(int u, int add) {
if (!u) return;
mem[u += (n - 1)].mx += add;
for (; u > 1; u >>= 1) {
mem[u >> 1] = max(mem[u ^ 1], mem[u]);
}
}
res calc(int st, int ed) {
res ans = res(-1, -1);
for (st += (n - 1), ed += (n - 1); ed >= st;
ed = (ed - 1) >> 1, st = (st + 1) >> 1) {
if (st & 1) smax(ans, mem[st]);
if (ed & 1 ^ 1) smax(ans, mem[ed]);
}
return ans;
}
} RT;
void update(int u, int add) { RT.update(sval[u], add); }
int main() {
scanf("%s", s);
int m;
cin >> m;
int pos = strlen(s);
for (int i = 1; i <= m; i++) {
scanf("%s", s + pos);
for (int j = pos; s[j]; j++, pos++) val[j] = i;
s[pos++] = '#';
}
SA::buildSA(pos);
for (int i = 0; i < pos; i++) sval[rk[i]] = val[i];
int q;
cin >> q;
int l, r, pl, pr, st, mid, ed, L, R;
int now;
for (int i = 0; i < q; i++) {
gn(l);
gn(r);
gn(pl);
gn(pr);
pl--;
pr -= pl;
now = rk[pl];
st = 0, ed = now;
while (ed > st + 1) {
mid = st + ed >> 1;
if (SA::calc(mid, now) >= pr)
ed = mid;
else
st = mid;
}
L = ed;
st = now;
ed = pos + 1;
while (ed > st + 1) {
mid = st + ed >> 1;
if (SA::calc(now, mid) >= pr)
st = mid;
else
ed = mid;
}
R = st;
query[i] = data(l, r, L, R, i);
}
sort(query, query + q);
RT.build(m);
for (int i = 0; i < q; i++) {
if (!i) st = query[i].L, ed = st - 1;
while (st > query[i].L) update(--st, 1);
while (st < query[i].L) update(st++, -1);
while (ed > query[i].R) update(ed--, -1);
while (ed < query[i].R) update(++ed, 1);
ans[query[i].id] = RT.calc(query[i].l, query[i].r);
}
for (int i = 0; i < q; i++) {
printf("%d %d\n", ans[i].pos, ans[i].mx);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T sqr(T n) {
return n * n;
}
template <typename T>
inline T pmod(T n, T m) {
return ((n % m) + m) % m;
}
template <typename T>
T power(T n, long long p) {
if (!p)
return 1;
else {
T res = sqr(power(n, p >> 1));
if (p & 1) res *= n;
return res;
}
}
template <typename T>
T bigmod(T n, long long p, T m) {
if (!p)
return 1;
else {
T r = sqr(bigmod(n, p >> 1, m)) % m;
if (p & 1) r = (r * n) % m;
return r;
}
}
template <typename T>
T exgcd(T a, T b, T& x, T& y) {
if (!b) {
x = 1;
y = 0;
return a;
} else {
T g = exgcd(b, a % b, y, x);
y -= (a / b) * x;
return g;
}
}
template <typename T>
T modinv(T a, T m) {
T x, y;
exgcd(a, m, x, y);
return pmod(x, m);
}
int test, cas = 1;
double getNCR(int n, int r) {
double res = 1;
for (int i = 1; i <= r; ++i) {
res = res * (n - i + 1) / i;
}
return res;
}
int main() {
int n, m, h, t, s;
int sum = 0;
scanf("%d %d %d", &n, &m, &h);
for (int i = 1; i <= m; ++i) {
scanf("%d", &s);
sum += s;
if (i == h) t = s;
}
if (sum < n) {
printf("-1\n");
} else if (sum - t < n - 1) {
printf("1\n");
} else {
double p = getNCR(sum - t, n - 1);
double q = getNCR(sum - 1, n - 1);
double res = (q - p) / q;
printf("%.6f\n", res);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long int pow(int k) {
int temp = 1;
for (int i = 0; i < k; i++) temp *= 10;
return temp;
}
void solution() {
int n;
string s;
cin >> s;
int k = 0;
int p = s[0] - 47;
if (p > 9) {
p = 1;
p = (p * pow((s.length())));
} else
p = (p * pow(s.length() - 1));
cout << p - stoi(s);
}
int main() {
solution();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1001], mn = INT_MAX;
long long s, cnt = 0;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> s;
for (int i = 1; i <= n; i++) {
cin >> a[i];
mn = min(mn, a[i]);
}
for (int i = 1; i <= n; i++) {
cnt += a[i] - mn;
}
cout << (cnt >= s ? mn
: (mn >= (s - cnt) / n + ((s - cnt) % n == 0 ? 0 : 1)
? mn - (s - cnt) / n - ((s - cnt) % n == 0 ? 0 : 1)
: -1));
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct stru {
int index;
int value;
};
bool acompare(stru s1, stru s2) { return s1.value < s2.value; }
int main() {
int n;
cin >> n;
stru arr[n];
for (int i = 0; i < n; i++) {
arr[i].index = i;
cin >> arr[i].value;
}
sort(arr, arr + n, acompare);
int res1[n];
int res2[n];
for (int i = 0; i < n / 3; i++) {
res1[arr[i].index] = i;
res2[arr[i].index] = arr[i].value - i;
}
for (int i = n / 3; i < (2 * n) / 3; i++) {
res2[arr[i].index] = i;
res1[arr[i].index] = arr[i].value - i;
}
for (int i = (2 * n) / 3; i < n; i++) {
res2[arr[i].index] = n - 1 - i;
res1[arr[i].index] = arr[i].value - (n - 1 - i);
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
cout << res1[i] << " ";
}
cout << endl;
for (int i = 0; i < n; i++) {
cout << res2[i] << " ";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt;
int a[200020], ans[200020];
void cg(int l, int r) {
if (l > r) return;
ans[l]++;
ans[r + 1]--;
}
int main() {
cin >> n;
memset(ans, 0, sizeof ans);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
if (a[1] > a[2]) ans[1] = 1;
for (int i = 3; i <= n; i++) {
int p = i - 2;
cnt = 0;
for (; cnt * cnt < p; cnt++)
;
for (int k = 1; k <= cnt; ++k)
if (a[p / k + 1] > a[i]) cg(k, k);
for (int tmp = p / cnt + 2; tmp >= 0; --tmp) {
int l = p / (tmp + 1) + 1;
int r;
if (!tmp)
r = n;
else
r = p / tmp;
if (a[tmp + 1] > a[i]) cg(max(cnt + 1, l), r);
}
}
for (int i = 1; i < n; i++) ans[i] += ans[i - 1];
for (int i = 1; i < n; i++) printf("%d ", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct DSU {
vector<long long> M;
DSU(long long n) {
M.resize(n);
for (long long i = 0; i < n; i++) {
M[i] = i;
}
}
long long root(long long x) {
while (M[x] != x) {
long long nx = M[x];
M[x] = M[nx];
x = nx;
}
return x;
}
bool join(long long x, long long y) {
long long xr = root(x);
long long yr = root(y);
if (xr == yr) {
return false;
} else {
M[yr] = xr;
return true;
}
}
bool check(long long x, long long y) { return root(x) == root(y); }
};
long long u[2005];
int main() {
ios::sync_with_stdio(0);
long long n, m, q, x, y;
cin >> n >> m >> q;
long long z = n + m - 1;
DSU dsu(n + m);
for (long long i = 0; i < q; i++) {
cin >> x >> y;
x--;
y--;
if (dsu.join(x, y + n)) z--;
}
cout << z;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace FGF {
int n, m;
const int N = 5005, mo = 998244353;
int o[N][N], fac, inv[N], ans[N];
void work() {
scanf("%d", &n);
fac = o[0][0] = inv[0] = inv[1] = 1;
for (int i = 2; i <= n; i++)
inv[i] = 1ll * inv[mo % i] * (mo - mo / i) % mo, fac = 1ll * fac * i % mo;
for (int i = 2; i <= n; i++) inv[i] = 1ll * inv[i] * inv[i - 1] % mo;
for (int i = 1; i <= n; i++) {
o[i][0] = 1;
for (int j = 1; j <= i; j++)
o[i][j] = (1ll * (i - j) * o[i - 1][j - 1] % mo +
1ll * (j + 1) * o[i - 1][j] % mo) %
mo;
}
for (int j = 1; j <= n; j++)
for (int i = 1; i <= n; i++)
ans[j] = (ans[j] + 1ll * o[i][j - 1] * fac % mo * inv[i] % mo) % mo;
for (int j = 1; j <= n; j++) printf("%d ", ans[j]);
}
} // namespace FGF
int main() {
FGF::work();
return 0;
}
| 11 |
#include <bits/stdc++.h>
const int N = 200000;
using namespace std;
int n, m, f[N];
vector<int> ent[N];
int ans[N];
int bad;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> f[i];
ent[f[i]].push_back(i);
}
for (int i = 1; i <= m; i++) {
int val;
cin >> val;
if (ent[val].size() == 0) {
cout << "Impossible" << endl;
return 0;
}
if (ent[val].size() > 1) bad = 1;
ans[i] = ent[val][0];
}
if (bad) {
cout << "Ambiguity" << endl;
return 0;
}
cout << "Possible" << endl;
for (int i = 1; i <= m; i++) {
if (i > 1) cout << " ";
cout << ans[i];
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c;
int positive = 1;
while (!isdigit(c = getchar()))
if (c == '-') positive = 0;
do x = x * 10 + c - '0';
while (isdigit(c = getchar()));
if (!positive) x = -x;
}
template <typename T>
inline void write(T x) {
if (x > 9) write(x / 10);
putchar(x % 10 + 48);
}
const int maxn = 200010;
const int maxlevel = 18;
int s[maxn];
int f[maxn][maxlevel];
long long d[maxn][maxlevel];
int a[maxn];
int n;
vector<int> e[maxn];
int h[maxn];
int pw[maxlevel];
void input() {
read(n);
for (int i = (1), _b = (n); i <= _b; i++) read(a[i]);
for (int i = (2), _b = (n); i <= _b; i++) {
int u, v;
read(u);
read(v);
f[i][0] = u;
d[i][0] = v;
e[u].push_back(i);
}
}
void init() {
pw[0] = 1;
for (int i = (1), _b = (maxlevel); i < _b; i++) pw[i] = pw[i - 1] * 2;
}
void dfs(int u) {
for (int i = (0), _b = (int((e[u]).size())); i < _b; i++)
dfs(e[u][i]), s[u] += s[e[u][i]];
}
void go(int u, int pa) {
h[u] = h[pa] + 1;
for (int i = (0), _b = (int((e[u]).size())); i < _b; i++) go(e[u][i], u);
}
long long get(int u, int dist) {
long long tot = 0;
for (int i = (maxlevel - 1), _a = (0); i >= _a; i--)
if (pw[i] <= dist) {
dist -= pw[i];
tot += d[u][i];
u = f[u][i];
}
return tot;
}
int getpa(int u, int dist) {
for (int i = (maxlevel - 1), _a = (0); i >= _a; i--)
if (pw[i] <= dist) {
dist -= pw[i];
u = f[u][i];
}
return u;
}
void solve() {
go(1, 0);
for (int i = (1), _b = (maxlevel); i < _b; i++)
for (int j = (1), _b = (n); j <= _b; j++) {
f[j][i] = f[f[j][i - 1]][i - 1];
d[j][i] = d[j][i - 1] + d[f[j][i - 1]][i - 1];
}
for (int i = (2), _b = (n); i <= _b; i++) {
int l = 1, r = h[i] - 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (get(i, mid) <= a[i])
l = mid + 1;
else
r = mid - 1;
}
if (r) s[f[getpa(i, r)][0]]--, s[f[i][0]]++;
}
dfs(1);
}
void output() {
for (int i = (1), _b = (n); i <= _b; i++) write(s[i]), putchar(' ');
}
int main() {
clock_t timestart, timeend;
timestart = clock();
input();
init();
solve();
output();
timeend = clock();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100010;
int primes[MAX_N + 1] = {0};
void Eratos() {
fill_n(primes, MAX_N + 1, 1);
primes[0] = primes[1] = false;
for (int i = 2; i * i <= MAX_N; i++) {
if (primes[i] == 1) {
for (int j = i * i; j <= MAX_N; j += i) {
primes[j] = 2;
}
}
}
}
class TaskB {
public:
void solve(std::istream& in, std::ostream& out) {
Eratos();
int n;
in >> n;
int cnt = 0;
bool flag1 = false, flag2 = false;
for (int i = 2; i <= n + 1; i++) {
if (flag1 && flag2) {
break;
}
if (!flag1 && primes[i] == 1) {
flag1 = true;
cnt++;
}
if (!flag2 && primes[i] != 1) {
flag2 = true;
cnt++;
}
}
out << cnt << "\n";
for (int i = 2; i <= n + 1; i++) {
out << primes[i] << " ";
}
}
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
TaskB solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void smain();
int main() {
ios_base::sync_with_stdio(0);
smain();
return 0;
}
long long n, m, L, p[30003], ps[30003];
long long d[30003][500];
map<long long, long long> md[30003];
inline void update(long long j, long long l, long long v) {
if (l < 500) {
d[j][l] = max(d[j][l], v);
} else {
if (md[j].count(l) == 0)
md[j].insert(make_pair(l, v));
else if (md[j].at(l) < v)
md[j].at(l) = v;
}
}
void smain() {
for (long long t = 0; cin >> n >> L; ++t) {
memset(d, 255, sizeof(d));
m = 0;
for (long long i = 0; i < n; i++) {
long long v;
cin >> v;
p[v] += 1;
m = max(v, m);
}
for (long long i = m + 1 - 1; i >= 0; i--) ps[i] = ps[i + 1] + p[i];
update(L, L, 0);
long long res = 0;
for (long long i = L; i <= m; ++i) {
for (long long j = 0; j < 500; j++)
if (d[i][j] != -1) {
long long l = j;
if (l <= 2) {
res = max(res, d[i][j] + ps[i]);
continue;
} else {
long long v = d[i][j] + p[i];
res = max(res, d[i][j] + p[i]);
if (i + l - 1 <= m) update(i + l - 1, l - 1, v);
if (i + l <= m) update(i + l, l, v);
if (i + l + 1 <= m) update(i + l + 1, l + 1, v);
}
}
for (auto it = md[i].begin(); it != md[i].end(); ++it) {
long long l = it->first;
if (l <= 2) {
res = max(res, it->second + ps[i]);
continue;
} else {
res = max(res, it->second + p[i]);
if (i + l - 1 <= m) update(i + l - 1, l - 1, it->second + p[i]);
if (i + l <= m) update(i + l, l, it->second + p[i]);
if (i + l + 1 <= m) update(i + l + 1, l + 1, it->second + p[i]);
}
}
}
cout << res << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<long long> A(n + 1, 0);
for (int i = 1; i <= n; i++) cin >> A[i];
long long K = 0;
for (int i = 2; i <= n; i++) K += max(A[i] - A[i - 1], 0LL);
long long ans = (long long)ceil((A[1] + K) / 2.00);
cout << max(ans, A[1] - ans + K) << "\n";
for (int i = n; i >= 2; i--) A[i] -= A[i - 1];
int q;
cin >> q;
while (q--) {
int l, r;
long long x;
cin >> l >> r >> x;
if (l > 1) {
K += max(0LL, A[l] + x) - max(0LL, A[l]);
A[l] += x;
} else
A[1] += x;
if (r < n) {
K += max(0LL, A[r + 1] - x) - max(0LL, A[r + 1]);
A[r + 1] -= x;
}
ans = (long long)ceil((A[1] + K) / 2.00);
cout << max(ans, A[1] - ans + K) << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
long long int l, r;
cin >> T;
while (T--) {
cin >> l >> r;
cout << l << " " << 2 * l << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> open, close;
set<int> color;
set<int>::iterator iter;
int main() {
int n, o, c;
int res = 0x3f3f3f3f;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &o, &c), color.insert(o), color.insert(c);
open[o]++;
if (c != o) close[c]++;
}
for (iter = color.begin(); iter != color.end(); iter++) {
int cur = *iter;
int curCnt = open[cur];
int need = n / 2 - curCnt + (n % 2);
if (need < 0) need = 0;
if (close[cur] >= need) res = min(res, need);
}
if (res == 0x3f3f3f3f)
puts("-1");
else
printf("%d\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int ans = 1e9;
char ansc = s[0];
for (int i = 0; i < 26; i++) {
char c = (char)'a' + i;
int mx = 0;
int prev = 0;
bool f = false;
for (int j = 0; j < s.size(); j++) {
if (s[j] == c && f) {
prev = j;
}
mx = max(j - prev + 1, mx);
if (s[j] == c && !f) {
prev = j;
f = true;
}
}
if (f) {
if (mx < ans) {
ans = mx;
ansc = c;
}
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000")
const int md = 1000000007;
using namespace std;
struct r {
int a, id;
};
int n, i, p, a[300005];
long long q;
r b[100005];
bool comp(r a, r b) { return (a.a < b.a || (a.a == b.a && a.id < b.id)); }
int build_tree(int n) {
int j = 1;
while (j < n) j *= 2;
for (int i = 1; i <= j + n - 1; i++) a[i] = 0;
return j - 1;
}
void renew(int v) {
v /= 2;
while (v > 0) {
a[v] = (a[2 * v] + a[2 * v + 1]) % md;
v /= 2;
}
}
long long find(int l, int r) {
long long ans = 0;
while (l <= r) {
if (l % 2 == 1) {
ans += a[l];
l++;
}
if (r % 2 == 0) {
ans += a[r];
r--;
}
l /= 2;
r /= 2;
}
return ans % md;
}
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> b[i].a;
b[i].id = i;
}
sort(b + 1, b + n + 1, comp);
p = build_tree(n);
i = 1;
while (i <= n) {
q = find(p + 1, p + b[i].id - 1);
q = (q * b[i].a + b[i].a) % md;
a[p + b[i].id] = q;
renew(p + b[i].id);
while (i + 1 <= n && b[i].a == b[i + 1].a) {
i++;
q = a[p + b[i - 1].id] + find(p + b[i - 1].id + 1, p + b[i].id - 1);
q = (q * b[i].a) % md;
a[p + b[i].id] = q;
renew(p + b[i].id);
}
i++;
}
long long ans = 0;
for (i = p + 1; i <= p + n; i++) ans += a[i];
cout << ans % md << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long long a[n + 1], i;
map<long long, long long> mp;
long long maxi = 0, mini = INT_MAX;
pair<long long, long long> p[n + 1];
for (i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
maxi = max(maxi, a[i]);
mini = min(mini, a[i]);
p[i].first = a[i];
p[i].second = i;
}
sort(p, p + n);
for (i = 2; i <= maxi; i++) {
if (mp[i] > mp[i - 1]) {
cout << -1 << endl;
return;
}
}
long long k = 1, l = 1;
pair<long long, long long> pr[n + 1];
pr[0].first = p[0].second;
pr[0].second = l;
for (i = 1; i < n; i++) {
if (p[i].first == p[i - 1].first) {
l++;
pr[i].first = p[i].second;
pr[i].second = l;
} else {
l = 1;
pr[i].first = p[i].second;
pr[i].second = l;
}
}
sort(pr, pr + n);
cout << mp[mini] << endl;
for (i = 0; i < n; i++) cout << pr[i].second << " ";
cout << endl;
}
int main() {
long long t = 1;
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_NUM = 1e6;
const double e = 1e-8;
int n, k, m;
int coor[MAX_NUM][5];
struct Point {
int x;
int y;
bool operator<(const Point p) const {
if (x == p.x && y == p.y) {
return false;
}
return x < p.x ? x < p.x : y < p.y;
}
bool operator==(const Point p) const { return x == p.x && y == p.y; }
Point operator-(const Point p) const {
Point result = {x - p.x, y - p.y};
return result;
}
};
struct Segment {
Point v1;
Point v2;
};
long double cross_product(Point a, Point b) { return a.x * b.y - a.y * b.x; }
long double seg_length(Segment s) {
double x = s.v2.x - s.v1.x;
double y = s.v2.y - s.v1.y;
return sqrt(pow(x, 2) + pow(y, 2));
}
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
long long int num_int_points_on_segment(Segment s) {
long long int result = gcd(abs(s.v1.y - s.v2.y), abs(s.v1.x - s.v2.x)) + 1;
return result;
}
bool is_intersect(Segment s1, Segment s2) {
Point m1, m2;
m1 = s1.v2 - s1.v1;
m2 = s2.v1 - s1.v1;
long double q1 = m1.x * m2.y - m1.y * m2.x;
m2 = s2.v2 - s1.v1;
long double q2 = m1.x * m2.y - m1.y * m2.x;
m1 = s2.v2 - s2.v1;
m2 = s1.v1 - s2.v1;
long double q3 = m1.x * m2.y - m1.y * m2.x;
m2 = s1.v2 - s2.v1;
long double q4 = m1.x * m2.y - m1.y * m2.x;
if (q1 * q2 <= 0 && q3 * q4 <= 0) {
return true;
} else {
return false;
}
}
long double distance(Point v1, Point v2) {
Segment d = {v1, v2};
return seg_length(d);
}
set<pair<int, int>> intersecs;
bool is_integer(double x) { return fabs(x - round(x)) <= e; }
bool are_equal(double a, double b) { return fabs(a - b) <= e; }
void solve_line(int x, double& k, double& b) {
k = (double)(coor[x][3] - coor[x][1]) / (coor[x][2] - coor[x][0]);
b = (double)coor[x][1] - k * coor[x][0];
}
void is_intersect_lattice(int i, int j) {
if (coor[i][0] == coor[i][2] && coor[j][0] == coor[j][2]) return;
if (coor[i][1] == coor[i][3] && coor[j][1] == coor[j][3]) return;
if (are_equal((double)(coor[i][3] - coor[i][1]) / (coor[i][2] - coor[i][0]),
(double)(coor[j][3] - coor[j][1]) / (coor[j][2] - coor[j][0])))
return;
double k1, k2, b1, b2;
solve_line(i, k1, b1);
solve_line(j, k2, b2);
double x, y;
if (coor[i][0] == coor[i][2]) {
x = coor[i][0];
y = k2 * x + b2;
} else if (coor[j][0] == coor[j][2]) {
x = coor[j][0];
y = k1 * x + b1;
} else {
x = (b2 - b1) / (k1 - k2);
y = k1 * x + b1;
}
if (!is_integer(x) || !is_integer(y)) return;
int xx = round(x), yy = round(y);
if (xx >= min(coor[i][0], coor[i][2]) && xx <= max(coor[i][0], coor[i][2]) &&
yy >= min(coor[i][1], coor[i][3]) && yy <= max(coor[i][1], coor[i][3]) &&
xx >= min(coor[j][0], coor[j][2]) && xx <= max(coor[j][0], coor[j][2]) &&
yy >= min(coor[j][1], coor[j][3]) && yy <= max(coor[j][1], coor[j][3])) {
intersecs.insert(make_pair(xx, yy));
}
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 4; j++) {
scanf("%d", &coor[i][j]);
}
}
long long int num_convered_points = 0;
for (int i = 0; i < n; i++) {
int xx = abs(coor[i][2] - coor[i][0]);
int yy = abs(coor[i][3] - coor[i][1]);
num_convered_points += gcd(xx, yy) + 1;
}
for (int i = 0; i < n; i++) {
intersecs.clear();
for (int j = i + 1; j < n; j++) {
is_intersect_lattice(i, j);
}
num_convered_points -= intersecs.size();
}
cout << num_convered_points << endl;
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.