solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 100050;
const int M = 2 * N;
const int K = 21;
const int inf = 1e9 + 7;
struct seg {
int sum, l, r;
seg() {}
seg(int x, int i) : sum(x), l(i), r(i) {}
seg(int x, int a, int b) : sum(x), l(a), r(b) {}
};
bool operator>(seg a, seg b) { return a.sum > b.sum; }
seg operator+(seg a, seg b) { return seg(a.sum + b.sum, a.l, b.r); }
seg max(seg a, seg b) { return a > b ? a : b; }
seg min(seg a, seg b) { return a > b ? b : a; }
struct Node {
seg best[2][2], ans[2], sum;
Node() {}
void init(int x, int i) {
best[0][0] = max(seg(x, i), seg(0, i, i - 1));
best[1][0] = max(seg(x, i), seg(0, i + 1, i));
best[0][1] = min(seg(x, i), seg(0, i, i - 1));
best[1][1] = min(seg(x, i), seg(0, i + 1, i));
ans[0] = max(seg(x, i), seg(0, i, i - 1));
ans[1] = min(seg(x, i), seg(0, i, i - 1));
sum = seg(x, i);
}
void Flip() {
sum.sum *= -1;
swap(ans[0], ans[1]);
ans[0].sum *= -1;
ans[1].sum *= -1;
swap(best[0][0], best[0][1]);
best[0][0].sum *= -1;
best[0][1].sum *= -1;
swap(best[1][0], best[1][1]);
best[1][0].sum *= -1;
best[1][1].sum *= -1;
}
};
Node operator+(Node a, Node b) {
Node c;
c.ans[0] = max(a.ans[0], b.ans[0]);
c.ans[0] = max(c.ans[0], a.best[1][0] + b.best[0][0]);
c.ans[1] = min(a.ans[1], b.ans[1]);
c.ans[1] = min(c.ans[1], a.best[1][1] + b.best[0][1]);
c.sum = a.sum + b.sum;
c.best[0][0] = max(a.best[0][0], a.sum + b.best[0][0]);
c.best[0][1] = min(a.best[0][1], a.sum + b.best[0][1]);
c.best[1][0] = max(b.best[1][0], a.best[1][0] + b.sum);
c.best[1][1] = min(b.best[1][1], a.best[1][1] + b.sum);
return c;
}
int ls[M], rs[M], tsz, root, lzy[M], a[N];
Node node[M];
void Build(int &c, int ss, int se) {
c = ++tsz;
lzy[c] = 0;
if (ss == se) {
node[c].init(a[ss], ss);
return;
}
int mid = ss + se >> 1;
Build(ls[c], ss, mid);
Build(rs[c], mid + 1, se);
node[c] = node[ls[c]] + node[rs[c]];
}
void push(int c) {
if (!lzy[c]) return;
node[ls[c]].Flip();
node[rs[c]].Flip();
lzy[ls[c]] ^= 1;
lzy[rs[c]] ^= 1;
lzy[c] = 0;
}
void Flip(int c, int ss, int se, int qs, int qe) {
if (qs > qe || qs > se || ss > qe) return;
if (qs <= ss && qe >= se) {
lzy[c] ^= 1;
node[c].Flip();
return;
}
push(c);
int mid = ss + se >> 1;
Flip(ls[c], ss, mid, qs, qe);
Flip(rs[c], mid + 1, se, qs, qe);
node[c] = node[ls[c]] + node[rs[c]];
}
void Set(int c, int ss, int se, int qi, int val) {
if (ss == se) {
node[c].init(val, ss);
return;
}
push(c);
int mid = ss + se >> 1;
if (qi <= mid)
Set(ls[c], ss, mid, qi, val);
else
Set(rs[c], mid + 1, se, qi, val);
node[c] = node[ls[c]] + node[rs[c]];
}
Node Get(int c, int ss, int se, int qs, int qe) {
if (qs <= ss && qe >= se) return node[c];
push(c);
int mid = ss + se >> 1;
if (qe <= mid) return Get(ls[c], ss, mid, qs, qe);
if (qs > mid) return Get(rs[c], mid + 1, se, qs, qe);
return Get(ls[c], ss, mid, qs, qe) + Get(rs[c], mid + 1, se, qs, qe);
}
int main() {
int n, q, i, t, l, r, k, x;
scanf("%i", &n);
for (i = 1; i <= n; i++) scanf("%i", &a[i]);
Build(root, 1, n);
scanf("%i", &q);
while (q--) {
scanf("%i", &t);
if (t == 0)
scanf("%i %i", &i, &x), Set(root, 1, n, i, x);
else {
scanf("%i %i %i", &l, &r, &k);
vector<pair<int, int>> fl;
int ans = 0;
while (k--) {
Node tmp = Get(root, 1, n, l, r);
ans += tmp.ans[0].sum;
fl.push_back({tmp.ans[0].l, tmp.ans[0].r});
Flip(root, 1, n, tmp.ans[0].l, tmp.ans[0].r);
}
for (auto p : fl) Flip(root, 1, n, p.first, p.second);
printf("%i\n", ans);
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int fa[1005], ka[1005], kb[1005], kRoom[1005];
map<string, int> proom;
int getf(int x) {
if (x == fa[x]) return x;
return getf(fa[x]);
}
void ds(int d[]) {
for (int i = 1; i <= n; i++) fa[i] = i;
bool bl = true;
while (bl) {
bl = false;
for (int j = 1; j <= m; j++) {
if (!d[j] &&
(getf(kRoom[j]) == getf(ka[j]) || getf(kRoom[j]) == getf(kb[j]))) {
bl = true;
d[j] = 1;
fa[getf(ka[j])] = getf(kb[j]);
}
}
}
}
int main() {
string s;
int room, keys, kk;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
scanf("%d%d", ka + i, kb + i);
}
for (int i = 1; i <= k; i++) {
cin >> s >> room >> keys;
proom[s] = room;
for (int j = 1; j <= keys; j++) {
scanf("%d", &kk);
kRoom[kk] = room;
}
}
int d[m + 2], dd[m + 2];
memset(d, 0, sizeof d);
memset(dd, 0, sizeof dd);
ds(d);
for (int i = 1; i <= k; i++) {
cin >> s >> room >> keys;
if (getf(proom[s]) != getf(room)) {
puts("NO");
return 0;
}
proom[s] = room;
for (int j = 1; j <= keys; j++) {
scanf("%d", &kk);
if (getf(kRoom[kk]) != getf(room)) {
puts("NO");
return 0;
}
kRoom[kk] = room;
}
}
ds(dd);
for (int i = 1; i <= m; i++) {
if (d[i] != dd[i]) {
puts("NO");
return 0;
}
}
puts("YES");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
vector<int> e[maxn];
int vis[maxn], v[maxn], ans[maxn], id = 0;
bool flag = 1;
void dfs(int u) {
if (!flag) return;
if (vis[u] == 0) {
vis[u] = 1;
for (auto &v : e[u]) dfs(v);
vis[u] = 2;
ans[id++] = u;
} else if (vis[u] == 1)
flag = 0;
}
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
fill(vis, vis + maxn, 0);
for (int i = 1; i <= k; i++) cin >> v[i];
for (int i = 1; i <= n; i++) {
int num;
cin >> num;
for (int j = 0; j < num; j++) {
int t;
cin >> t;
e[i].push_back(t);
}
}
for (int i = 1; i <= k; i++) {
if (!flag) break;
if (vis[v[i]] > 0) continue;
dfs(v[i]);
}
if (flag) {
cout << id << '\n';
for (int i = 0; i < id; i++) cout << ans[i] << ' ';
cout << '\n';
} else {
cout << "-1\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 10;
const int inf = 1e9;
int a[N];
bool comp(int x, int y) { return x % 10 > y % 10; }
int main() {
int n, k;
cin >> n >> k;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, comp);
int cont = 0;
for (int i = 0; i < n; i++) {
int b = 10 - (a[i] % 10);
if (k - b >= 0) {
a[i] += b;
k -= b;
}
ans += (a[i] / 10);
cont += (100 - a[i]);
}
cout << ans + (min(k, cont) / 10) << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int gr[] = {0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5,
5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7,
7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9,
9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10};
int main() {
int n;
scanf("%d", &n);
int ans = 0;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
ans ^= gr[a];
}
if (ans == 0)
printf("YES");
else
printf("NO");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve() {
int n;
cin >> n;
vector<int> v;
v.push_back(0);
for (int i = 1; i <= sqrt(n); i++) {
v.push_back(i);
if (n / i != i) {
v.push_back(n / i);
}
}
sort(v.begin(), v.end());
cout << v.size() << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << endl;
}
int main() {
int t;
t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
long long extgcd(long long a, long long b, long long& x, long long& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
int g = extgcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
}
long long modpow(long long a, long long b) {
long long res = 1;
a %= 1000000007;
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
const int sz = 2e5 + 5;
int a[sz], n;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ifstream in("input.txt");
ofstream out("output.txt");
cin >> n;
int diff = 1;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i) {
int d = abs(a[i] - a[i - 1]);
if (d != 1 && d) {
if (diff == 1)
diff = d;
else if (diff != d) {
cout << "NO" << endl;
return 0;
}
}
if (!d) {
cout << "NO" << endl;
return 0;
}
}
}
if (diff == 1) {
cout << "YES" << endl;
int pp = 1e9;
cout << pp << " " << diff << endl;
return 0;
}
for (int i = 1; i < n; i++) {
if (abs(a[i] - a[i - 1]) == 1) {
if ((a[i] - 1) / diff != (a[i - 1] - 1) / diff) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
int pp = 1e9;
cout << pp << " " << diff << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> A(n);
vector<vector<int>> idx(5001);
for (int i = 0; i < n; i++) {
cin >> A[i];
idx[A[i]].push_back(i);
}
for (int i = 0; i <= 5000; ++i) {
sort(idx[i].begin(), idx[i].end());
}
vector<int> dp(8192, -1);
dp[0] = 1e9;
for (int v = 5000; v >= 0; --v) {
if (idx[v].empty()) continue;
for (int t = 0; t < 8192; ++t) {
int id = dp[t ^ v];
if (id == -1) continue;
auto it = lower_bound(idx[v].begin(), idx[v].end(), id);
if (it == idx[v].begin()) continue;
it = prev(it);
dp[t] = max(*it, dp[t]);
}
}
int cnt = 0;
for (int t = 0; t < 8192; ++t)
if (dp[t] != -1) cnt++;
cout << cnt << endl;
for (int t = 0; t < 8192; ++t)
if (dp[t] != -1) cout << t << " ";
cout << endl;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int n, m, x, p[500005];
int w[500005], u[500005], mom[500005], timer = 1;
vector<int> cyc;
set<int> g[500005];
vector<pair<int, int>> e;
void dfs(int v, int par) {
u[v] = 1;
p[v] = par;
for (auto to : g[v]) {
p[to] = v;
if (u[to] == 0)
dfs(to, v);
else if (u[to] == 1 && !cyc.size()) {
int cur = v;
cyc.push_back(cur);
while (cur != to && p[cur] != cur) {
cur = p[cur];
cyc.push_back(cur);
}
reverse(cyc.begin(), cyc.end());
cyc.push_back(cyc.front());
}
}
u[v] = 2;
}
void have(int v) {
u[v] = 1;
for (auto to : g[v]) {
if (u[to] == 0)
have(to);
else if (u[to] == 1) {
x = 1;
}
}
u[v] = 2;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cout.precision(30);
cerr.precision(7);
;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int v1, v2;
cin >> v1 >> v2;
g[v1].insert(v2);
}
for (int i = 1; i <= n; i++)
if (!u[i]) {
dfs(i, 0), timer++;
};
if (!cyc.size()) {
cout << "YES\n";
return 0;
}
for (int i = 1; i < cyc.size(); i++) {
e.push_back({cyc[i - 1], cyc[i]});
}
for (auto r : e) {
g[r.first].erase(r.second);
x = 0;
for (int i = 1; i <= n; i++) u[i] = 0;
for (int i = 1; i <= n; i++)
if (!u[i] && !x) have(i);
if (!x) {
cout << "YES\n";
return 0;
}
g[r.first].insert(r.second);
}
cout << "NO\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
const long long inf_ll = 1e18;
const long long N = 500005, S = 800;
long long a[S][S], c[S];
multiset<long long> f[S];
void inc(long long i, long long x) {
long long& y = a[i / S][i % S];
f[i / S].erase(f[i / S].find(y));
y += x;
f[i / S].insert(y);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, q;
cin >> n >> q;
for (long long i = 0; i < n; i++) {
cin >> a[i / S][i % S];
f[i / S].insert(a[i / S][i % S]);
}
while (q--) {
long long t;
cin >> t;
if (t == 1) {
long long l, r, x;
cin >> l >> r >> x;
l--, r--;
if (l / S == r / S)
for (long long i = l; i <= r; i++) inc(i, x);
else {
for (long long i = l / S + 1; i < r / S; i++) c[i] += x;
for (long long i = l; i < (l / S + 1) * S; i++) inc(i, x);
for (long long i = (r / S) * S; i <= r; i++) inc(i, x);
}
} else {
long long y;
cin >> y;
long long l = inf, r = -inf;
;
for (long long i = 0; i <= (n - 1) / S; i++)
if (f[i].find(y - c[i]) != f[i].end())
l = min(l, i * S), r = max(r, (i + 1) * S - 1);
if (l == inf)
cout << "-1\n";
else {
while (a[l / S][l % S] != y - c[l / S]) l++;
while (a[r / S][r % S] != y - c[r / S]) r--;
cout << r - l << "\n";
}
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 220000;
const int MAXM = 2 * MAXN;
int n, m;
int tot, to[MAXM], rnk[MAXM];
vector<int> g[MAXN], h[MAXN];
pair<vector<int>, int> c[MAXN];
int cnt, near[MAXM], pos[MAXN];
bool used[MAXM];
int sz[MAXN], mx[MAXN], col[MAXN];
int sum, root;
bool vis[MAXN];
bool cmp(int a, int b) { return to[a] < to[b]; }
void addEdge(int u, int v) {
to[tot] = v, g[u].push_back(tot++);
to[tot] = u, g[v].push_back(tot++);
}
void find_loop(int u, int e) {
cnt++;
while (!used[e]) {
c[cnt].first.push_back(u);
used[e] = 1, near[e] = cnt, u = to[e];
e = rnk[e ^ 1] ? g[u][rnk[e ^ 1] - 1] : g[u].back();
}
sort(c[cnt].first.begin(), c[cnt].first.end(), greater<int>());
c[cnt].second = cnt;
}
int get_sz(int u, int f) {
int siz = 1;
for (int v : h[u])
if (!vis[v] && v != f) siz += get_sz(v, u);
return siz;
}
void get_root(int u, int f) {
sz[u] = 1, mx[u] = 0;
for (int v : h[u])
if (!vis[v] && v != f) {
get_root(v, u);
sz[u] += sz[v];
mx[u] = max(mx[u], sz[v]);
}
mx[u] = max(mx[u], sum - sz[u]);
if (mx[u] < mx[root]) root = u;
}
void solve(int u, int d) {
vis[u] = 1, col[u] = d;
for (int v : h[u])
if (!vis[v]) {
sum = get_sz(v, u), root = 0;
get_root(v, u);
solve(root, d + 1);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) addEdge(i, i % n + 1);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
addEdge(a, b);
}
for (int u = 1; u <= n; u++) {
sort(g[u].begin(), g[u].end(), cmp);
for (int i = 0; i < g[u].size(); i++) rnk[g[u][i]] = i;
}
for (int u = 1; u <= n; u++)
for (int e : g[u])
if (!used[e]) find_loop(u, e);
sort(c + 1, c + cnt + 1);
cnt--;
for (int i = 1; i <= cnt; i++) pos[c[i].second] = i;
for (int i = 0; i < tot; i += 2) {
int u = pos[near[i]], v = pos[near[i ^ 1]];
if (u && v) h[u].push_back(v), h[v].push_back(u);
}
mx[0] = sum = cnt, root = 0;
get_root(1, 0);
solve(root, 1);
for (int i = 1; i <= cnt; i++) printf("%d ", col[i]);
putchar('\n');
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int MAXN = 200100;
int a[MAXN], N;
int best[2][MAXN], B[2];
int main() {
ios::sync_with_stdio(false);
cin >> N;
for (int i = (0); i < (N); i++) cin >> a[i];
for (int i = (0); i < (N); i++) a[i] -= i;
B[0] = B[1] = 0;
for (int i = (0); i < (N); i++) {
int lo = 0, hi = B[1];
while (lo != hi) {
int m = lo + (hi - lo) / 2;
if (best[1][m] <= a[i])
lo = m + 1;
else
hi = m;
}
B[1] = max(B[1], lo + 1);
best[1][lo] = a[i];
lo = 0, hi = B[0];
while (lo != hi) {
int m = lo + (hi - lo) / 2;
if (best[0][m] - 1 <= a[i])
lo = m + 1;
else
hi = m;
}
if (lo != 0 && best[0][lo - 1] - 1 == a[i] && a[i - 1] != best[0][lo - 1]) {
B[1] = max(B[1], lo + 1);
best[1][lo] = a[i];
while (lo > 0 && best[1][lo - 1] == best[1][lo] + 1) best[1][--lo]--;
}
lo = 0, hi = B[0];
while (lo != hi) {
int m = lo + (hi - lo) / 2;
if (best[0][m] <= a[i])
lo = m + 1;
else
hi = m;
}
B[0] = max(B[0], lo + 1);
best[0][lo] = a[i];
}
cout << min(max(0, N - B[0] - 1), max(0, N - B[1] - 1)) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3007;
int n, m, l[maxn][maxn], r[maxn][maxn], len[maxn];
vector<int> o[maxn];
char c[maxn][maxn];
int sum[maxn];
void update(int x, int w) {
for (; x < maxn; x += ((x) & (-(x)))) sum[x] += w;
}
int query(int x) {
int r = 0;
for (; x > 0; x -= ((x) & (-(x)))) {
r += sum[x];
}
return r;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%s", c[i] + 1);
for (int j = 1; j <= m; ++j)
if (c[i][j] == 'z') l[i][j] = l[i][j - 1] + 1;
for (int j = m; j >= 1; --j)
if (c[i][j] == 'z') r[i][j] = r[i][j + 1] + 1;
}
long long res = 0;
for (int i = 1; i <= n + m - 1; ++i) {
memset(sum, 0, sizeof(sum));
int y = min(m, i);
int le = 0;
vector<pair<int, int> > dia;
int x = max(1, i + 1 - y);
dia.push_back(make_pair(0, 0));
while (y >= 1 && x <= n) {
if (c[x][y] == '.') le = -1;
len[dia.size()] = ++le;
o[dia.size()].clear();
dia.push_back(make_pair(x, y));
--y;
++x;
}
for (int i = dia.size() - 1; i >= 1; --i) {
update(i, 1);
o[max(i - min(len[i], r[dia[i].first][dia[i].second]), 0)].push_back(i);
for (int j = 0; j < o[i].size(); ++j) update(o[i][j], -1);
res +=
query(min(i + l[dia[i].first][dia[i].second] - 1, n)) - query(i - 1);
}
}
printf("%I64d\n", res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2, s3;
map<char, char> mp;
cin >> s1 >> s2 >> s3;
for (int i = 0; i < s1.size(); ++i) {
mp[s1[i]] = s2[i];
mp[s1[i] - ' '] = s2[i] - ' ';
}
for (int i = 0; i < s3.size(); ++i) {
if (s3[i] >= 'a' && s3[i] <= 'z' || s3[i] >= 'A' && s3[i] <= 'Z')
cout << mp[s3[i]];
else
cout << s3[i];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int M = 300005;
struct Edge {
int next, to, w;
} edge[M << 1];
int head[N], cnt, n, m, q[N * 20], S;
void save(int a, int b, int c = 0) {
edge[cnt] = (Edge){head[a], b, c}, head[a] = cnt++;
}
int dep[N], fa[N][22];
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
for (int i = 19; ~i; --i)
if (dep[fa[x][i]] >= dep[y]) {
x = fa[x][i];
}
if (x == y) return x;
for (int i = 19; ~i; --i)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
bool inq[N];
long long dis[N];
vector<pair<int, int> > vec[N];
vector<int> rev[N];
void spfa() {
int h, t;
q[h = t = 0] = S;
memset(dis, 63, sizeof(dis));
dis[S] = 0;
inq[S] = 1;
while (h <= t) {
int x = q[h++];
for (pair<int, int> a : vec[x]) {
int d = a.second, y = a.first;
if (dis[y] > dis[x] + d) {
dis[y] = dis[x] + d;
if (!inq[y]) q[++t] = y;
}
}
inq[x] = 0;
}
}
int deg[N];
namespace Graph {
int head[N], cnt, cur[N];
struct Edge {
int next, to;
} edge[N << 1];
void save(int a, int b) { edge[cnt] = (Edge){head[a], b}, head[a] = cnt++; }
void dfs(int x) {
cur[x] = 1;
for (int i = head[x]; ~i; i = edge[i].next) {
dfs(edge[i].to);
cur[x] += cur[edge[i].to];
}
}
} // namespace Graph
void toposort() {
int h = 0, t = 0;
q[0] = S;
dep[S] = 2;
while (h <= t) {
int x = q[h++];
if (x != S) {
int lca = *rev[x].begin();
for (int y : rev[x]) lca = LCA(y, lca);
dep[x] = dep[lca] + 1;
fa[x][0] = lca;
for (int i = 1; i <= 19; ++i) fa[x][i] = fa[fa[x][i - 1]][i - 1];
Graph ::save(lca, x);
}
for (int i = head[x]; ~i; i = edge[i].next)
if ((--deg[edge[i].to]) == 0) q[++t] = edge[i].to;
}
}
int main() {
memset(head, -1, sizeof(head));
memset(Graph ::head, -1, sizeof(Graph ::head));
scanf("%d%d%d", &n, &m, &S);
for (int i = 1; i <= m; ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
vec[a].push_back(make_pair(b, c));
vec[b].push_back(make_pair(a, c));
}
spfa();
dep[0] = 1;
for (int i = 1; i <= n; ++i) {
for (pair<int, int> c : vec[i])
if (dis[c.first] == dis[i] + c.second)
deg[c.first]++, save(i, c.first, 0), rev[c.first].push_back(i);
}
toposort();
Graph ::dfs(S);
int mx = 0;
for (int i = 1; i <= n; ++i)
if (i != S) mx = max(mx, Graph ::cur[i]);
printf("%d\n", mx);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, z, a[1001000], dp[202][202][202];
long long solve(int pos, int lerigo, int lft) {
if (lerigo < 0 || lft < 0) return -1000000000000000LL;
if (pos == n && lft == 0) return 0;
if (pos == n) return -1000000000000000LL;
long long &x = dp[pos][lerigo][lft];
if (x != -1) return x;
x = max(solve(pos + 1, lerigo - 1, lft),
solve(pos + 1, k - 1, lft - 1) + a[pos]);
return x;
}
int main() {
scanf("%lld %lld %lld", &n, &k, &z);
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
printf("%lld\n", max(-1LL, solve(0, k - 1, z)));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char pole[52][52];
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= n + 1; j++) {
pole[i][j] = '#';
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> pole[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (pole[i][j] == '.') {
if (pole[i - 1][j] == '.' && pole[i][j - 1] == '.' &&
pole[i][j + 1] == '.' && pole[i + 1][j] == '.') {
pole[i - 1][j] = '#';
pole[i][j - 1] = '#';
pole[i][j + 1] = '#';
pole[i + 1][j] = '#';
pole[i][j] = '#';
}
}
}
}
bool res = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (pole[i][j] == '.') {
res = 0;
}
}
}
if (res == 1) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long w, l;
cin >> w >> l;
vector<long long> a(w);
long long res = 4154118101919364364;
for (int i = 1; i <= w - 1; i++) {
cin >> a[i];
a[i] += a[i - 1];
if (i >= l) {
res = min(a[i] - a[i - l], res);
}
}
cout << res << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops, no-stack-protector")
#pragma GCC target("avx,avx2,fma")
using namespace std;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
using vb = vector<bool>;
using vi = vector<int>;
using vl = vector<long long>;
using vvb = vector<vector<bool>>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<long long>>;
using vpii = vector<pair<int, int>>;
using mii = map<int, int>;
using umii = unordered_map<int, int>;
using seti = set<int>;
using useti = unordered_set<int>;
template <typename... ArgTypes>
void print(ArgTypes... args);
template <typename... ArgTypes>
void input(ArgTypes &...args);
template <>
void print() {}
template <>
void input() {}
template <typename T, typename... ArgTypes>
void print(T t, ArgTypes... args) {
cout << t;
print(args...);
}
template <typename T, typename... ArgTypes>
void input(T &t, ArgTypes &...args) {
cin >> t;
input(args...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
string s, t;
cin >> s;
t = s;
int r = 0;
int last = 0;
for (int i = 0; i < (n); (i)++)
if (s[i] == 'L') {
r += i - last;
last++;
}
int l = 0;
list<int> current;
for (int i = 0; i < (n - 1); (i)++)
if (s[i] == 'R' && s[i + 1] == 'L') current.push_back(i + 1);
while (!current.empty()) {
list<int> temp;
while (!current.empty()) {
auto a = current.front();
current.pop_front();
swap(s[a], s[a - 1]);
if (a - 2 >= 0 && s[a - 2] == 'R') temp.push_back(a - 1);
if (a + 1 < n && s[a + 1] == 'L') temp.push_back(a + 1);
}
current.splice(current.end(), temp);
l++;
}
if (k < l || k > r) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < (n - 1); (i)++)
if (t[i] == 'R' && t[i + 1] == 'L') current.push_back(i + 1);
int spare = r - k;
int res[n];
for (int kk = 0; kk < (k); (kk)++) {
int taken = 0;
list<int> temp;
while (!current.empty()) {
if (!taken) {
auto a = current.front();
current.pop_front();
swap(t[a], t[a - 1]);
if (a - 2 >= 0 && t[a - 2] == 'R') temp.push_back(a - 1);
if (a + 1 < n && t[a + 1] == 'L') temp.push_back(a + 1);
res[taken] = a;
taken = 1;
} else if (spare) {
auto a = current.front();
current.pop_front();
swap(t[a], t[a - 1]);
if (a - 2 >= 0 && t[a - 2] == 'R') temp.push_back(a - 1);
if (a + 1 < n && t[a + 1] == 'L') temp.push_back(a + 1);
res[taken] = a;
spare--;
taken++;
} else {
temp.splice(temp.end(), current);
break;
}
}
cout << taken << " ";
for (int i = 0; i < (taken); (i)++) cout << res[i] << " ";
cout << "\n";
current.splice(current.end(), temp);
}
}
| 6 |
#include <bits/stdc++.h>
const int MAXINT = 2147483640;
const long long MAXLL = 9223372036854775800LL;
const long long MAXN = 1e6;
const double eps = 1e-9;
const long long mod = 1e9 + 7;
using namespace std;
long long p[MAXN * 4], a[MAXN], l[MAXN];
void modify(long long v, long long ls, long long rs, long long pos,
long long val) {
if (ls == rs) {
p[v] = val;
return;
}
long long mid = (ls + rs) / 2;
if (pos <= mid) {
modify(v * 2, ls, mid, pos, val);
} else
modify(v * 2 + 1, mid + 1, rs, pos, val);
p[v] = p[v * 2] + p[v * 2 + 1];
}
long long get(long long v, long long ls, long long rs, long long l,
long long r) {
if (l > r) return 0;
if (ls == l && rs == r) {
return p[v];
}
long long mid = (ls + rs) / 2;
return get(v * 2, ls, mid, l, min(r, mid)) +
get(v * 2 + 1, mid + 1, rs, max(l, mid + 1), r);
}
int main() {
srand(time(0));
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long n, x;
vector<pair<long long, long long> > v;
cin >> n >> x;
long long now = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
now += a[i];
v.push_back(make_pair(now, i));
modify(1, 1, n, i, 1);
}
sort(v.begin(), v.end());
long long cur = 0, ans = 0;
for (int i = 0; i < v.size(); ++i) {
l[v[i].second] = i;
}
for (int i = 1; i <= n; ++i) {
pair<long long, long long> what = make_pair(cur + x - 1, MAXLL);
now = upper_bound(v.begin(), v.end(), what) - v.begin();
ans += get(1, 1, n, 1, now);
modify(1, 1, n, l[i] + 1, 0);
cur += a[i];
}
cout << ans << "\n";
cerr << "Time execute: " << clock() / (double)CLOCKS_PER_SEC << " sec"
<< "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[100 + 10], f[100 + 10], nxt[100 + 10], t[100 + 10];
int b[100 + 10], num, ans, vis[100 + 10];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(t, 31, sizeof(t));
for (int i = n; i >= 1; i--) {
nxt[i] = t[a[i]];
t[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
f[a[i]] = nxt[i];
if (vis[a[i]]) {
f[a[i]] = nxt[i];
continue;
}
ans++;
if (num < k) {
b[++num] = a[i];
vis[a[i]] = 1;
continue;
}
int mx = 0, mp = 0;
for (int j = 1; j <= num; j++)
if (mx < f[b[j]]) mx = f[b[j]], mp = j;
vis[b[mp]] = 0;
vis[a[i]] = 1;
b[mp] = a[i];
f[a[i]] = nxt[i];
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int buffer_size = 1e5 + 5;
char buf[buffer_size], *S, *T;
bool flag_EOF;
inline char read_char() {
if (S == T) T = (S = buf) + fread(buf, 1, buffer_size, stdin);
return S != T ? *(S++) : EOF;
}
inline int read_int() {
int flag = 1;
char c = read_char();
while (c < '0' || c > '9') {
if (c == EOF) {
flag_EOF = true;
return 0;
}
flag = (c == '-' ? -1 : 1);
c = read_char();
}
int x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + (c ^ 48);
c = read_char();
}
return x * flag;
}
char st[13];
int _top;
void Write(int x) {
if (!x) {
putchar('0');
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
while (x) {
st[++_top] = x % 10 + '0';
x /= 10;
}
while (_top > 0) putchar(st[_top--]);
}
} // namespace IO
const int max_n = 1e5 + 5;
int cnt[max_n], b[max_n];
struct cmp {
inline bool operator()(int x, int y) {
return cnt[x] != cnt[y] ? cnt[x] < cnt[y] : x < y;
}
};
priority_queue<int, vector<int>, cmp> q;
set<int, cmp> s;
vector<pair<int, int> > inter;
vector<int> ans[max_n];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, x, y;
scanf("%d%d%d", &n, &x, &y);
for (int i = 1; i <= n + 1; ++i) cnt[i] = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", b + i);
++cnt[b[i]];
}
while (q.size()) q.pop();
s.clear();
inter.clear();
for (int i = 1; i <= n + 1; ++i) ans[i].clear();
int col = 0;
for (int i = 1; i <= n + 1; ++i) {
if (cnt[i] > 0)
q.push(i);
else
col = i;
}
for (int k = 1; k <= x; ++k) {
int now = q.top();
q.pop();
--cnt[now];
if (cnt[now] > 0) q.push(now);
ans[now].push_back(now);
}
if (y == n && ((y - x) & 1)) {
if (q.size() < 3) {
puts("NO");
continue;
}
int a, b, c;
a = q.top();
q.pop();
b = q.top();
q.pop();
c = q.top();
q.pop();
ans[a].push_back(b);
ans[b].push_back(c);
ans[c].push_back(a);
--cnt[a];
if (cnt[a] > 0) q.push(a);
--cnt[b];
if (cnt[b] > 0) q.push(b);
--cnt[c];
if (cnt[c] > 0) q.push(c);
y -= 3;
}
for (int i = 1; i <= n + 1; ++i) {
if (cnt[i] > 0) {
s.insert(i);
}
}
while (1) {
while (s.size() && cnt[*s.begin()] == 0) s.erase(*s.begin());
if (s.size() < 2) break;
int x = *(--s.end());
s.erase(x);
int y = *s.begin();
s.erase(y);
inter.push_back(pair<int, int>(x, y));
--cnt[x], --cnt[y];
if (cnt[x] > 0) s.insert(x);
if (cnt[y] > 0) s.insert(y);
}
if (int(inter.size()) * 2 < y - x) {
puts("NO");
continue;
}
for (int i = 0; i < int(inter.size()) && y > x; ++i) {
int a = inter[i].first, b = inter[i].second;
ans[a].push_back(b);
--y;
if (y > x) {
ans[b].push_back(a);
--y;
}
}
puts("YES");
for (int i = 1; i <= n; ++i) {
int ans_now;
if (ans[b[i]].empty())
ans_now = col;
else {
ans_now = ans[b[i]].back();
ans[b[i]].pop_back();
}
printf("%d%c", ans_now, i < n ? ' ' : '\n');
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200005;
int main() {
long long a, b;
cin >> a >> b;
for (int i = 1; i <= 100000; i++) {
a *= 3;
b *= 2;
if (a > b) {
cout << i;
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int q, n;
int a[200010];
int p[200010];
int main() {
scanf("%d", &q);
while (q--) {
int ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) p[i] = i - 1;
for (int i = 1; i <= n; i++) {
int sum = a[i], s = 1, x = i;
while (s < 3 && x) {
if (a[i] % a[x]) s++, sum += a[x];
while (p[x] && a[i] % a[p[x]] == 0) p[x] = p[p[x]];
x = p[x];
}
ans = max(ans, sum);
}
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
int mi[N], out[N], d[N][N];
int n, m;
void solve() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i > j) d[i][j] = j + n - i;
if (i < j) d[i][j] = j - i;
}
}
int u, v;
fill(mi, mi + N, N);
for (int i = 1; i <= m; i++) {
cin >> u >> v;
out[u]++;
mi[u] = min(mi[u], d[u][v]);
}
for (int i = 1; i <= n; i++) {
int t = 0;
for (int j = 1; j <= n; j++) {
if (out[j]) {
t = max(t, d[i][j] + (out[j] - 1) * n + mi[j]);
}
}
cout << t << " \n"[i == n];
}
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, k1, k2, n, t1 = -1, t2 = -1, p;
cin >> a;
for (int i = 0; i < a; i++) {
t1 = -1;
t2 = -1;
cin >> n >> k1 >> k2;
for (int j = 0; j < k1; j++) {
cin >> p;
t1 = max(t1, p);
}
for (int j = 0; j < k2; j++) {
cin >> p;
t2 = max(t2, p);
}
if (t1 > t2) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, d, cnt, a[10005];
int main() {
scanf("%d%d", &n, &d);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
int time = 0;
for (int i = 1; i < n; ++i) {
time += a[i] + 10;
cnt += 2;
}
time += a[n];
if (d < time) {
cout << -1 << endl;
return 0;
}
cnt += (d - time) / 5;
cout << cnt << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int inf = 9 * 1e18;
const long long maxn = 2e5 + 100;
long long pow(long long a, long long b) {
if (b < 0) return 0LL;
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a;
a = a * a;
b >>= 1;
}
return ans;
}
long long binpow(long long a, long long b, long long m) {
if (b < 0) return 0LL;
if (a <= 0) return 0LL;
a %= m;
long long ans = 1LL;
while (b) {
if (b & 1) ans = ans * a % m;
a = a * a % m;
b >>= 1;
}
return ans;
}
long long modinv(long long n) { return binpow(n, mod - 2, mod); }
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;
}
void modInverse(int a, int m) {
int x, y;
int g = gcdExtended(a, m, &x, &y);
if (g != 1)
cout << "Inverse doesn't exist";
else {
int res = (x % m + m) % m;
cout << "Modular multiplicative inverse is " << res;
}
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
const long long N = 1e7 + 5;
long long sp[N];
void sieve(long long N) {
for (long long i = 1; i < N; i++) sp[i] = i;
for (long long i = 2; i < N; i++) {
if (sp[i] == i) {
for (long long j = i * i; j < N; j += i) {
if (sp[j] == j) sp[j] = i;
}
}
}
}
void solve() {
string s1;
cin >> s1;
long long k;
cin >> k;
long long n = s1.size();
map<char, char> ma;
for (int i = 0; i < k; i++) {
char u, x;
cin >> u >> x;
ma[u] = x;
ma[x] = u;
}
long long c1 = 0, c2 = 0;
long long ans = 0;
long long j = 0;
for (int i = 0; i < n; i++) {
c1 = 1;
c2 = 0;
char a = s1[i];
char b = ma[a];
for (j = i + 1; j < n; j++) {
if (s1[j] == a)
c1++;
else if (s1[j] == b)
c2++;
else
break;
}
ans += min(c1, c2);
i = j - 1;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n, m;
cin >> n >> m;
int tiles[n][4];
int flag = 0;
for (int i = 0; i < 2 * n; i++) {
cin >> tiles[i / 2][2 * (i % 2)] >> tiles[i / 2][2 * (i % 2) + 1];
if (i % 2) {
if (tiles[i / 2][1] == tiles[i / 2][2]) {
flag = 1;
}
}
}
if ((m % 2) == 1 || flag == 0) {
cout << "NO\n";
} else {
cout << "YES\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, m, deg[maxn], val[maxn], d[maxn];
vector<pair<int, int> > adj[maxn], moj[maxn];
vector<int> cadj[maxn];
bool mark[maxn], markv[maxn];
queue<int> Q;
void input() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
if (k == 1) Q.push(i);
deg[i] = k;
while (k--) {
int v;
cin >> v;
cadj[i].push_back(v);
adj[abs(v) - 1].push_back(make_pair(i, v / abs(v)));
}
deg[i] = cadj[i].size();
}
for (int i = 0; i < m; i++) d[i] = adj[i].size();
}
void popQ() {
while (!Q.empty()) {
int now = Q.front();
Q.pop();
if (mark[now]) continue;
bool f = 0;
for (int i = 0; i < cadj[now].size(); i++) {
int nv = cadj[now][i];
if (markv[abs(nv) - 1]) continue;
f = 1;
mark[now] = markv[abs(nv) - 1] = 1;
d[abs(nv) - 1]--;
val[abs(nv) - 1] = (nv / abs(nv) == 1 ? 1 : 0);
if (adj[abs(nv) - 1].size() == 2)
for (int j = 0; j < adj[abs(nv) - 1].size(); j++) {
int ng = adj[abs(nv) - 1][j].first;
if (nv / abs(nv) == adj[abs(nv) - 1][j].second && ng != now) {
mark[ng] = 1;
d[abs(nv) - 1]--;
} else if (ng != now) {
deg[ng]--;
if (!deg[ng] && !mark[ng])
exit(cout << "NO\n" ? 0 : 0);
else if (deg[ng] == 1)
Q.push(ng);
}
}
break;
}
if (!f) exit(cout << "NO\n" ? 0 : 0);
}
}
int findadj(int v) {
for (int i = 0; i < adj[v].size(); i++)
if (!mark[adj[v][i].first]) return i;
}
void decdeg(int v) {
for (int i = 0; i < cadj[v].size(); i++)
if (!markv[cadj[v][i]]) d[cadj[v][i]]--;
}
void make_adj() {
for (int i = 0; i < m; i++)
if (!markv[i]) {
if (d[i] == 0)
markv[i] = 1;
else if (d[i] == 1) {
int ind = findadj(i);
val[i] = (adj[i][ind].second == 1 ? 1 : 0);
markv[i] = mark[adj[i][ind].first] = 1;
decdeg(adj[i][ind].first);
} else {
int u, v;
v = adj[i][0].first;
u = adj[i][1].first;
moj[v].push_back(make_pair(u, adj[i][0].second * (i + 1)));
moj[u].push_back(make_pair(v, adj[i][1].second * (i + 1)));
}
}
}
vector<int> barg;
void dfs_visit(int v) {
mark[v] = 1;
bool f = 0;
for (int i = 0; i < moj[v].size(); i++) {
int nv = moj[v][i].first;
if (!mark[nv]) {
dfs_visit(nv);
val[abs(moj[v][i].second) - 1] =
(moj[v][i].second / abs(moj[v][i].second) == 1 ? 1 : 0);
markv[abs(moj[v][i].second) - 1] = 1;
f = 1;
}
}
if (!f) barg.push_back(v);
}
void dfs() {
for (int i = 0; i < n; i++)
if (!mark[i]) dfs_visit(i);
}
void sat_barg() {
for (int i = 0; i < barg.size(); i++) {
int v = barg[i];
for (int j = 0; j < moj[v].size(); j++) {
int x = moj[v][j].second;
if (!markv[abs(x) - 1]) {
val[abs(x) - 1] = (x / abs(x) == 1 ? 1 : 0);
markv[abs(x) - 1] = 1;
mark[v] = 1;
}
}
}
}
void solve() {
popQ();
make_adj();
dfs();
sat_barg();
}
void output() {
for (int i = 0; i < n; i++)
if (!mark[i]) exit(cout << "NO\n" ? 0 : 0);
cout << "YES" << endl;
for (int i = 0; i < m; i++) cout << val[i];
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
input();
solve();
output();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
const int N = 3e5 + 7;
int add[4 * N];
int t[4 * N];
void upd(int v, int x) {
add[v] += x;
t[v] += x;
}
void push(int v) {
if (add[v]) {
upd(v * 2 + 1, add[v]);
upd(v * 2 + 2, add[v]);
add[v] = 0;
}
}
void upd(int v, int l, int r, int tl, int tr, int x) {
if (tl >= r || tr <= l) {
return;
}
if (tl >= l && tr <= r) {
upd(v, x);
} else {
int tm = (tl + tr) / 2;
push(v);
upd(v * 2 + 1, l, r, tl, tm, x);
upd(v * 2 + 2, l, r, tm, tr, x);
t[v] = min(t[v * 2 + 1], t[v * 2 + 2]);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> p(n), q(n);
vector<int> rev(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
p[i]--;
rev[p[i]] = i;
}
for (int i = 0; i < n; i++) {
cin >> q[i];
q[i]--;
}
auto decrease = [&](int x) {
upd(0, 0, rev[x] + 1, 0, n, -1);
if (t[0] >= 0) {
return true;
} else {
upd(0, 0, rev[x] + 1, 0, n, 1);
return false;
}
};
int x = n - 1;
for (int i = 0; i < n; i++) {
while (decrease(x)) x--;
cout << x + 1 << ' ';
upd(0, 0, q[i] + 1, 0, n, 1);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 22;
const long long inf = 1011011011022022022LL;
int cnt[10], c[10], CP[10];
long long L, l, r, ans;
vector<int> v;
long long get_first() {
int len = 0, mx = 0;
for (int i = 1; i < 10; ++i) {
len += cnt[i];
if (cnt[i]) {
mx = i;
}
}
if (len > v.size()) {
long long res = 0;
for (int i = 1; i < 10; ++i) {
for (int j = 0; j < cnt[i]; ++j) {
res = res * 10 + i;
}
}
return res;
}
long long res = inf, X = 0;
cnt[0] = v.size() - len;
copy(cnt, cnt + 10, CP);
int last = 0, mx_pos = 9;
for (int i = 0; i < v.size(); ++i) {
int mn = v[i] + 1;
if (i + 1 == v.size()) {
mn = v[i];
}
while (mx_pos >= 0 && cnt[mx_pos] == 0) {
--mx_pos;
}
if (mn <= mx_pos) {
last = i;
}
if (cnt[v[i]] == 0) {
break;
}
--cnt[v[i]];
}
copy(CP, CP + 10, cnt);
for (int i = 0; i < v.size(); ++i) {
int mn = v[i] + 1;
if (i + 1 == v.size()) {
mn = v[i];
}
if (i == last) {
copy(cnt, cnt + 10, c);
long long x = -1;
for (int j = mn; j < 10; ++j) {
if (c[j]) {
x = j;
--c[j];
break;
}
}
if (x != -1) {
x = X * 10 + x;
for (int j = 0; j < 10; ++j) {
for (int k = 0; k < c[j]; ++k) {
x = x * 10 + j;
}
}
res = min(res, x);
}
break;
}
--cnt[v[i]];
X = X * 10 + v[i];
}
if (res == inf) {
copy(CP, CP + 10, cnt);
++cnt[0];
for (int i = 1; i < 10; ++i) {
if (cnt[i]) {
res = i;
break;
}
}
--cnt[res];
for (int i = 0; i < 10; ++i) {
for (int j = 0; j < cnt[i]; ++j) {
res = res * 10 + i;
}
}
}
copy(CP, CP + 10, cnt);
return res;
}
bool ok() { return get_first() <= r; }
void get_all(int pos, int sum) {
if (pos == 10) {
if (sum != 18 && ok()) {
++ans;
}
return;
}
for (int i = 0; i <= sum; ++i) {
cnt[pos] = i;
get_all(pos + 1, sum - i);
}
}
double st = clock();
double get_time() { return (clock() - st) / CLOCKS_PER_SEC; }
int main() {
cin >> l >> r;
L = l;
while (l) {
v.push_back(l % 10);
l /= 10;
}
reverse(v.begin(), v.end());
if (v.size() == 19) {
cout << 1 << endl;
return 0;
}
get_all(1, 18);
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
char s[1000005];
long long ans = 0;
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++)
if (s[i] == '@') {
int j = i + 1;
for (; j < n; j++) {
if (s[j] == '.' || s[j] == '@' || s[j] == '_') break;
}
if (s[j] != '.' || j == i + 1) {
i = j - 1;
continue;
}
int end = 0;
while (j + end + 1 < n && s[j + end + 1] >= 'a' && s[j + end + 1] <= 'z')
end++;
int bf = 0;
for (int p = i - 1; p >= 0; p--) {
if (s[p] == '@' || s[p] == '.') break;
if (s[p] >= 'a' && s[p] <= 'z') bf++;
}
ans += (long long)end * bf;
i = j + end;
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
struct edge {
int w, typ, ord;
bool friend operator<(edge a, edge b) {
return make_pair(a.w, -a.typ) < make_pair(b.w, -b.typ);
}
} E[222222];
int maxv[222222];
int nn = 1;
pair<int, int> ans[222222];
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i < M; i++) {
scanf("%d%d", &E[i].w, &E[i].typ);
E[i].ord = i;
}
sort(E, E + M);
bool flag = 0;
maxv[1] = 1;
for (int i = 0; i < M; i++) {
if (E[i].typ) {
ans[E[i].ord] = make_pair(1, ++nn);
maxv[1]++;
maxv[nn] = nn;
} else {
bool finded = 0;
for (int j = 2; j <= nn; j++) {
if (maxv[j] < nn) {
ans[E[i].ord] = make_pair(j, ++maxv[j]);
finded = true;
break;
}
}
if (!finded) {
flag = 1;
break;
}
}
}
if (flag) {
printf("-1\n");
return 0;
}
for (int i = 0; i < M; i++) printf("%d %d\n", ans[i].first, ans[i].second);
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64777216")
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
const double pi = acos(-1.0), eps = 1e-9, e = exp(1.0);
const int INF = 1000 * 1000 * 1000 + 5, MAXN = 100005, MOD = 1000000007;
const long long INFL = 1e+18;
void prepare(string s) {
if ((int)s.size() != 0) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
}
int n, p;
string s;
char alpha[26];
void solve() {
cin >> n >> p >> s;
for (char c = 'a'; c <= 'z'; c++) alpha[c - 'a'] = c;
char gr = alpha[p - 1];
if (n == 1) {
s[0]++;
if (s[0] <= gr)
cout << s;
else
cout << "NO";
}
if (n == 2) {
char start = s[1];
start++;
for (char c = s[0]; c <= gr; c++) {
if (c != s[0]) start = 'a';
for (char d = start; d <= gr; d++)
if (d != c) {
cout << c << d;
return;
}
}
cout << "NO";
}
if (n >= 3) {
char start, A, B;
bool f = false;
for (int i = (int)s.size() - 1; i >= 0; i--) {
start = s[i];
if (i >= 2) A = s[i - 1], B = s[i - 2];
if (i == 1) A = s[i - 1];
start++;
if (i >= 2) {
for (char c = start; c <= gr; c++)
if (c != A && c != B) {
s[i] = c;
f = true;
break;
}
}
if (i == 1) {
for (char c = start; c <= gr; c++)
if (c != A) {
s[i] = c;
f = true;
break;
}
}
if (i == 0) {
f = true;
s[i]++;
if (s[i] > gr) {
cout << "NO";
return;
}
}
if (f) {
for (int j = i + 1; j < (int)s.size(); j++)
for (char c = 'a'; c <= gr; c++)
if (j >= 2) {
if (c != s[j - 1] && c != s[j - 2]) {
s[j] = c;
break;
}
} else {
if (c != s[j - 1]) {
s[j] = c;
break;
}
}
cout << s;
break;
}
}
if (!f) cout << "NO";
}
}
int main() {
prepare("");
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 1e3 + 5, P = 998244353;
typedef long long arrn[MXN];
int n;
arrn fac, ifac, arr, dp;
inline long long qpow(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % P;
x = x * x % P, y >>= 1;
}
return res;
}
inline long long c(long long x, long long y) {
if (x < y || y < 0) return 0;
return fac[x] * ifac[x - y] % P * ifac[y] % P;
}
int main() {
scanf("%d", &n);
fac[0] = ifac[0] = 1;
for (int i = 1; i <= n; i++) {
scanf("%lld", arr + i);
fac[i] = fac[i - 1] * i % P;
ifac[i] = qpow(fac[i], P - 2);
}
dp[n + 1] = 1;
long long ans = 0;
for (int i = n; i; i--) {
if (arr[i] > 0)
for (int j = arr[i]; i + j <= n; j++)
dp[i] = (dp[i] + dp[i + j + 1] * c(j, arr[i])) % P;
ans = (ans + dp[i]) % P;
}
printf("%lld", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e6 + 5;
const int inf = 0x3f3f3f3f;
long long mul(long long a, long long b, long long mod) {
long long ret = (a * b - (long long)((long double)a / mod * b) * mod);
return (ret % mod + mod) % mod;
}
long long qpow(long long base, long long t, long long mod) {
long long ret = 1;
while (t) {
if (t & 1) ret = mul(ret, base, mod);
base = mul(base, base, mod);
t >>= 1;
}
return ret;
}
long long mod;
void FWT(long long* a, int n, int op) {
for (int len = 1; len < n; len <<= 1) {
for (int i = 0; i < n; i += len * 2) {
for (int j = i; j < i + len; j++) {
long long x = a[j], y = a[j + len];
a[j] = (x + y) % mod;
a[j + len] = (x - y + mod) % mod;
}
}
}
}
long long a[maxn], b[30], e[maxn];
int main(void) {
int m;
long long t, p;
scanf("%d%lld%lld", &m, &t, &p);
int n = 1 << m;
mod = (long long)n * p;
for (int i = 0; i < n; i++) {
scanf("%lld", e + i);
e[i] %= mod;
}
for (int i = 0; i <= m; i++) {
scanf("%lld", b + i);
b[i] %= mod;
}
for (int i = 0; i < n; i++) a[i] = b[__builtin_popcount(i)];
FWT(a, n, 1);
FWT(e, n, 1);
for (int i = 0; i < n; i++) {
a[i] = qpow(a[i], t, mod);
a[i] = mul(a[i], e[i], mod);
}
FWT(a, n, -1);
for (int i = 0; i < n; i++) printf("%lld\n", (long long)a[i] / n);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 50;
long long k[N];
long long value[N];
struct node {
long long en, value;
node(){};
node(long long en, long long value) {
this->en = en;
this->value = value;
}
};
vector<vector<node>> mp;
bool flag[N];
void DFS(long long root, long long sum_side, long long& kle);
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
long long b, c;
mp.resize(N);
cin >> n;
for (int i = 1; i <= n; i++) cin >> value[i];
for (int i = 2; i <= n; i++) {
cin >> b >> c;
mp[i].push_back(node(b, c));
mp[b].push_back(node(i, c));
}
long long kle = 0;
DFS(1, 0, kle);
cout << n - kle << endl;
return 0;
}
void DFS(long long root, long long sum_side, long long& kle) {
if (sum_side > value[root]) return;
++kle;
flag[root] = true;
for (int i = 0; i < mp[root].size(); i++) {
if (flag[mp[root][i].en] == false) {
DFS(mp[root][i].en, max(sum_side + mp[root][i].value, mp[root][i].value),
kle);
}
}
return;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
int arr[11] = {0};
cin >> n;
cout << "+------------------------+\n";
if (n >= 4) {
arr[0] = 4;
n -= 4;
} else {
arr[0] = n;
n = 0;
}
int ij = 1;
while (n > 0) {
arr[ij] = min(3, n);
n -= arr[ij];
++ij;
}
cout << "|";
for (int i = 0; i < 11; ++i) {
if (arr[i]) {
cout << "O";
--arr[i];
} else {
cout << "#";
}
cout << ".";
}
cout << "|D|)\n|";
for (int i = 0; i < 11; ++i) {
if (arr[i]) {
cout << "O";
--arr[i];
} else {
cout << "#";
}
cout << ".";
}
cout << "|.|\n";
if (arr[0]) {
cout << "|O.......................|\n|";
--arr[0];
} else {
cout << "|#.......................|\n|";
}
for (int i = 0; i < 11; ++i) {
if (arr[i]) {
cout << "O";
--arr[i];
} else {
cout << "#";
}
cout << ".";
}
cout << "|.|)\n";
cout << "+------------------------+\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
int flag = 2;
int inp;
cin >> n;
for (i = 0; i < n; i++) {
scanf("%d", &inp);
if (flag == 2) {
if (inp % 2 == 1) flag = 1;
}
}
if (flag == 1)
cout << "First";
else
cout << "Second";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2005;
char str[MAXN][MAXN], mp[MAXN][MAXN];
int ax[30], ay[30], bx[30], by[30], T, n, m;
int main() {
for (scanf("%d", &T); T--;) {
scanf("%d%d", &n, &m);
int mx = 0;
memset(ax, 0, sizeof(ax)), memset(ay, 0, sizeof(ay)),
memset(bx, 0, sizeof(bx)), memset(by, 0, sizeof(by));
for (int i = 1; i <= n; i++) {
scanf("%s", str[i] + 1);
for (int j = 1; j <= m; j++) {
if (str[i][j] != '.') {
int t = str[i][j] - 'a';
mx = max(mx, t + 1);
if (!ax[t]) ax[t] = i, ay[t] = j;
bx[t] = i, by[t] = j;
}
mp[i][j] = '.';
}
}
int flag = 1;
for (int i = 0; i < mx; i++) {
if (!ax[i]) {
ax[i] = bx[i] = ax[mx - 1];
ay[i] = by[i] = ay[mx - 1];
continue;
}
if (ax[i] != bx[i] && ay[i] != by[i]) {
flag = 0;
break;
}
}
if (!flag) {
puts("NO");
continue;
}
for (int i = 0; i < mx; i++) {
for (int a = ax[i]; a <= bx[i]; a++)
for (int b = ay[i]; b <= by[i]; b++) mp[a][b] = 'a' + i;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (str[i][j] != mp[i][j]) {
flag = 0;
break;
}
if (!flag) break;
}
puts(flag ? "YES" : "NO");
if (!flag) continue;
printf("%d\n", mx);
for (int i = 0; i < mx; i++)
printf("%d %d %d %d\n", ax[i], ay[i], bx[i], by[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m;
int a[N];
map<int, int> mp;
int dpr[N];
int r[N];
int dpl[N];
int l[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) scanf("%d", &a[i]);
if (n == 1) {
cout << 0 << endl;
return 0;
}
for (int i = m; i >= 1; --i) {
if (mp.find(a[i] + (m - i) - 1) != mp.end())
dpr[i] = dpr[mp[a[i] + (m - i) - 1]];
else
dpr[i] = min(n, a[i] + (m - i));
mp[a[i] + (m - i)] = i;
}
for (int i = 1; i <= n; ++i) {
if (mp.find(i + 1 + m - 1) != mp.end())
r[i] = dpr[mp[i + 1 + m - 1]];
else
r[i] = min(n, i + 1 + m);
}
mp.clear();
for (int i = m; i >= 1; --i) {
if (mp.find(a[i] - (m - i) + 1) != mp.end())
dpl[i] = dpl[mp[a[i] - (m - i) + 1]];
else
dpl[i] = max(1, a[i] - (m - i));
mp[a[i] - (m - i)] = i;
}
for (int i = 1; i <= n; ++i) {
if (mp.find(i - 1 - m + 1) != mp.end())
l[i] = dpl[mp[i - 1 - m + 1]];
else
l[i] = max(1, i - 1 - m);
}
long long ans = 0;
for (int i = 1; i <= n; ++i) ans += (r[i] - l[i] + 1);
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
char buf[1000000], *p1 = buf, *p2 = buf;
inline char gc() {
if (p1 == p2) p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin);
return p1 == p2 ? EOF : *(p1++);
}
template <class T>
inline void read(T &n) {
n = 0;
register int ch = gc(), f;
while ((ch < '0' || ch > '9') && ch != '-') ch = gc();
f = (ch == '-' ? ch = gc(), -1 : 1);
while (ch >= '0' && ch <= '9') n = n * 10 + (ch ^ 48), ch = gc();
n *= f;
}
char Of[105], *O1 = Of, *O2 = Of;
template <class T>
inline void print(T n, char ch = '\n') {
if (n < 0) putchar('-'), n = -n;
if (n == 0) putchar('0');
while (n) *(O1++) = (n % 10) ^ 48, n /= 10;
while (O1 != O2) putchar(*(--O1));
putchar(ch);
}
} // namespace IO
using IO ::print;
using IO ::read;
int const MAXN = 7005;
bitset<MAXN> val[MAXN], mu[MAXN], a[100005], tmp;
int Prime[MAXN], tot;
char Notprime[MAXN], miu[MAXN];
void Init(int Max) {
miu[1] = 1;
for (register int i = 2; i <= Max; ++i) {
if (!Notprime[i]) Prime[++tot] = i, miu[i] = -1;
for (register int j = 1; j <= tot && i * Prime[j] <= Max; ++j) {
Notprime[i * Prime[j]] = 1;
if (i % Prime[j] == 0) break;
miu[i * Prime[j]] = miu[i] * -1;
}
}
for (register int i = 1; i <= Max; ++i)
for (register int j = i; j <= Max; j += i) {
val[j].set(i);
if (miu[j / i]) mu[i].set(j);
}
}
int main() {
int n, q;
read(n), read(q);
Init(7000);
while (q--) {
int op;
read(op);
if (op == 1) {
int x, v;
read(x), read(v);
a[x] = val[v];
} else if (op == 2) {
int x, y, z;
read(x), read(y), read(z);
a[x] = a[y] ^ a[z];
} else if (op == 3) {
int x, y, z;
read(x), read(y), read(z);
a[x] = a[y] & a[z];
} else {
int x, v;
read(x), read(v);
tmp = a[x] & mu[v];
putchar('0' + (tmp.count() & 1));
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
vector<int> v1, v2;
int flag[N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
int now = 0, cc;
for (cc = 1;;) {
now += cc;
if (now > n + m) break;
cc++;
}
cc--;
for (int i = (cc + 1) - 1; i >= (1); --i)
if (n >= i) v1.push_back(i), n -= i, flag[i] = 1;
for (int i = (cc + 1) - 1; i >= (1); --i)
if (!flag[i]) v2.push_back(i);
printf("%d\n", ((int)(v1).size()));
for (int i = (0); i < (((int)(v1).size())); ++i)
printf("%d%c", v1[i], " \n"[i == ((int)(v1).size()) - 1]);
printf("%d\n", ((int)(v2).size()));
for (int i = (0); i < (((int)(v2).size())); ++i)
printf("%d%c", v2[i], " \n"[i == ((int)(v2).size()) - 1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int MOD = 1000000007;
using namespace std;
void dfs(int i, int j, int &count, vector<string> &arr,
vector<pair<int, int>> &v) {
if (i < 0 || j < 0 || i > arr.size() - 1 || j > arr[0].size() - 1 ||
arr[i][j] == '*' || arr[i][j] == 'v') {
return;
}
count++;
arr[i][j] = 'v';
v.push_back({i, j});
dfs(i + 1, j, count, arr, v);
dfs(i, j + 1, count, arr, v);
dfs(i - 1, j, count, arr, v);
dfs(i, j - 1, count, arr, v);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
string a, b;
cin >> a >> b;
int n = a.length();
int ans = 0, four = 0, seven = 0;
for (int i = 0; i < n; ++i) {
if (a[i] == b[i]) continue;
if (a[i] == '4') {
if (seven > 0) {
seven--;
} else {
ans++;
four++;
}
} else {
if (four > 0) {
four--;
} else {
ans++;
seven++;
}
}
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, m, k, l, r, x;
cin >> n >> m;
int A[n];
int pos[n + 1];
for (i = 0; i < n; ++i) {
cin >> A[i];
pos[A[i]] = i;
}
while (m--) {
cin >> l >> r >> x;
l--;
r--;
x = A[x - 1];
if (pos[x] < l || pos[x] > r) {
cout << "No\n";
} else {
int coun = 0;
for (i = l; i <= r; ++i) {
if (A[i] < x) {
coun++;
}
}
if (coun == pos[x] - l) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, n, l, r, mid, t, sum;
scanf("%lld", &n);
while (n--) {
scanf("%lld %lld", &a, &b);
l = 1;
r = 1000000;
sum = a * b;
while (l <= r) {
mid = (l + r) / 2;
t = mid * mid * mid;
if (t > sum) {
r = mid - 1;
} else if (t < sum) {
l = mid + 1;
} else {
break;
}
}
if (l <= r && a % mid == 0 && b % mid == 0) {
printf("Yes\n");
} else {
printf("No\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
const long long maxn = 1e6;
long long n, d, m;
cin >> n >> d >> m;
vector<long long> hi(maxn), lo(maxn);
long long locnt = 0, hicnt = 0, sum = 0;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
sum += a;
if (a > m)
hi[++hicnt] = a;
else
lo[++locnt] = a;
}
if (hicnt == 0) {
cout << sum << "\n";
return;
}
sort(hi.begin() + 1, hi.begin() + hicnt + 1);
sort(lo.begin() + 1, lo.begin() + locnt + 1);
reverse(hi.begin() + 1, hi.begin() + hicnt + 1);
reverse(lo.begin() + 1, lo.begin() + locnt + 1);
for (int i = 1; i <= hicnt; i++) hi[i] += hi[i - 1];
for (int i = 1; i <= locnt; i++) lo[i] += lo[i - 1];
for (int i = locnt + 1; i <= n; i++) lo[i] = lo[locnt];
long long ans = 0;
for (long long i = (hicnt + d) / (d + 1); i <= hicnt; i++) {
if ((i - 1) * (d + 1) + 1 <= n) {
ans = max(ans, hi[i] + lo[n - (i - 1) * (d + 1) - 1]);
}
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
char maze[501][501];
long long dx[] = {0, 0, -1, 1};
long long dy[] = {1, -1, 0, 0};
long long visited[501][501];
long long dotCount, nodesVisited;
bool isValid(long long x, long long y) {
if (x >= 0 && y >= 0 && x < n && y < m) {
return true;
}
return false;
}
void bfs(long long i, long long j) {
visited[i][j] = 1;
nodesVisited++;
if (nodesVisited == dotCount - k) {
return;
}
for (long long l = 0; l < 4; l++) {
if (isValid(i + dx[l], j + dy[l]) && !visited[i + dx[l]][j + dy[l]] &&
maze[i + dx[l]][j + dy[l]] == '.' && nodesVisited < dotCount - k) {
bfs(i + dx[l], j + dy[l]);
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
string str;
vector<long long> availX;
vector<long long> availY;
cin >> n >> m >> k;
long long startX, startY;
for (long long i = 0; i < n; i++) {
cin >> str;
for (long long j = 0; j < str.length(); j++) {
maze[i][j] = str[j];
if (maze[i][j] == '.') {
dotCount++;
startX = i;
startY = j;
}
}
}
bfs(startX, startY);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (maze[i][j] == '.' && !visited[i][j]) {
maze[i][j] = 'X';
}
cout << maze[i][j];
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e4 + 50, mod = 1e9 + 7, L = 31;
int n, a[N], ch[N * L][2], sz[N * L], tot, lim, f[N * L], t[N * L], s[N][L][2],
b[L];
long long anss, k;
void insert(int id) {
int p = 0, x = a[id];
for (int i = lim, c; i >= 0; i--) {
c = (x >> i) & 1;
if (!ch[p][c]) ch[p][c] = ++tot, f[tot] = id;
p = ch[p][c];
sz[p]++;
t[p] = id;
}
}
int ask(int x, int y) {
int p = 0, ret = 0;
for (int i = lim; i >= 0; i--) {
int c = (x >> i) & 1, d = (y >> i) & 1;
if (!d && ch[p][c ^ 1]) ret += sz[ch[p][c ^ 1]];
if (ch[p][c ^ d])
p = ch[p][c ^ d];
else
break;
}
return ret;
}
long long ask2(int x, int y) {
int p = 0, ss = 0;
long long ret = 0;
for (int i = 0, xx = x; i <= lim; i++, xx >>= 1) b[i] = xx & 1;
for (int i = lim; i >= 0; i--) {
int c = b[i], d = (y >> i) & 1, q = ch[p][c ^ 1];
if (!d && q) {
ss += sz[q];
for (int j = 0; j <= lim; j++)
ret +=
1ll * (s[t[q]][j][b[j] ^ 1] - s[f[q] - 1][j][b[j] ^ 1]) * (1 << j);
}
if (ch[p][c ^ d])
p = ch[p][c ^ d];
else
break;
}
k -= ss;
return ret;
}
bool check(int x) {
long long ret = 0;
for (int i = 1; i <= n; i++) ret += ask(a[i], x);
return ret < k;
}
int main() {
scanf("%d%d", &n, &k);
k *= 2;
if (!k) puts("0"), exit(0);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
lim = log2(a[n]);
for (int i = 1; i <= n; i++)
for (int j = 0, x = a[i]; j <= lim; j++, x >>= 1)
s[i][j][1] = s[i - 1][j][1] + (x & 1), s[i][j][0] = i - s[i][j][1];
for (int i = 1; i <= n; i++) insert(i);
long long l = 0, r = (1ll << 31) - 1, ans = 1e9;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
for (int i = 1; i <= n; i++) anss += ask2(a[i], ans);
anss += 1ll * ans * k;
cout << anss / 2 % mod;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long mo = 998244353;
long long sx, sy, ex, ey, dx[6] = {0, 1, 0, -1, 0, 0},
dy[6] = {1, 0, -1, 0, 0, 0}, m, n, k,
dz[6]{0, 0, 0, 0, -1, 1}, sg, re;
long long p, no, v, ans, w;
int par[55000];
long long a[400005], b[2750135], c[500006], d[400006];
struct mat {
long long a[40][40];
};
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
set<long long> se;
long long qu(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) {
ans = ans % m * a % m;
}
b >>= 1;
a = a % m * a % m;
}
return ans;
}
int su(int n) {
if (n == 1 || n == 0) return 0;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return 0;
}
return 1;
}
int fi(int a) {
if (a == par[a])
return a;
else
return par[a] = fi(par[a]);
}
map<long long, long long> mp, mp1;
priority_queue<long long> que;
pair<long long, long long> a1[400000], a2[205];
int vis[2750131], vis1[2750131];
vector<long long> g[400000], g1[400000];
string s1;
struct node {
long long x, y, t;
} aa[200005];
vector<long long> ve, ve1[3];
int cmp1(pair<long long, long long> a, pair<long long, long long> b) {
return a.first > b.first;
}
int cmp(long long a, long long b) { return a > b; }
void su1(long long n) {
int p = 1;
for (int i = 2; i <= n; i++) b[i] = 1;
for (int i = 2; i <= n; i++) {
if (b[i]) {
vis1[i] = p++;
for (int j = 2 * i; j <= n; j += i) b[j] = 0;
}
}
}
int main() {
int t, p2, p3;
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string ss, sss, s;
long long l, r, n1, u, d;
su1(2750131);
while (cin >> n) {
for (int i = 0; i < 2 * n; i++) {
cin >> a[i];
}
sort(a, a + 2 * n, cmp);
for (int i = 0; i < 2 * n; i++) {
vis[a[i]]--;
if (vis[a[i]] < 0) {
if (b[a[i]]) {
vis[vis1[a[i]]]++;
ve1[2].push_back(vis1[a[i]]);
} else {
for (long long j = 2; j <= sqrt(a[i]); j++) {
if (a[i] % j == 0) {
vis[a[i] / j]++;
ve1[2].push_back(a[i]);
break;
}
}
}
}
}
for (int i = 0; i < ve1[2].size(); i++) {
cout << ve1[2][i] << " ";
}
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 998244353;
const int MAXN = 150010, SQ = 95;
long long n, m, k, u, v, x, y, t, a, b, ans, invn;
long long fen[MAXN];
long long lazy[MAXN];
int stt[MAXN], fnt[MAXN], timer = 1;
int sz[MAXN];
vector<int> G[MAXN], big;
vector<pair<int, int> > child[MAXN];
void upd(int pos, long long val) {
for (; pos < MAXN; pos += pos & -pos) fen[pos] = (fen[pos] + val) % mod;
}
void Add(int l, int r, long long val) {
upd(l, +val);
upd(r, -val);
}
long long Get(int pos) {
long long res = 0;
for (; pos; pos -= pos & -pos) res += fen[pos];
return res % mod;
}
long long powmod(long long a, long long b) {
if (!b) return 1;
if (b & 1) return a * powmod(a * a % mod, b >> 1) % mod;
return powmod(a * a % mod, b >> 1);
}
int dfs(int node, int par) {
stt[node] = timer++;
for (int v : G[node])
if (v != par) {
sz[node] += dfs(v, node);
child[node].push_back({fnt[v], v});
}
fnt[node] = timer;
return ++sz[node];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i < n; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, 1);
for (int i = 1; i <= n; i++)
if (child[i].size() > SQ) big.push_back(i);
invn = powmod(n, mod - 2);
while (m--) {
cin >> t;
if (t == 1) {
cin >> v >> x;
Add(1, n + 1, x * (sz[v] * invn % mod));
Add(stt[v], fnt[v], -x * (sz[v] * invn % mod));
Add(stt[v] + 1, fnt[v], x * ((n - sz[v] + 1) * invn % mod));
Add(stt[v], stt[v] + 1, x);
if (child[v].size() > SQ)
lazy[v] = (lazy[v] + x) % mod;
else {
for (pair<int, int> p : child[v]) {
int u = p.second;
Add(stt[u], fnt[u], x * ((sz[v] - sz[u] - 1) * invn % mod));
}
}
continue;
}
cin >> v;
ans = Get(stt[v]);
for (int u : big)
if (stt[u] <= stt[v] && fnt[v] <= fnt[u] && u != v) {
int x = lower_bound(child[u].begin(), child[u].end(),
pair<int, int>(fnt[v], 0))
->second;
ans = (ans + lazy[u] * ((sz[u] - sz[x] - 1) * invn % mod)) % mod;
}
if (ans < 0) ans += mod;
cout << ans << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int n;
long long x, y;
int a, b;
int main() {
scanf("%d", &n);
for (int i = 0; i < n * 2; i++) {
scanf("%d%d", &a, &b);
x += a;
y += b;
}
printf("%lld %lld\n", x / n, y / n);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct put {
long long int p, k, c;
};
put a[2500];
long long int u, v, w;
long long int minn(long long int a, long long int b) {
if (a < b)
return (a);
else
return (b);
}
long long int maxx(long long int a, long long int b) {
if (a > b)
return (a);
else
return (b);
}
long long int koren(long long int a, long long int b) {
if (a == b)
return (a);
else
return (koren(minn(a, b / 2), maxx(a, b / 2)));
}
int main() {
int q, j = 0;
cin >> q;
for (int i = 1; i <= q; i++) {
int m;
cin >> m;
if (m == 1) {
cin >> u >> v >> w;
j++;
long long int t = koren(minn(u, v), maxx(u, v));
a[j].p = t;
a[j].k = u;
a[j].c = w;
j++;
a[j].p = t;
a[j].k = v;
a[j].c = w;
} else {
cin >> u >> v;
if (u > v) {
long long int pom;
pom = u;
u = v;
v = pom;
}
long long int rez = 0, t = koren(minn(u, v), maxx(u, v));
for (int i2 = 1; i2 <= j; i2++) {
long long int k1 = a[i2].k, p1 = a[i2].p, u1 = u, v1 = v;
while ((k1 > p1) && (u1 > t)) {
if (k1 == u1) {
rez += a[i2].c;
k1 /= 2;
u1 /= 2;
} else if (k1 > u1)
k1 /= 2;
else
u1 /= 2;
}
k1 = a[i2].k;
while ((k1 > p1) && (v1 > t)) {
if (k1 == v1) {
rez += a[i2].c;
k1 /= 2;
v1 /= 2;
} else if (k1 > v1)
k1 /= 2;
else
v1 /= 2;
}
}
cout << rez << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x[5005], y[5005], t[5005];
bool num[5005][1005];
char a1[15], a2[1005];
map<string, int> mp;
bool ans[2][1005];
int tmp[5005];
int cal(int xx, int f) {
int ans = 0;
for (int i = 1; i <= n; i++) {
if (t[i] == -1)
tmp[i] = num[i][xx];
else {
int a, b;
if (x[i] == -1)
a = f;
else
a = tmp[x[i]];
if (y[i] == -1)
b = f;
else
b = tmp[y[i]];
if (t[i] == 1) tmp[i] = a & b;
if (t[i] == 2) tmp[i] = a | b;
if (t[i] == 3) tmp[i] = a ^ b;
}
ans += tmp[i];
}
return ans;
}
string a;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s%*s", a1);
a = string(a1);
mp[a] = i;
scanf("%s", a2);
if (a2[0] >= '0' && a2[0] <= '9') {
t[i] = -1;
for (int j = 1; j <= m; j++) num[i][j] = a2[j - 1] - '0';
} else {
if (a2[0] == '?')
x[i] = -1;
else {
a = string(a2);
x[i] = mp[a];
}
scanf("%s", a1);
if (a1[0] == 'A') t[i] = 1;
if (a1[0] == 'O') t[i] = 2;
if (a1[0] == 'X') t[i] = 3;
scanf("%s", a2);
if (a2[0] == '?')
y[i] = -1;
else {
a = string(a2);
y[i] = mp[a];
}
}
}
for (int i = 1; i <= m; i++) {
int x = cal(i, 0);
int y = cal(i, 1);
if (x >= y)
ans[1][i] = 0;
else
ans[1][i] = 1;
if (x <= y)
ans[0][i] = 0;
else
ans[0][i] = 1;
}
for (int i = 1; i <= m; i++) printf("%d", ans[0][i]);
puts("");
for (int i = 1; i <= m; i++) printf("%d", ans[1][i]);
puts("");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, seg[4 * N], lazy[4 * N], a[N], tin[N], tout[N], rev[N], timer;
vector<int> adj[N];
void dfs(int node) {
tin[node] = ++timer;
rev[timer] = node;
for (auto &v : adj[node]) dfs(v);
tout[node] = timer;
}
void build(int l, int r, int node) {
if (l == r) {
seg[node] = a[rev[l]];
return;
}
int mid = (l + r) >> 1;
build(l, mid, 2 * node);
build(mid + 1, r, 2 * node + 1);
seg[node] = seg[2 * node] + seg[2 * node + 1];
}
void push(int l, int r, int node) {
if (!lazy[node]) return;
seg[node] = r - l + 1 - seg[node];
if (l != r) {
lazy[2 * node] = 1 - lazy[2 * node];
lazy[2 * node + 1] = 1 - lazy[2 * node + 1];
}
lazy[node] = 0;
}
void update(int l, int r, int node, int ql, int qr) {
push(l, r, node);
if (r < ql || qr < l) return;
if (ql <= l && r <= qr) {
lazy[node] ^= 1;
push(l, r, node);
return;
}
int mid = (l + r) >> 1;
update(l, mid, 2 * node, ql, qr);
update(mid + 1, r, 2 * node + 1, ql, qr);
seg[node] = seg[2 * node] + seg[2 * node + 1];
}
int query(int l, int r, int node, int ql, int qr) {
push(l, r, node);
if (r < ql || qr < l) return 0;
if (ql <= l && r <= qr) return seg[node];
int mid = (l + r) >> 1;
return query(l, mid, 2 * node, ql, qr) +
query(mid + 1, r, 2 * node + 1, ql, qr);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 2, p; i <= n; i++) {
cin >> p;
adj[p].push_back(i);
}
dfs(1);
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, n, 1);
int q;
cin >> q;
while (q--) {
string s;
cin >> s;
int node;
cin >> node;
if (s[0] == 'g')
cout << query(1, n, 1, tin[node], tout[node]) << "\n";
else
update(1, n, 1, tin[node], tout[node]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
int len;
int freq[2], lps[500005];
void LongestPrefixSuffix(string& pattern) {
int L = 0, R, sz = pattern.size();
for (R = 1; R < sz;) {
if (pattern[L] == pattern[R]) {
lps[R] = L + 1;
L++;
R++;
} else {
if (L != 0) {
L = lps[L - 1];
} else {
lps[R] = 0;
R++;
}
}
}
}
void input() {
cin >> s;
cin >> t;
len = s.size();
for (int i = 0; i < len; i++) {
if (s[i] == '0')
freq[0]++;
else if (s[i] == '1')
freq[1]++;
}
}
string prefx = "", extra = "", key = "";
bool f1, f2;
int ache;
int fun1() {
bool sotto = 1;
for (int i = 0; i < prefx.size(); i++) {
if (freq[prefx[i] - 48]) {
cout << prefx[i];
freq[prefx[i] - 48]--;
} else {
while (freq[0] > 0) {
cout << 0;
freq[0]--;
}
while (freq[1] > 0) {
cout << 1;
freq[1]--;
}
return 0;
}
}
while (sotto) {
for (int i = 0; i < extra.size(); i++) {
if (freq[extra[i] - 48]) {
cout << extra[i];
freq[extra[i] - 48]--;
} else {
sotto = 0;
break;
}
}
}
while (freq[0] > 0) {
cout << 0;
freq[0]--;
}
while (freq[1] > 0) {
cout << 1;
freq[1]--;
}
return 0;
}
int main() {
input();
LongestPrefixSuffix(t);
ache = lps[t.size() - 1];
int tsz = t.size();
for (int i = 0; i < ache; i++) prefx += t[i];
for (int i = ache; i < tsz; i++) extra += t[i];
int res = fun1();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t, n;
cin >> t;
while (t--) {
cin >> n;
string s;
cin >> s;
long long int c = 0;
stack<char> a;
for (long long int i = 0; i < n; i++) {
if (s[i] == '(')
a.push(s[i]);
else {
if (a.empty())
c++;
else
a.pop();
}
}
cout << c << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> aa(n, 0);
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a) {
aa[max(0, i - a)] += 1;
aa[i] -= 1;
}
}
int ans = n, cur = 0;
for (int i = 0; i < n; i++) {
cur += aa[i];
if (cur) ans--;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N], b[N], c[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c[i];
}
a[1] = 1;
for (int i = 2; i <= n; i++) {
if (c[i] > c[i - 1])
a[i] = a[i - 1] + 1;
else
a[i] = 1;
}
b[n] = 1;
for (int i = n - 1; i > 0; i--) {
if (c[i] < c[i + 1])
b[i] = b[i + 1] + 1;
else
b[i] = 1;
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (c[i + 1] - c[i - 1] > 1)
res = max(res, a[i - 1] + b[i + 1] + 1);
else
res = max(res, max(a[i - 1], b[i + 1]) + 1);
}
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char small[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
char capital[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
map<char, int> mps;
map<char, int> mpt;
int main() {
string s, t;
cin >> s >> t;
long long siz = s.size();
for (int i = 0; i < siz; i++) {
mps[s[i]]++;
}
siz = t.size();
for (int i = 0; i < siz; i++) {
mpt[t[i]]++;
}
long long yay = 0, whoops = 0;
for (int i = 0; i < 26; i++) {
if (mpt[small[i]] >= mps[small[i]]) {
mpt[small[i]] -= mps[small[i]];
yay += mps[small[i]];
mps[small[i]] = 0;
} else {
mps[small[i]] -= mpt[small[i]];
yay += mpt[small[i]];
mpt[small[i]] = 0;
}
if (mpt[capital[i]] >= mps[capital[i]]) {
mpt[capital[i]] -= mps[capital[i]];
yay += mps[capital[i]];
mps[capital[i]] = 0;
} else {
mps[capital[i]] -= mpt[capital[i]];
yay += mpt[capital[i]];
mpt[capital[i]] = 0;
}
}
for (int i = 0; i < 26; i++) {
if (mps[small[i]] && mpt[capital[i]]) {
whoops += min(mps[small[i]], mpt[capital[i]]);
}
if (mps[capital[i]] && mpt[small[i]]) {
whoops += min(mps[capital[i]], mpt[small[i]]);
}
}
cout << yay << " " << whoops << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 2000;
typedef struct P {
long long x, y;
P() {}
P(long long x, long long y) : x(x), y(y) {}
} P;
bool operator<(const P &a, const P &b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
bool operator==(const P &a, const P &b) { return a.x == b.x && a.y == b.y; }
P operator-(const P &a, const P &b) { return P(a.x - b.x, a.y - b.y); }
long long operator*(const P &a, const P &b) { return a.x * b.x + a.y * b.y; }
int n;
P p[MAXN];
P c;
int mlt;
long long v[MAXN];
bool ok(const P &dir) {
for (int i = (0); i < (n); ++i) v[i] = p[i] * dir;
sort(v, v + n);
long long sum = v[0] + v[n - 1];
for (int i = (0); i < (n); ++i)
if (v[i] + v[n - i - 1] != sum) return false;
return true;
}
void run() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) scanf("%lld%lld", &p[i].x, &p[i].y);
mlt = n;
c.x = c.y = 0;
for (int i = (0); i < (n); ++i) c.x += p[i].x, c.y += p[i].y;
set<P> have;
for (int i = (0); i < (n); ++i) {
P cur = P(mlt * p[i].x, mlt * p[i].y);
P opp = c - (cur - c);
if (cur == opp)
continue;
else if (have.count(opp))
have.erase(opp);
else
have.insert(cur);
}
n = 0;
for (auto it = have.begin(); it != have.end(); ++it)
p[n++] = P(it->x / mlt, it->y / mlt);
if (n == 0) {
printf("-1\n");
return;
}
set<P> ptest;
for (int j = (0); j < (n); ++j) {
P a = P(2 * c.x, 2 * c.y),
b = P(mlt * (p[0].x + p[j].x), mlt * (p[0].y + p[j].y));
P dir = P((b - a).y, -(b - a).x);
if (dir.x < 0 || dir.x == 0 && dir.y < 0) dir.x = -dir.x, dir.y = -dir.y;
long long g = gcd(dir.x, abs(dir.y));
dir.x /= g, dir.y /= g;
ptest.insert(dir);
}
int ret = 0;
for (auto it = ptest.begin(); it != ptest.end(); ++it)
if (ok(*it)) ++ret;
printf("%d\n", ret);
}
int main() {
run();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int j = 0; j < n; j++) {
int m;
long long ans = 0;
cin >> m;
pair<long long, long long> ar[m + 5];
for (int i = 0; i < m; i++) {
cin >> ar[i].first >> ar[i].second;
ans += ar[i].second;
}
sort(ar, ar + m);
priority_queue<long long> pq;
int pt = 1, pt2 = 0;
bool flag = 0;
if (m == 1) ans = 0;
while (pt < m) {
if (pq.empty()) flag = 0;
while (pt2 < m && ar[pt2].first <= pt) {
if (ar[pt2].first == 0) flag = 1;
pq.push(ar[pt2++].second);
}
if (!pq.empty()) {
ans -= pq.top();
pq.pop();
}
pt++;
}
if (!flag)
cout << ans << endl;
else
cout << 0 << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const int N = 3e5 + 5;
const int MOD = 1e9 + 7;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
long long v[N], w[N], t[N];
long long n, a, b, c, d, start, len;
long long st[4 * N];
void build(int p, int l, int r) {
if (l == r) {
st[p] = w[l];
return;
}
int m = (l + r) / 2;
build(2 * p, l, m);
build(2 * p + 1, m + 1, r);
st[p] = min(st[2 * p], st[2 * p + 1]);
}
long long query(int p, int l, int r, int i, int j) {
if (r < i or l > j) return LINF;
if (l >= i and r <= j) return st[p];
int m = (l + r) / 2;
return min(query(2 * p, l, m, i, j), query(2 * p + 1, m + 1, r, i, j));
}
int main() {
scanf("%lld %lld %lld %lld %lld %lld %lld", &n, &a, &b, &c, &d, &start, &len);
v[0] = w[0] = start;
for (int i = 1; i <= n; i++) {
long long u;
scanf("%lld %lld", &t[i], &u);
if (u) {
v[i] = v[i - 1] + a;
w[i] = w[i - 1] + c;
} else {
v[i] = v[i - 1] - b;
w[i] = w[i - 1] - d;
}
}
build(1, 1, n);
int tm = 1;
for (int i = 0; i <= n; i++) {
if (v[i] < 0) return printf("-1\n"), 0;
while (t[tm] < t[i] + len + 1 and tm <= n) tm++;
long long mn = query(1, 1, n, i + 1, tm - 1) - w[i];
if (v[i] + mn >= 0) return printf("%lld\n", i == 0 ? 0 : t[i] + 1), 0;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
double n, r;
scanf("%lf%lf", &n, &r);
double a = atan(1) * 2 / n;
printf("%.10f\n", r * r * n * sin(2 * a) * sin(a) / sin((n * 2 - 3) * a));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 5e5 + 5;
vector<int> g[maxn], w;
int du[maxn], dv[maxn], del[maxn], f[maxn], p[maxn], st[maxn], tot = 0;
bool vis[maxn], vedge[maxn];
void dfs(int u, int fa) {
if (vis[u]) {
w.clear();
int v, pre = u;
for (int i = tot; i > 0; --i) {
v = du[st[i]] ^ dv[st[i]] ^ pre;
w.push_back(st[i]);
if (v == u) break;
pre = v;
}
rotate(w.begin(), min_element(w.begin(), w.end()), w.end());
int i = 1, j = w.size() - 1;
while (i < j && w[i] < w[i + 1]) i++;
while (i < j && w[j] < w[j - 1]) j--;
if (i == j) p[w[i]] = w[0];
return;
}
vis[u] = 1;
for (auto i : g[u]) {
int v = du[i] ^ dv[i] ^ u;
if (v == fa || vedge[i]) continue;
vedge[i] = 1;
st[++tot] = i;
dfs(v, u);
tot--;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &du[i], &dv[i]);
g[du[i]].push_back(i);
g[dv[i]].push_back(i);
}
dfs(1, 0);
fill(f + 1, f + n + 1, 1);
for (int i = m; i > 0; --i) {
f[du[i]] = f[dv[i]] = f[du[i]] + f[dv[i]] - del[i];
if (p[i]) del[p[i]] = f[du[i]];
}
for (int i = 1; i <= n; ++i) printf("%d ", f[i] - 1);
;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int d(char a[], char b[], int n) {
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int p(char c[]) {
char str[11];
int n = 0;
for (int i = 0; i < 11; i++) {
if (c[i] == 0)
break;
else
n += 1;
}
for (int i = n - 1; i >= 0; i--) {
str[n - i - 1] = c[i];
}
if (d(str, c, n) == 1) return 1;
return 0;
}
int main() {
char a[10], b[11];
cin >> a;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < i; j++) {
b[j] = a[j];
}
for (char c = 'a'; c <= 'z'; c++) {
b[i] = c;
for (int k = i + 1; k < 11; k++) {
b[k] = a[k - 1];
}
if (p(b) == 1) {
for (int k = 0; k < 11; k++) {
if (b[k] == 0) {
break;
}
cout << b[k];
}
return 0;
}
}
}
cout << "NA";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, k, b, x, a;
struct Matrix {
long long int arr[101][101];
Matrix() {
for (int i = 0; i < x; i++) {
for (int j = 0; j < x; j++) {
arr[i][j] = 0;
}
}
}
Matrix operator*(Matrix a) {
Matrix C;
for (int i = 0; i < x; i++) {
for (int j = 0; j < x; j++) {
long long int ans = 0;
for (int k = 0; k < x; k++) {
ans = (ans + (a.arr[i][k] * arr[k][j])) % 1000000007LL;
}
C.arr[i][j] = ans;
}
}
return C;
}
Matrix power(int exp) {
if (exp == 1) return *this;
if (exp % 2 == 0) {
Matrix root = this->power(exp / 2);
return root * root;
} else {
Matrix oneless = this->power(exp - 1);
return (*this) * oneless;
}
}
};
int main() {
Matrix M;
cin >> n >> b >> k >> x;
for (int i = 0; i < n; i++) {
cin >> a;
for (int j = 0; j < x; j++) {
M.arr[j][(10 * j + a) % x]++;
}
}
cout << M.power(b).arr[0][k] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int test;
cin >> test;
while (test--) {
long long int n;
cin >> n;
long long int x = __builtin_popcount(n);
long long int y = pow(2, x);
cout << y << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cout << setprecision(12);
int n;
cin >> n;
;
vector<int> p(n);
for (int i = 0; i < n; i++) cin >> p[i];
;
for (int i = 0; i < n; i++) {
if (p[i] != -1) p[i]--;
}
vector<int> h(n, 1);
for (int i = 0; i < n; i++) {
for (int k = i; p[k] != -1; k = p[k]) {
h[i]++;
}
}
int result = 1;
for (int i = 0; i < n; i++) {
result = max(result, h[i]);
}
cout << result << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, p;
long long cnt[300005], cntt[300005];
int x[300005], y[300005];
map<pair<int, int>, int> many;
map<pair<int, int>, bool> done;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> p;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
if (x[i] > y[i]) swap(x[i], y[i]);
--x[i];
--y[i];
many[make_pair(x[i], y[i])]++;
cnt[x[i]]++;
cnt[y[i]]++;
}
for (int i = 0; i < n; i++) cntt[i] = cnt[i];
sort(cntt, cntt + n);
long long ans = 0;
for (int i = 0; i < n - 1; i++) {
if (cntt[i] + cntt[n - 1] < p) continue;
int lo = i + 1;
int hi = n - 1;
while (lo < hi) {
int m = (lo + hi) >> 1;
if (cntt[m] >= p - cntt[i])
hi = m;
else
lo = m + 1;
}
ans += n - lo;
}
for (int i = 0; i < n; i++)
if (done[make_pair(x[i], y[i])] == 0) {
done[make_pair(x[i], y[i])] = 1;
if (cnt[x[i]] + cnt[y[i]] >= p) ans--;
if (cnt[x[i]] + cnt[y[i]] - many[make_pair(x[i], y[i])] >= p) ans++;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
;
const long long N = 200 * 1000 + 20, inf = 1e18, M = 1e6 + 20;
long long n, m, p, a[N], ca[N], costa[M], b[N], cb[N], costb[M], seg[M << 2],
lazy[M << 2], tmp[N], x[N], y[N], z[N], ans = -inf;
void shift(int id) {
seg[id << 1] += lazy[id];
seg[id << 1 | 1] += lazy[id];
lazy[id << 1] += lazy[id];
lazy[id << 1 | 1] += lazy[id];
lazy[id] = 0;
}
void build(int id = 1, int st = 0, int en = M - 1) {
if (en - st == 1) {
seg[id] = -costb[st];
return;
}
int mid = st + en >> 1;
build(id << 1, st, mid);
build(id << 1 | 1, mid, en);
seg[id] = max(seg[id << 1], seg[id << 1 | 1]);
}
void update(int l, int r, long long val, int id = 1, int st = 0,
int en = M - 1) {
if (r <= st || en <= l) return;
if (l <= st && en <= r) {
seg[id] += val;
lazy[id] += val;
return;
}
int mid = st + en >> 1;
shift(id);
update(l, r, val, id << 1, st, mid);
update(l, r, val, id << 1 | 1, mid, en);
seg[id] = max(seg[id << 1], seg[id << 1 | 1]);
}
long long get(int l, int r, int id = 1, int st = 0, int en = M - 1) {
if (r <= st || en <= l) return 0;
if (l <= st && en <= r) return seg[id];
int mid = st + en >> 1;
shift(id);
return max(get(l, r, id << 1, st, mid), get(l, r, id << 1 | 1, mid, en));
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m >> p;
fill(costa, costa + M, inf);
fill(costb, costb + M, inf);
for (int i = 0; i < n; i++) cin >> a[i] >> ca[i];
for (int i = 0; i < m; i++) cin >> b[i] >> cb[i];
for (int i = 0; i < p; i++) cin >> x[i] >> y[i] >> z[i];
for (int i = 0; i < n; i++) costa[a[i]] = min(costa[a[i]], ca[i]);
for (int i = 0; i < m; i++) costb[b[i]] = min(costb[b[i]], cb[i]);
for (int i = M - 2; ~i; i--) costa[i] = min(costa[i], costa[i + 1]);
for (int i = M - 2; ~i; i--) costb[i] = min(costb[i], costb[i + 1]);
iota(tmp, tmp + p, 0);
sort(tmp, tmp + p, [](int i, int j) { return x[i] < x[j]; });
build();
ans = -(costa[1] + costb[1]);
for (int i = 0; i < p; i++) {
update(y[tmp[i]] + 1, M, z[tmp[i]]);
ans = max(ans, seg[1] - costa[x[tmp[i]] + 1]);
}
return cout << ans << endl, 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int IN() {
int x = 0, f = 0, ch;
for (; (ch = getchar()) < '0' || ch > '9';) f = (ch == '-');
for (; ch >= '0' && ch <= '9'; (ch = getchar())) x = x * 10 + ch - '0';
return f ? -x : x;
}
int N, M, A[100005][3], B[100005][3];
int D, st[100005], V[100005], Deg[100005];
int Q[100005], Ans[2], Dp[100005][2][2];
struct Lin {
int v, c, next;
} E[100005 << 1];
map<int, int> G[100005], H[100005];
void Link(int u, int v, int c) {
E[++D] = (Lin){v, c, st[u]};
st[u] = D;
Deg[u]++;
E[++D] = (Lin){u, c, st[v]};
st[v] = D;
Deg[v]++;
G[u][v] = G[v][u] = c;
}
void Plu(int& a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
void Upd(int x, int y) {
int a = Ans[0], b = Ans[1];
Ans[0] = (1ll * a * x + 1ll * y * b) % 1000000007;
Ans[1] = (1ll * x * b + 1ll * y * a) % 1000000007;
}
int main(int argc, char* argv[]) {
N = IN();
M = IN();
for (int i = 1, lim = N; i <= lim; i++) {
*B[i] = IN();
for (int j = 1, lim = *B[i]; j <= lim; j++) {
B[i][j] = IN();
int x = abs(B[i][j]);
A[x][++*A[x]] = i;
H[i][x] = B[i][j] > 0;
}
}
for (int i = 1, lim = M; i <= lim; i++)
if (*A[i] > 1) {
int x = 0, y = 0;
for (int j = 1, lim = *B[A[i][1]]; j <= lim; j++)
if (abs(B[A[i][1]][j]) == i) x = B[A[i][1]][j] > 0;
for (int j = 1, lim = *B[A[i][2]]; j <= lim; j++)
if (abs(B[A[i][2]][j]) == i) y = B[A[i][2]][j] > 0;
Link(A[i][1], A[i][2], x ^ y);
}
Ans[0] = 1;
for (int i = 1, lim = M; i <= lim; i++)
if (*A[i] == 0) Upd(2, 0);
for (int i = 1, lim = N; i <= lim; i++)
if (Deg[i] == 0) {
if (*B[i] == 1)
Upd(1, 1);
else
Upd(1, 3);
}
for (int i = 1, lim = N; i <= lim; i++)
if (Deg[i] == 1 && !V[i]) {
*Q = 0;
for (int u = i;;) {
Q[++*Q] = u;
V[u] = 1;
for (int j = st[u], v; j; j = E[j].next)
if (!V[v = E[j].v]) {
u = v;
break;
}
if (V[u]) break;
}
for (int j = 0, lim = *Q; j <= lim; j++)
for (int a = 0, lim = 1; a <= lim; a++)
for (int b = 0, lim = 1; b <= lim; b++) Dp[j][a][b] = 0;
if (*B[i] == 1)
Dp[1][1][1] = 1, Dp[1][0][0] = 1;
else
Dp[1][1][1] = 2, Dp[1][0][1] = 1, Dp[1][0][0] = 1;
for (int j = 2, lim = *Q; j <= lim; j++)
for (int a = 0, lim = 1; a <= lim; a++)
for (int b = 0, lim = 1; b <= lim; b++) {
int c = a ^ G[Q[j - 1]][Q[j]];
if (*B[Q[j]] == 2)
for (int d = 0, lim = 1; d <= lim; d++)
Plu(Dp[j][d][(c | d) ^ b], Dp[j - 1][a][b]);
else
Plu(Dp[j][0][c ^ b], Dp[j - 1][a][b]);
}
int x = 0, y = 0;
for (int a = 0, lim = 1; a <= lim; a++)
Plu(x, Dp[*Q][a][0]), Plu(y, Dp[*Q][a][1]);
Upd(x, y);
}
for (int i = 1, lim = N; i <= lim; i++)
if (Deg[i] == 2 && !V[i]) {
*Q = 0;
for (int u = i;;) {
Q[++*Q] = u;
V[u] = 1;
for (int j = st[u], v; j; j = E[j].next)
if (!V[v = E[j].v]) {
u = v;
break;
}
if (V[u]) break;
}
if (*Q == 1) {
if (B[Q[1]][1] != B[Q[1]][2])
Upd(0, 2);
else
Upd(1, 1);
continue;
}
if (*Q == 2) {
int x = 0, y = 0;
for (int a = 0, lim = 1; a <= lim; a++)
for (int b = 0, lim = 1; b <= lim; b++) {
int c, d;
{
int t = B[Q[1]][1];
if (H[Q[1]][t] ^ H[Q[2]][t])
c = a ^ 1;
else
c = a;
}
{
int t = B[Q[1]][2];
if (H[Q[1]][t] ^ H[Q[2]][t])
d = b ^ 1;
else
d = b;
}
if ((a | b) ^ (c | d))
y++;
else
x++;
}
Upd(x, y);
continue;
}
int x = 0, y = 0;
for (int e = 0, lim = 1; e <= lim; e++) {
for (int j = 0, lim = *Q; j <= lim; j++)
for (int a = 0, lim = 1; a <= lim; a++)
for (int b = 0, lim = 1; b <= lim; b++) Dp[j][a][b] = 0;
for (int a = 0, lim = 1; a <= lim; a++) Dp[1][a][e | a]++;
for (int j = 2, lim = *Q; j <= lim; j++)
for (int a = 0, lim = 1; a <= lim; a++)
for (int b = 0, lim = 1; b <= lim; b++) {
int c = a ^ G[Q[j - 1]][Q[j]];
if (j < *Q)
for (int d = 0, lim = 1; d <= lim; d++)
Plu(Dp[j][d][(c | d) ^ b], Dp[j - 1][a][b]);
else {
int d = e ^ G[Q[1]][Q[*Q]];
Plu(Dp[j][d][(c | d) ^ b], Dp[j - 1][a][b]);
}
}
for (int a = 0, lim = 1; a <= lim; a++)
Plu(x, Dp[*Q][a][0]), Plu(y, Dp[*Q][a][1]);
}
Upd(x, y);
}
printf("%d\n", Ans[1]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int_fast64_t t;
cin >> t;
while (t--) {
int_fast64_t n;
cin >> n;
string s;
cin >> s;
int_fast64_t sum = 0;
for (int_fast64_t i = 0; i < n; i++) {
if ((s[i] - '0') != 0) {
sum += s[i] - '0';
sum += (i != (n - 1));
}
}
cout << sum << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
class BCompositeColoring {
public:
void solve(std::istream &in, std::ostream &out) {
int n, cnt = 1;
in >> n;
vector<pair<int, bool>> v(n);
bool flag = false;
for (int i = 0; i < n; i++) {
int p;
in >> p;
v[i] = make_pair(p, true);
}
for (int i = 2; i < n; i++) {
flag = false;
for (int j = 0; j < n; j++) {
if (!v[j].second) continue;
if (v[j].first % i == 0) {
v[j].second = false;
v[j].first = cnt;
flag = true;
}
}
if (flag) cnt++;
}
for (auto &data : v) {
if (data.second) {
data.first = cnt;
cnt++;
}
}
out << cnt - 1 << endl;
for (auto data : v) out << data.first << ' ';
out << endl;
}
};
int main() {
std::ios_base::sync_with_stdio(0);
std::cin.tie(nullptr);
BCompositeColoring solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
int n;
in >> n;
for (int i = 0; i < n; ++i) {
solver.solve(in, out);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.F);
putchar(' ');
_W(x.S);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
const int MAXN = 1e6 + 10, MAXM = 4e6 + 10;
const int INF = INT_MAX, SINF = 0x3f3f3f3f;
const long long llINF = LLONG_MAX;
const int MOD = 1e9 + 7, mod = 998244353;
const int inv2 = 5e8 + 4;
const int Lim = 1 << 20;
char s[MAXN], t[MAXN];
char a[MAXN], b[MAXN];
int d, n, q = 1;
long long cnt[1005][2];
int dp[52][505 * 505][2];
struct ACautomaton {
struct Node {
int val, fail, son[26];
} t[MAXN];
int cnt;
void insert_Trie(char *s) {
int u = 0, n = strlen(s);
for (int i = 0; i < n; i++) {
if (!t[u].son[s[i] - '0']) t[u].son[s[i] - '0'] = ++cnt;
u = t[u].son[s[i] - '0'];
t[u].val = i + 1;
}
}
queue<int> q;
void getfail() {
for (int i = 0; i < 10; i++)
if (t[0].son[i]) q.push(t[0].son[i]);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < 10; i++) {
if (t[u].son[i]) {
t[t[u].son[i]].fail = t[t[u].fail].son[i];
q.push(t[u].son[i]);
} else
t[u].son[i] = t[t[u].fail].son[i];
}
}
}
} G;
long long calc(char *s, int pd) {
int d = strlen(s);
cnt[d][0] = cnt[d][1] = 1;
for (int i = d - 1; ~i; i--)
cnt[i][0] = cnt[i + 1][0] * 10 % MOD,
cnt[i][1] = (s[i] - '0') * cnt[i + 1][0] % MOD + cnt[i + 1][1];
long long ans = 0;
for (int i = 0; i <= d; i++) memset(dp[i], 0, sizeof(dp[i]));
dp[0][0][1] = 1;
for (int i = 0; i < d; i++)
for (int j = 0; j <= G.cnt; j++)
if (G.t[j].val < pd) {
for (int k = 0; k < 10; k++) {
int u = G.t[j].son[k];
(dp[i + 1][u][0] += dp[i][j][0]) %= MOD;
if (k < s[i] - '0') (dp[i + 1][u][0] += dp[i][j][1]) %= MOD;
if (k == s[i] - '0') (dp[i + 1][u][1] += dp[i][j][1]) %= MOD;
}
}
for (int i = 1; i <= d; i++)
for (int j = 0; j <= G.cnt; j++)
if (G.t[j].val == pd) {
(ans += 1ll * dp[i][j][0] * cnt[i][0] % MOD +
1ll * dp[i][j][1] * cnt[i][1] % MOD) %= MOD;
}
return ans;
}
void solve() {
R(s, a, b);
n = strlen(s);
int k = strlen(a) - 1;
d = strlen(a);
while (a[k] == '0') a[k--] = '9';
a[k]--;
for (int i = 0; i < d / 2; i++) t[i] = s[i];
for (int i = d / 2; i < n; i++) {
G.insert_Trie(t + i - d / 2);
t[i] = s[i];
}
G.insert_Trie(t + n - d / 2);
G.getfail();
while (q--) {
W((calc(b, d / 2) - calc(a, d / 2) + MOD) % MOD);
}
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using ii = pair<int, int>;
using ld = long double;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<int> prio;
using Key = long long;
struct Node {
int y;
Node *l, *r;
Key x;
int size;
long long sum;
long long ans;
Node(const Key& k) : y(prio(rng)), l(nullptr), r(nullptr), x(k) { fix(); }
void fix() {
size = 1;
sum = x;
ans = 0;
if (l) {
size += l->size;
sum += l->sum;
ans += l->ans;
ans += x * l->size - l->sum;
}
if (r) {
ans += r->sum * size - sum * r->size;
size += r->size;
sum += r->sum;
ans += r->ans;
}
}
};
void split(Node* v, const Key& sx, Node*& sl, Node*& sr) {
if (v) {
if (sx <= v->x) {
split(v->l, sx, sl, v->l);
sr = v;
} else {
split(v->r, sx, v->r, sr);
sl = v;
}
v->fix();
} else {
sl = sr = nullptr;
}
}
void merge(Node*& v, Node* ml, Node* mr) {
if (ml || mr) {
if (!ml) {
v = mr;
} else if (!mr) {
v = ml;
} else {
if (ml->y < mr->y) {
merge(mr->l, ml, mr->l);
v = mr;
} else {
merge(ml->r, ml->r, mr);
v = ml;
}
}
v->fix();
} else {
v = nullptr;
}
}
struct Set {
Node* root;
Set() : root(nullptr) {}
void move(long long x, int d) {
Node *head, *body, *tail, *head2, *tail2;
split(root, x, head, tail);
split(tail, x + 1, body, tail);
body->x = x + d;
body->fix();
if (d < 0) {
split(head, x + d, head2, tail2);
merge(tail2, body, tail2);
merge(head, head2, tail2);
} else {
split(tail, x + d, head2, tail2);
merge(tail2, body, tail2);
merge(tail, head2, tail2);
}
merge(root, head, tail);
}
void insert(long long x) {
Node *head, *tail;
split(root, x, head, tail);
merge(tail, new Node(x), tail);
merge(root, head, tail);
}
long long query(long long l, long long r) {
Node *head, *body, *tail;
split(root, l, head, tail);
split(tail, r + 1, body, tail);
long long ans = body == nullptr ? 0 : body->ans;
merge(tail, body, tail);
merge(root, head, tail);
return ans;
}
};
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
Set s;
int n;
cin >> n;
vector<long long> p(n);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
p[i] = x;
s.insert(x);
}
int m;
cin >> m;
while (m--) {
int o;
cin >> o;
switch (o) {
case 1: {
int i, d;
cin >> i >> d;
--i;
s.move(p[i], d);
p[i] += d;
} break;
case 2: {
int l, r;
cin >> l >> r;
cout << s.query(l, r) << '\n';
} break;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int inf_ = 0x7fffffff;
const long long inff = 4557430888798830399ll;
const double pi = acos(-1.0);
long long mod = 1e9 + 7;
struct HUNGARY {
HUNGARY() { init(0, 0); };
int n, m, to[10004], vt[10004];
bool vis[10004];
vector<int> N[10004];
void init(int _n, int _m) {
n = _n;
m = _m;
for (int i = (1); i <= (n); ++i) N[i].clear();
memset(to, 0, sizeof(to));
memset(vt, 0, sizeof(vt));
}
void link(int u, int v) { N[u].push_back(v); }
bool dfs(int u) {
for (auto v : N[u])
if (!vis[v]) {
vis[v] = 1;
if (!to[v] || dfs(to[v])) {
to[v] = u, vt[u] = v;
return 1;
}
}
return 0;
}
void run() {
for (int i = (1); i <= (n); ++i)
if (!vt[i]) {
memset(vis, 0, sizeof(vis));
dfs(i);
}
}
set<int> A, B;
void dfsc(int u) {
A.erase(u);
for (auto v : N[u])
if (!vis[v]) {
vis[v] = 1;
B.insert(v);
if (to[v] && A.count(to[v])) dfsc(to[v]);
}
}
void cover() {
memset(vis, 0, sizeof(vis));
A.clear();
B.clear();
for (int i = (1); i <= (n); ++i) A.insert(i);
for (int i = (1); i <= (n); ++i)
if (!vt[i]) dfsc(i);
}
} h;
map<int, vector<int> > X, Y;
vector<pair<pair<int, int>, pair<int, int> > > V, H, A, B;
void pt(pair<int, int> p) { cout << "(" << p.first << "," << p.second << ")"; }
bool cross(pair<pair<int, int>, pair<int, int> > p,
pair<pair<int, int>, pair<int, int> > q) {
return q.first.first < p.first.first && p.first.first < q.second.first &&
p.first.second < q.second.second && q.second.second < p.second.second;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, x, y;
vector<pair<int, int> > z;
int o[10004];
cin >> n;
for (int i = (0); i < (n); ++i) {
cin >> x >> y;
X[x].push_back(y);
Y[y].push_back(x);
z.push_back(make_pair(x, y));
}
for (auto z : X) {
sort((z.second).begin(), (z.second).end());
for (int i = (0); i < (((int)z.second.size()) - 1); ++i)
V.push_back(make_pair(make_pair(z.first, z.second[i]),
make_pair(z.first, z.second[i + 1])));
}
for (auto z : Y) {
sort((z.second).begin(), (z.second).end());
for (int i = (0); i < (((int)z.second.size()) - 1); ++i)
H.push_back(make_pair(make_pair(z.second[i], z.first),
make_pair(z.second[i + 1], z.first)));
}
h.init(((int)V.size()), ((int)H.size()));
for (int i = (0); i < (((int)V.size())); ++i)
for (int j = (0); j < (((int)H.size())); ++j)
if (cross(V[i], H[j])) h.link(i + 1, j + 1);
h.run();
h.cover();
for (int i = (0); i < (((int)V.size())); ++i)
if (!h.A.count(i + 1)) {
if (!((int)A.size()) || A.back().second != V[i].first)
A.push_back(V[i]);
else
A[((int)A.size()) - 1].second = V[i].second;
}
for (int i = (0); i < (((int)H.size())); ++i)
if (!h.B.count(i + 1)) {
if (!((int)B.size()) || B.back().second != H[i].first)
B.push_back(H[i]);
else
B[((int)B.size()) - 1].second = H[i].second;
}
memset(o, 0, sizeof(o));
for (int i = (0); i < (((int)z.size())); ++i) {
for (int j = (0); j < (((int)A.size())); ++j)
if (A[j].first.first == z[i].first && A[j].first.second <= z[i].second &&
z[i].second <= A[j].second.second)
o[i] |= 1;
for (int j = (0); j < (((int)B.size())); ++j)
if (B[j].second.second == z[i].second && B[j].first.first <= z[i].first &&
z[i].first <= B[j].second.first)
o[i] |= 2;
}
for (int i = (0); i < (((int)z.size())); ++i) {
if ((o[i] & 1) == 0) A.push_back(make_pair(z[i], z[i]));
if ((o[i] & 2) == 0) B.push_back(make_pair(z[i], z[i]));
}
swap(A, B);
cout << ((int)A.size()) << endl;
for (auto z : A)
cout << z.first.first << " " << z.first.second << " " << z.second.first
<< " " << z.second.second << endl;
cout << ((int)B.size()) << endl;
for (auto z : B)
cout << z.first.first << " " << z.first.second << " " << z.second.first
<< " " << z.second.second << endl;
}
| 9 |
#include <bits/stdc++.h>
const long long mod = (long long)1e9 + 7;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
vector<long long> v(m);
bool valid = true;
for (long long i = 0; i < m; i++) {
cin >> v[i];
if (v[i] == n or v[i] == 1) valid = 0;
}
if (!valid) {
cout << "NO"
<< "\n";
return 0;
}
sort(v.begin(), v.end());
for (long long i = 2; i < m; i++) {
if (v[i] - 1 == v[i - 1] and v[i] - 2 == v[i - 2]) {
valid = 0;
break;
}
}
if (valid)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, k, sum = 0, ans = 0, count = 0, c1 = 0, c2 = 0, x = -1;
cin >> n >> k;
long long a[5001] = {0}, b[5001] = {0};
a[0] = 0;
a[1] = 0;
a[2] = 0;
sum = 1;
for (i = 3; i < 5001; i++) {
a[i] = sum;
a[i] += a[i - 1];
if (i % 2 == 0) sum++;
}
if (a[n] < k) {
cout << -1;
return 0;
}
if (k == 0) {
cout << 1 << " ";
if (n == 2)
cout << 2 << " ";
else if (n > 2) {
cout << 2 << " ";
b[0] = 1;
b[1] = 2;
for (i = 2; i < n; i++) {
cout << b[1] + (i - 1) * 3 << " ";
}
}
return 0;
}
j = lower_bound(a, a + n + 1, k) - a;
if (a[j] == k) {
for (i = 1; i <= j; i++) {
cout << i << " ";
b[i] = i;
}
for (i = j + 1; i <= n; i++) {
cout << b[j] + ((i - j) * (b[j] + 1)) << " ";
}
} else {
j--;
for (i = 1; i <= j; i++) {
cout << i << " ";
b[i] = i;
}
k = k - a[j];
if (j % 2 == 0) {
sum = j / 2;
for (i = 1; i <= j - 1; i++) {
if (k == sum) break;
if (i % 2 == 1) sum--;
}
cout << j + i << " ";
b[j + 1] = j + i;
for (i = j + 2; i <= n; i++) {
cout << b[j + 1] + ((i - (j + 1)) * (b[j] + 1)) << " ";
}
} else {
sum = j / 2;
for (i = 1; i <= j - 1; i++) {
if (k == sum) break;
if (i % 2 == 0) sum--;
}
cout << j + i << " ";
b[j + 1] = j + i;
for (i = j + 2; i <= n; i++) {
cout << b[j + 1] + ((i - (j + 1)) * (b[j] + 1)) << " ";
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
long long i, a[n + 5];
for (i = 1; i <= n; i++) cin >> a[i];
long long sum = 0;
multiset<long long, greater<long long> > s;
for (i = 1; i <= n; i++) {
long long cnt = 0;
long long sum1 = sum;
auto it = s.begin();
while (sum1 + a[i] > m) {
sum1 -= (*it);
it++;
cnt++;
}
cout << cnt << " ";
s.insert(a[i]);
sum += a[i];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char a[25], b[25];
int len;
int main() {
cin >> a >> b;
len = strlen(a);
cout << a[0];
for (int i = 1; i < len; i++) {
if (a[i] < b[0])
cout << a[i];
else
break;
}
cout << b[0];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
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);
int n;
cin >> n;
string s;
cin >> s;
string ans;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '4') {
ans += "322";
} else if (s[i] == '6')
ans += "53";
else if (s[i] == '8')
ans += "7222";
else if (s[i] == '9')
ans += "3372";
else if (s[i] != '1' && s[i] != '0')
ans += s[i];
}
sort(ans.begin(), ans.end());
reverse(ans.begin(), ans.end());
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
scanf("%d%d", &m, &n);
if (m == 0 || n == 0 || (m == 1 && n == 1))
printf("0\n");
else if ((m / n) >= 2)
printf("%d\n", n);
else if ((n / m) >= 2)
printf("%d\n", m);
else {
if (m <= n) {
while ((n / m) != 2 && m > 1) {
m--;
n++;
}
printf("%d\n", m);
} else {
while ((m / n) != 2 && n > 1) {
n--;
m++;
}
printf("%d\n", n);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void testing(int position = 0) {
static clock_t clock_tStart;
if (position == 0) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
clock_tStart = clock();
} else {
printf("\n\nTime taken: %fs\n\n",
(double)(clock() - clock_tStart) / CLOCKS_PER_SEC);
}
}
void real_main();
int main() {
real_main();
return 0;
}
void real_main() {
double d, l, v1, v2;
cin >> d >> l >> v1 >> v2;
cout.precision(10);
cout << (l - d) / (v1 + v2);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long d[110][3];
char s[110];
int main() {
int i, k, n;
long long r;
for (scanf("%s", s), n = 0; s[n]; n++)
;
r = 0;
s[n] = s[0];
for (k = 0; k < 3; k++) {
d[0][0] = 0;
d[0][1] = 0;
d[0][2] = 0;
d[0][k] = 1;
for (i = 1; i <= n; i++) {
if (s[i - 1] == 'A' && s[i] == 'A') {
d[i][0] = d[i - 1][0] + d[i - 1][1];
d[i][1] = 0;
d[i][2] = 0;
}
if (s[i - 1] == 'A' && s[i] == 'B') {
d[i][0] = d[i - 1][1];
d[i][1] = 0;
d[i][2] = d[i - 1][0] + d[i - 1][1];
}
if (s[i - 1] == 'B' && s[i] == 'A') {
d[i][0] = d[i - 1][0];
d[i][1] = d[i - 1][2];
d[i][2] = 0;
}
if (s[i - 1] == 'B' && s[i] == 'B') {
d[i][0] = d[i - 1][0];
d[i][1] = 0;
d[i][2] = d[i - 1][0];
}
}
r += d[n][k];
}
printf("%I64d\n", r);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d, n, m, xi, yi, signs[] = {1, -1, -1, 1};
cin >> n >> d >> m;
for (int i = 0; i < m; i++) {
cin >> xi >> yi;
cout << (((xi + yi - d) * signs[0] >= 0 &&
(xi + yi - 2 * n + d) * signs[1] >= 0 &&
(xi - yi - d) * signs[2] >= 0 && (xi - yi + d) * signs[3] >= 0)
? "YES"
: "NO")
<< '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline void printA(long long int _a[], long long int _to,
long long int _from = 0) {
for (long long int _i = _from; _i < _to; _i++) cout << _a[_i] << ' ';
cout << '\n';
}
inline void printV(vector<long long int> _a, long long int _to,
long long int _from = 0) {
for (long long int _i = _from; _i < _to; _i++) cout << _a[_i] << ' ';
cout << '\n';
}
inline void INP() {}
const long long int inf = 0x3f3f3f3f;
const long long int INF = 0x3f3f3f3f3f3f3f3f;
long long int n, m, k, q, d, TIME;
string s;
vector<long long int> adj[(long long int)2e5 + 5];
long long int vis[(long long int)2e5 + 5], Start[(long long int)2e5 + 5],
End[(long long int)2e5 + 5], Depth[(long long int)2e5 + 5],
a[(long long int)2e5 + 5];
class Fenwick {
public:
vector<long long int> BIT;
void init() {
long long int nn = n + 10;
BIT.clear();
BIT.resize(nn, 0);
}
void update(long long int i, long long int val) {
for (; i <= n; i += (i & (-i))) BIT[i] += val;
}
long long int query(long long int i) {
long long int sum = 0;
for (; i > 0; i -= (i & (-i))) sum += BIT[i];
return sum;
}
} odd, even;
void dfs(long long int i, long long int p = 0, long long int d = 0) {
vis[i] = 1;
Start[i] = ++TIME;
Depth[i] = d;
for (auto j : adj[i]) {
if (j == p) continue;
if (!vis[j]) {
dfs(j, i, d + 1);
}
}
End[i] = TIME;
}
void go() {
cin >> n >> m;
odd.init();
even.init();
for (long long int i = 1; i < n + 1; i++) cin >> a[i];
for (long long int i = 0; i < n - 1; i++) {
long long int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1);
while (m--) {
long long int qq, x;
cin >> qq >> x;
if (qq == 1) {
long long int val;
cin >> val;
if (Depth[x] & 1) {
odd.update(Start[x], val);
odd.update(End[x] + 1, -val);
even.update(Start[x], -val);
even.update(End[x] + 1, val);
} else {
even.update(Start[x], val);
even.update(End[x] + 1, -val);
odd.update(Start[x], -val);
odd.update(End[x] + 1, val);
}
} else {
long long int ans = a[x];
if (Depth[x] & 1) {
ans += odd.query(Start[x]);
} else {
ans += even.query(Start[x]);
}
cout << ans << '\n';
}
}
}
int32_t main() {
INP();
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t = 1;
while (t--) go();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
int count = 0;
cin >> str;
for (int i = 0; i < str.length(); i++) {
if (str[i] == '4' || str[i] == '7') count++;
}
if (count == 4 || count == 7)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int A[110];
int main() {
int n, m;
scanf("%d %d", &n, &m);
int last = 0;
while (n--) {
int a, b;
scanf("%d %d", &a, &b);
if (last >= a) last = max(b, last);
}
if (last >= m)
puts("YES");
else
puts("NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int fro[2000005], dep[2000005], maxx[2000005], top[2000005], dis[2000005], ans,
ans1, inf = 1e9, vis[2000005], mx = inf, rt, siz[2000005], num, qwq, n, m,
num1[2000005];
vector<pair<int, int> > vec[2000005];
void dfs(int x, int fa) {
dis[x] = fro[x] = -inf;
if (vis[x]) dis[x] = 0;
for (int i = 0; i < vec[x].size(); i++) {
int y = vec[x][i].first;
if (y == fa) continue;
dfs(y, x);
if (dis[y] + vec[x][i].second > dis[x])
fro[x] = dis[x], dis[x] = dis[y] + vec[x][i].second;
else if (dis[y] + vec[x][i].second > fro[x])
fro[x] = dis[y] + vec[x][i].second;
}
}
void dfs1(int x, int fa, int pre) {
maxx[x] = max(dis[x], pre);
for (int i = 0; i < vec[x].size(); i++) {
int y = vec[x][i].first;
if (y == fa) continue;
if (dis[y] + vec[x][i].second == dis[x])
dfs1(y, x, max(fro[x], pre) + vec[x][i].second);
else
dfs1(y, x, max(dis[x], pre) + vec[x][i].second);
}
if (maxx[x] < mx) mx = maxx[x], rt = x;
}
void dfs2(int x, int fa, int tp) {
dis[x] = fro[x] = -inf;
if (tp) top[x] = tp;
if (vis[x]) siz[x] = 1, dis[x] = 0, num1[x] = 1;
for (int i = 0; i < vec[x].size(); i++) {
int y = vec[x][i].first;
if (y == fa) continue;
dep[y] = dep[x] + vec[x][i].second;
dfs2(y, x, (!tp) ? y : tp);
if (dis[y] + vec[x][i].second == dis[x]) {
if (x == rt) num += siz[y], qwq++;
num1[x] += num1[y];
} else if (dis[y] + vec[x][i].second > dis[x]) {
fro[x] = dis[x];
dis[x] = dis[y] + vec[x][i].second;
if (x == rt) qwq = 1, num = siz[y];
num1[x] = num1[y];
} else if (dis[y] + vec[x][i].second > fro[x]) {
fro[x] = dis[y] + vec[x][i].second;
}
siz[x] += siz[y];
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
vis[x] = 1;
}
maxx[0] = fro[0] = -inf;
for (int i = 1; i < n; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
vec[x].push_back(make_pair(y, z));
vec[y].push_back(make_pair(x, z));
}
dfs(1, 0);
dfs1(1, 0, vis[1] ? 0 : -inf);
memset(fro, 0, sizeof(fro));
memset(dis, 0, sizeof(dis));
dfs2(rt, 0, 0);
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
int x = top[i];
if (i == rt) {
if (siz[i] > ans)
ans = siz[i], ans1 = 1;
else if (siz[i] == ans)
ans1++;
} else if (dis[i] + dep[i] - dep[x] == dis[x] && num1[i] == num1[x]) {
if (qwq >= 3) {
if (siz[i] > ans)
ans = siz[i], ans1 = 1;
else if (siz[i] == ans)
ans1++;
} else if (qwq == 2) {
if (dep[x] + dis[x] == dis[rt]) {
if (siz[i] + num - siz[x] > ans)
ans = siz[i] + num - siz[x], ans1 = 1;
else if (siz[i] + num - siz[x] == ans)
ans1++;
} else {
if (siz[i] > ans)
ans = siz[i], ans1 = 1;
else if (siz[i] == ans)
ans1++;
}
} else {
if (dep[x] + dis[x] == dis[rt]) {
if (siz[i] + siz[rt] - siz[x] > ans)
ans = siz[i] + siz[rt] - siz[x], ans1 = 1;
else if (siz[i] + siz[rt] - siz[x] == ans)
ans1++;
} else if (dep[x] + dis[x] == fro[rt]) {
if (siz[i] + num > ans)
ans = siz[i] + num, ans1 = 1;
else if (siz[i] + num == ans)
ans1++;
} else {
if (siz[i] > ans)
ans = siz[i], ans1 = 1;
else if (siz[i] == ans)
ans1++;
}
}
} else {
if (siz[i] > ans)
ans = siz[i], ans1 = 1;
else if (siz[i] == ans)
ans1++;
}
}
}
printf("%d %d", ans, ans1);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t-- > 0) {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
int f = 1;
for (int i = 0; i < n; i++) {
c[i] = (b[i] - a[i]);
}
for (int i = 0; i < n; i++) {
if (c[i] < 0) {
f = 0;
break;
}
}
if (f == 0) {
cout << "NO" << endl;
} else {
int f1 = 1;
int i, j, k;
for (int i = 0; i < n; i++) {
if (c[i] != 0) {
j = i;
break;
}
}
while ((j + 1) < n && (c[j] == c[j + 1])) {
j += 1;
}
for (k = (j + 1); k < n; k++) {
if (c[k] != 0) {
f1 = 0;
break;
}
}
if (f1 == 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int x, y, k, n;
int main() {
scanf("%d%d%d", &y, &k, &n);
for (x = (y / k + 1) * k - y; x + y <= n; x += k) printf("%d ", x);
if ((y / k + 1) * k > n) puts("-1");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int tab[N], cnt[N], lewo[N];
set<int> secik;
vector<long long> v;
long long solve(long long n, int to_swap) {
vector<long long> w = v;
int www = 0, aaa = -1, blast = 0;
if (to_swap) {
for (auto i = (n / 2 - 1); i >= (v[0]); --i) {
if (tab[i] == to_swap) {
blast = n / 2;
swap(tab[i], tab[n / 2]);
aaa = i;
for (__typeof((w).begin()) it = ((w).begin()); it != (w).end(); ++it) {
if (*it == i) www = 1;
}
if (!www) {
w.push_back(i);
sort((w).begin(), (w).end());
}
break;
}
}
if (!www && (int)((v).size()) == (int)((w).size())) {
for (auto i = (n / 2 + 1); i <= (n - 1); ++i) {
if (tab[i] == to_swap) {
blast = i;
swap(tab[i], tab[n / 2]);
aaa = i;
for (__typeof((w).begin()) it = ((w).begin()); it != (w).end();
++it) {
if (*it == n - i - 1) www = 1;
}
if (!www) {
w.push_back(n - i - 1);
sort((w).begin(), (w).end());
}
break;
}
}
}
}
for (__typeof((w).begin()) it = ((w).begin()); it != (w).end(); ++it) {
lewo[tab[*it]]++;
if (lewo[tab[*it]] >= 0) {
secik.erase(tab[*it]);
}
lewo[tab[n - 1 - *it]]--;
if (lewo[tab[n - 1 - *it]] < 0) {
secik.insert(tab[n - 1 - *it]);
}
}
long long last = w[(int)((w).size()) - 1];
if (to_swap) last = blast;
int pos = (int)((w).size()) - 1;
for (auto i = ((n + 1) / 2); i <= (n - 1); ++i) {
if (secik.empty()) break;
if (pos >= 0 && n - 1 - w[pos] == i) {
lewo[tab[n - 1 - w[pos]]] += 2;
if (lewo[tab[n - 1 - w[pos]]] >= 0) {
secik.erase(tab[n - 1 - w[pos]]);
}
last = max(last, n - 1 - w[pos]);
pos--;
} else {
lewo[tab[i]] += 2;
if (lewo[tab[i]] >= 0) {
secik.erase(tab[i]);
}
last = max(last, i);
}
}
if (to_swap) swap(tab[aaa], tab[n / 2]);
return (long long)(v[0] + 1) * (long long)(n - 1 - v[0] - last);
}
void jebaj() {
int n;
cin >> n;
for (auto i = (0); i <= ((n)-1); ++i) {
cin >> tab[i];
cnt[tab[i]]++;
}
int kupa = 0, dupa = 0;
for (auto i = (0); i <= ((n + 1) - 1); ++i) {
if (n % 2 == 0 && cnt[i] % 2) {
cout << "0\n";
return;
}
if (n % 2 && cnt[i] % 2 && tab[n / 2] != i) {
dupa = i;
}
if (n % 2 && cnt[i] % 2) {
kupa++;
}
}
if (kupa > 1) {
cout << "0\n";
return;
}
for (auto i = (0); i <= ((n / 2) - 1); ++i) {
if (tab[i] != tab[n - i - 1]) v.push_back(i);
}
if (v.empty()) {
long long res = n;
res *= (long long)(n + 1);
res /= 2LL;
cout << res << "\n";
return;
}
long long res = v[0] + 1;
res *= res;
res += solve(n, dupa);
for (auto i = (0); i <= ((n / 2) - 1); ++i) swap(tab[i], tab[n - i - 1]);
for (auto i = (1); i <= (n); ++i) lewo[i] = 0;
secik.clear();
res += solve(n, dupa);
cout << res << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
int t;
t = 1;
for (auto i = (0); i <= ((t)-1); ++i) {
jebaj();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 150000;
string s;
int mx, mxDig;
long long dp[11][2][2][2][2];
long long solve(int i, bool less1, bool less2, bool zero1, bool zero2) {
if (i == -1) return (!zero1 && !zero2) ? 1 : 0;
long long& ret = dp[i][less1][less2][zero1][zero2];
if (~ret) return ret;
ret = 0;
if (i > mx) {
for (int j = 0; j <= (s[i] - '0'); j++) {
for (int k = 0; k <= (s[i] - '0'); k++) {
if (j + k > mxDig) continue;
ret += solve(i - 1, j < (s[i] - '0'), k < (s[i] - '0'), zero1 && j == 0,
zero2 && k == 0);
}
}
} else {
for (int j = 0; j <= (less1 ? 9 : s[i] - '0'); j++) {
for (int k = 9 - j; k <= (less2 ? 9 : s[i] - '0') && k + j <= 9; k++) {
if (j + k != 9) continue;
ret += solve(i - 1, less1 || (j < (s[i] - '0')),
less2 || (k < (s[i] - '0')), zero1 && j == 0,
zero2 && k == 0);
}
}
}
return ret;
}
int main() {
int n;
cin >> n;
if (n <= 4) return cout << n * (n - 1) / 2, 0;
stringstream ss;
int temp = n + (n - 1);
while (temp >= 10) temp /= 10;
mxDig = temp;
temp = 2 * n - 1;
long long curr = 0;
while (true) {
curr *= 10;
curr += 9;
if (curr > temp) break;
mx++;
}
mx--;
ss << n;
ss >> s;
reverse(s.begin(), s.end());
memset(dp, -1, sizeof dp);
printf("%I64d", solve(s.length() - 1, 0, 0, 1, 1) / 2);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[100010];
int d[100010];
bool ok(const int d) {
if (d % 2 == 0) return 0;
for (int i = 1; i <= n; i++)
if ((a[i] - 1) % d != 0) return 0;
return 1;
}
long long calc(int i) {
long long ret = 0;
for (; i < m; i *= 2) ret += m - i;
return ret;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
int k = 0;
long long ret = 0;
for (int i = 1; i <= int(sqrt(a[1] - 1.0) + 1e-8); i++) {
if (ok(i)) ret += calc(i);
if ((a[1] - 1) / i != i && ok((a[1] - 1) / i)) ret += calc((a[1] - 1) / i);
}
printf("%I64d", ret);
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int N = (int)1e6 + 5;
int n, m;
long long ans;
char s[N], t[N];
int sum[N][3][3];
int dic(char c) { return c == 'R' ? 0 : c == 'G' ? 1 : 2; }
int main() {
scanf("%s%s", s, t);
n = strlen(s), m = strlen(t);
for (int i = 0; i < n; i++) s[i] = dic(s[i]);
for (int i = 0; i < m; i++) t[i] = dic(t[i]);
for (int i = m - 1; i >= 0; i--) {
memcpy(sum[i], sum[i + 1], sizeof(sum[i]));
if (i >= 1) sum[i][t[i - 1]][t[i]]++;
}
for (int i = 0, l = 0, r = 0; i < n && l < m; i++) {
for (; r < m && s[i] != t[r]; r++)
;
if (r < m && s[i] == t[r]) r++;
if (l < r) {
ans += r - l;
if (i >= 1 && s[i] != s[i - 1]) {
ans -= sum[l][s[i]][s[i - 1]] - sum[r][s[i]][s[i - 1]];
}
}
if (l < m && s[i] == t[l]) l++;
}
printf("%I64d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using dd = long double;
namespace {
static bool constexpr dbg = 0;
ll constexpr N = 1.1e6, INF = LONG_LONG_MAX / 4;
ll a, b, k, res[N + 9];
bool pr[N + 9];
static bool _init_pr = []() {
for (ll i = 2; i <= N; ++i) pr[i] = true;
for (ll i = 2; i <= N; ++i)
if (pr[i]) {
for (ll j = i * i; j <= N; j += i) pr[j] = false;
}
return true;
}();
void init() { cin >> a >> b >> k; }
void solve() {
for (ll i = 1, ii_ = (N); i <= ii_; ++i) res[i] = INF;
ll l = a, r = a, cnt = 0;
while (r <= b) {
while (cnt < k && r <= b) {
if (pr[r++]) ++cnt;
}
if (cnt != k) break;
res[l] = r - l;
if (pr[l]) --cnt;
++l;
}
if (res[a] == INF) {
cout << -1;
return;
}
ll re = -1;
for (ll i = a; i <= b; ++i) {
if (res[i] == INF) {
re = max(re, b + 1 - i + 1);
break;
}
re = max(re, res[i]);
}
cout << re;
}
} // namespace
int main() {
if (!dbg) {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
cout << fixed << setprecision(20);
init();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, m;
int a[maxn];
int b[maxn];
int f[2 * maxn];
int op[2 * maxn];
bool v[2 * maxn];
int mod;
int read() {
int x;
scanf("%d", &x);
return x;
}
int dfs(int x, int t) {
v[x] = true;
f[x] = t;
if (!v[op[x]]) {
dfs(op[x], !t);
}
if (!v[x ^ 1]) {
dfs(x ^ 1, !t);
}
return 0;
}
int main() {
int i, j;
n = read();
mod = 2 * n;
for (i = 1; i <= n; i++) {
a[i] = read();
b[i] = read();
a[i]--;
b[i]--;
op[a[i]] = b[i];
op[b[i]] = a[i];
}
for (i = 0; i < 2 * n; i++) {
if (!v[i]) {
dfs(i, 0);
}
}
for (i = 1; i <= n; i++) {
cout << f[a[i]] + 1 << " " << f[b[i]] + 1 << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int trieSize, trieSon[600005][26], trieCnt[600005];
int TrieMerge(int u, int v) {
int now, i;
if (!u || !v) return u | v;
now = ++trieSize;
trieCnt[now] = 1;
for (i = 0; i < 26; ++i) {
trieSon[now][i] = TrieMerge(trieSon[u][i], trieSon[v][i]);
if (trieSon[now][i]) trieCnt[now] += trieCnt[trieSon[now][i]];
}
return now;
}
int n, ret[600005];
void Solve(int now, int dep) {
int uniNow, i;
trieCnt[now] = 1;
for (i = 0; i < 26; ++i) {
if (trieSon[now][i]) Solve(trieSon[now][i], dep + 1);
trieCnt[now] += trieCnt[trieSon[now][i]];
}
trieSize = n;
for (i = 0, uniNow = 0; i < 26; ++i)
uniNow = TrieMerge(uniNow, trieSon[now][i]);
ret[dep] += trieCnt[now] - (uniNow ? trieCnt[uniNow] : 1);
}
int main(int argc, char *argv[]) {
int ans, i, u, v;
char c;
scanf("%d", &n);
for (i = 2; i <= n; ++i)
scanf("%d%d%*c%c", &u, &v, &c), trieSon[u][c - 'a'] = v;
Solve(1, 1);
for (i = 2, ans = 1; i <= n; ++i)
if (ret[i] > ret[ans]) ans = i;
printf("%d %d\n", n - ret[ans], ans);
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.