solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m, k, x, y, block, a[N], f[N], ff[N], b[N], ans[N], g[N], tc, tq, tt,
l = 1, r, t;
struct change {
int p, s, la;
change() {}
change(int _p, int _s, int _la) { p = _p, s = _s, la = _la; }
} c[N];
struct query {
int l, r, t, i;
query() {}
query(int _l, int _r, int _t, int _i) { l = _l, r = _r, t = _t, i = _i; }
} q[N];
bool cmp(query a, query b) {
if (g[a.l] ^ g[b.l]) return g[a.l] < g[b.l];
if (g[a.r] ^ g[b.r]) return g[a.r] < g[b.r];
return a.t < b.t;
}
void del(int x) { f[x]--, ff[f[x] + 1]--, ff[f[x]]++; }
void add(int x) { f[x]++, ff[f[x] - 1]--, ff[f[x]]++; }
int calc() {
for (int i = 1;; i++)
if (!ff[i]) return i;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), b[++tt] = a[i];
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &k, &x, &y);
if (k == 2)
c[++tc] = change(x, y, a[x]), a[x] = y, b[++tt] = y;
else
q[++tq] = query(x, y, tc, tq);
}
sort(b + 1, b + 1 + tt);
tt = unique(b + 1, b + 1 + tt) - b - 1;
for (int i = 1; i <= n; i++) a[i] = lower_bound(b + 1, b + 1 + tt, a[i]) - b;
for (int i = 1; i <= tc; i++)
c[i].s = lower_bound(b + 1, b + 1 + tt, c[i].s) - b,
c[i].la = lower_bound(b + 1, b + 1 + tt, c[i].la) - b;
block = ceil(exp((log(n) + log(tc)) / 3));
for (int i = 1; i <= n; i++) g[i] = (i - 1) / block + 1;
for (int i = tc; i >= 1; i--) a[c[i].p] = c[i].la;
sort(q + 1, q + 1 + tq, cmp);
for (int i = 1; i <= tq; i++) {
while (l < q[i].l) del(a[l++]);
while (l > q[i].l) add(a[--l]);
while (r < q[i].r) add(a[++r]);
while (r > q[i].r) del(a[r--]);
while (t < q[i].t) {
int p = c[++t].p;
if (l <= p && p <= r) del(a[p]);
a[p] = c[t].s;
if (l <= p && p <= r) add(a[p]);
}
while (t > q[i].t) {
int p = c[t].p;
if (l <= p && p <= r) del(a[p]);
a[p] = c[t--].la;
if (l <= p && p <= r) add(a[p]);
}
ans[q[i].i] = calc();
}
for (int i = 1; i <= tq; i++) printf("%d\n", ans[i]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, d;
cin >> n >> d;
long moves = 0;
long prev;
cin >> prev;
for (int i = 2; i <= n; i++) {
long curr;
cin >> curr;
if (curr > prev) {
prev = curr;
continue;
} else {
long req = prev + 1 - curr;
if (req % d == 0) {
prev = prev + 1;
moves += req / d;
} else {
prev = curr + (req / d + 1) * d;
moves += req / d + 1;
}
}
}
cout << moves;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 200005;
inline int read() {
int x = 0, f = 1;
char c = 0;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c && c <= '9') x = 10 * x + c - '0', c = getchar();
return x * f;
}
struct Matrix {
int m[5][5];
inline int *operator[](int id) { return m[id]; }
inline Matrix operator*(Matrix rsh) {
Matrix ret;
memset(ret.m, 0x3f, sizeof(ret.m));
for (register int i = 0; i < 5; i++)
for (register int k = 0; k < 5; k++)
for (register int j = 0; j < 5; j++)
ret[i][j] = min(ret[i][j], m[i][k] + rsh[k][j]);
return ret;
}
} tr[N << 1], mdl[6];
inline void Pushup(int l, int mid, int r) {
tr[(((l) + (r)) | ((l) != (r)))] =
tr[(((mid + 1) + (r)) | ((mid + 1) != (r)))] *
tr[(((l) + (mid)) | ((l) != (mid)))];
}
void Build(int l, int r) {
if (l == r) {
switch (getchar()) {
case '2':
tr[(((l) + (r)) | ((l) != (r)))] = mdl[1];
break;
case '0':
tr[(((l) + (r)) | ((l) != (r)))] = mdl[2];
break;
case '1':
tr[(((l) + (r)) | ((l) != (r)))] = mdl[3];
break;
case '7':
tr[(((l) + (r)) | ((l) != (r)))] = mdl[4];
break;
case '6':
tr[(((l) + (r)) | ((l) != (r)))] = mdl[5];
break;
default:
tr[(((l) + (r)) | ((l) != (r)))] = mdl[0];
break;
}
return;
}
int mid = (l + r) >> 1;
Build(l, mid);
Build(mid + 1, r);
Pushup(l, mid, r);
}
Matrix Query(int l, int r, int L, int R) {
if (L <= l && r <= R) return tr[(((l) + (r)) | ((l) != (r)))];
int mid = (l + r) >> 1;
if (R <= mid) return Query(l, mid, L, R);
if (L > mid) return Query(mid + 1, r, L, R);
return Query(mid + 1, r, L, R) * Query(l, mid, L, R);
}
void Init() {
memset(mdl[0].m, 0x3f, sizeof(mdl[0].m));
for (int i = 0; i < 5; i++) mdl[0][i][i] = 0;
for (int i = 1; i <= 5; i++) mdl[i] = mdl[0];
mdl[1][0][0] = 1, mdl[1][1][0] = 0;
mdl[2][1][1] = 1, mdl[2][2][1] = 0;
mdl[3][2][2] = 1, mdl[3][3][2] = 0;
mdl[4][3][3] = 1, mdl[4][4][3] = 0;
mdl[5][4][4] = 1, mdl[5][3][3] = 1;
}
int n, q;
int x, y;
int main() {
Init();
n = read();
q = read();
Build(1, n);
Matrix tmp;
while (q--) {
x = read(), y = read();
tmp = Query(1, n, x, y);
if (tmp[4][0] > (y - x + 1))
puts("-1");
else
printf("%d\n", tmp[4][0]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct ns {
int a;
int b;
int num;
};
int cmp(const ns &a, const ns &b) { return a.a > b.a; }
int n, num;
ns lis[100101];
int main() {
cin >> n;
num = n / 2 + 1;
for (int i = 1; i <= n; i++) {
cin >> lis[i].a;
lis[i].num = i;
}
for (int i = 1; i <= n; i++) cin >> lis[i].b;
sort(lis + 1, lis + n + 1, cmp);
cout << num << endl << lis[1].num;
for (int i = 1; i <= num - 1; i++) {
if (lis[2 * i].b > lis[2 * i + 1].b)
cout << ' ' << lis[2 * i].num;
else
cout << " " << lis[2 * i + 1].num;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
long long bit[4][maxn][maxn];
int low(int p) { return p & (-p); }
void merg(int u, int x, int y, int n, long long k) {
while (x <= n) {
int p = y;
while (p <= n) {
bit[u][x][p] ^= k;
p = p + low(p);
}
x = x + low(x);
}
}
long long sum(int u, int x, int y) {
long long s = 0;
while (x) {
int p = y;
while (p) {
s ^= bit[u][x][p];
p = p - low(p);
}
x = x - low(x);
}
return s;
}
int get(int x, int y) { return (x % 2) * 2 + y % 2; }
int main() {
int i, j, n, m;
cin >> n >> m;
for (i = 1; i <= m; i++) {
int p;
int x1, y1, x2, y2;
scanf("%d%d%d%d%d", &p, &x1, &y1, &x2, &y2);
if (p == 1) {
long long s = 0;
s = sum(get(x2, y2), x2, y2);
if (x1 != 1 && y1 != 1) {
s ^= sum(get(x1 - 1, y1 - 1), x1 - 1, y1 - 1);
}
if (x1 != 1) {
s ^= sum(get(x1 - 1, y2), x1 - 1, y2);
}
if (y1 != 1) s ^= sum(get(x2, y1 - 1), x2, y1 - 1);
printf("%I64d\n", s);
} else {
long long v;
scanf("%I64d", &v);
int p = get(x1, y1);
merg(p, x1, y1, n, v);
merg(p, x1, y2, n, v);
merg(p, x2, y1, n, v);
merg(p, x2, y2, n, v);
if ((x2 - x1 + 1) % 2 == 1) {
merg(get(x2, y1), x2, y1, n, v);
merg(get(x2 + 1, y1), x2, y1, n, v);
merg(get(x2, y1), x2, y2, n, v);
merg(get(x2 + 1, y1), x2, y2, n, v);
}
if ((y2 - y1 + 1) % 2 == 1) {
merg(get(x1, y2), x1, y2, n, v);
merg(get(x1, y2 + 1), x1, y2, n, v);
merg(get(x1, y2), x2, y2, n, v);
merg(get(x1, y2 + 1), x2, y2, n, v);
}
if (((x2 - x1 + 1) * (y2 - y1 + 1)) % 2 == 1) {
for (j = 0; j < 4; j++) {
merg(j, x2, y2, n, v);
}
}
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k;
cin >> s;
int ans = 0;
for (long long(i) = (0); (i) < (26); (i)++) {
char c = 'a' + i;
int cont = 0, cur = 0;
for (long long(i) = (0); (i) < (s.size()); (i)++) {
if (c == s[i]) {
cur++;
if (cur == k) {
cur = 0;
cont++;
}
} else {
cur = 0;
}
}
ans = max(ans, cont);
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
using namespace std;
using Graph = vector<vector<long long>>;
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
long long g = gcd(a, b);
return a / g * b;
}
bool prime(long long n) {
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return false;
}
return n != 1;
}
bool compare_by_b(pair<long long, long long> a, pair<long long, long long> b) {
if (a.second != b.second) {
return a.second < b.second;
} else {
return a.first < b.first;
}
}
const long long MOD = 1000000007;
const long long INF = 1LL << 50;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < (n); i++) cin >> a[i];
vector<long long> b(n);
for (long long i = 0; i < (n); i++) b[i] = a[i];
vector<bool> ok(n, true);
sort((b).rbegin(), (b).rend());
long long ans = 0;
for (long long i = 0; i < (n); i++) {
ans += b[i] * i + 1;
}
cout << ans << endl;
vector<long long> c(n);
long long now = 0;
for (long long i = 0; i < (n); i++) {
long long cnt = 1 + now;
for (long long j = 0; j < (n); j++) {
if (a[j] == b[i]) {
c[j] = cnt;
a[j] = -1;
now++;
break;
}
}
}
vector<long long> d(n);
long long now2 = 1;
for (long long i = 0; i < (n); i++) {
for (long long j = 0; j < (n); j++) {
if (c[j] == now2) {
d[now2 - 1] = j + 1;
now2++;
break;
}
}
}
for (long long i = 0; i < (n); i++) cout << d[i] << " ";
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, x, b[33][33], ans = 0;
bool c[17] = {}, first = true;
scanf("%d", &n);
x = n / 2 + 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) scanf("%d", &b[i][j]);
for (int i = 0;;) {
if (!c[i]) {
if (first)
first = false;
else {
c[i] = 1;
i = 0;
}
int sum = 0;
for (int j = 0; j < x - 1; ++j) {
if (c[j])
sum -= b[j][x - 1];
else
sum += b[j][x - 1];
if (c[j] ^ c[x - 1])
sum -= b[j + x][x - 1];
else
sum += b[j + x][x - 1];
}
if (c[x - 1])
sum -= b[x - 1][x - 1];
else
sum += b[x - 1][x - 1];
for (int j = 0; j < x - 1; ++j) {
int sumcola = 0, sumcolb = 0;
for (int k = 0; k < x - 1; ++k) {
int q, a;
if (c[k])
q = b[k][j] - b[k][j + x];
else
q = b[k][j] + b[k][j + x];
if (c[k] ^ c[x - 1])
a = b[k + x][j] - b[k + x][j + x];
else
a = b[k + x][j] + b[k + x][j + x];
sumcola += (q + a < -q - a ? -q - a : q + a);
sumcolb += (q - a < a - q ? a - q : q - a);
}
sum += (sumcola + b[x - 1][j] +
(c[x - 1] ? -b[x - 1][j + x] : b[x - 1][j + x]) <
sumcolb - b[x - 1][j] -
(c[x - 1] ? -b[x - 1][j + x] : b[x - 1][j + x])
? sumcolb - b[x - 1][j] -
(c[x - 1] ? -b[x - 1][j + x] : b[x - 1][j + x])
: sumcola + b[x - 1][j] +
(c[x - 1] ? -b[x - 1][j + x] : b[x - 1][j + x]));
}
if (ans < sum) ans = sum;
} else {
c[i] = 0;
++i;
if (i == x) break;
}
}
printf("%d", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int a[maxn], n, ans;
int main() {
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
ans = 0;
bool fir = false, sec = false;
int arb = -1;
int d, pre = -1;
for (int i = 1; i <= n; i++) {
if (a[i] > 0) {
if (!fir)
fir = true;
else if (!sec) {
if ((a[i] - a[pre]) % (i - pre)) {
arb = -1;
ans++;
} else {
d = (a[i] - a[pre]) / (i - pre);
if (arb == -1 || a[i] - 1LL * (i - arb) * d > 0)
sec = true;
else {
ans++;
arb = -1;
}
}
} else {
if (a[i] - a[pre] != 1LL * (i - pre) * d) {
ans++;
sec = false;
arb = -1;
}
}
pre = i;
} else {
if (sec && a[pre] + 1LL * (i - pre) * d <= 0) {
fir = false;
sec = false;
ans++;
arb = i;
} else if (arb == -1)
arb = i;
}
}
printf("%d\n", ++ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> adj;
vector<int> parent, depth, leaves;
long long k;
void dfs(int u) {
int kids = 0;
for (int v : adj[u])
if (parent[v] == -1) {
kids++;
parent[v] = u;
depth[v] = depth[u] + 1;
dfs(v);
}
if (leaves.size() < k && kids == 0) leaves.push_back(u);
}
void out(int u, int v) {
while (u != parent[v]) {
cout << u + 1 << " ";
u = parent[u];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m >> k;
adj.resize(n);
for (int i = 0; i < (int)m; i++) {
int x, y;
cin >> x >> y;
adj[x - 1].push_back(y - 1);
adj[y - 1].push_back(x - 1);
}
depth.resize(n);
parent = vector<int>(n, -1);
parent[0] = -2;
depth[0] = 1;
dfs(0);
for (int i = 0; i < (int)n; i++)
if (depth[i] * k >= n) {
cout << "PATH\n" << (n + k - 1) / k << "\n";
int nd = i;
for (int j = 0; j < (int)(n + k - 1) / k; j++) {
cout << i + 1 << " ";
i = parent[i];
}
cout << "\n";
return 0;
}
cout << "CYCLES\n";
for (int i : leaves) {
int n2 = -1, n3 = -1;
for (int v : adj[i])
if (v != parent[i])
if (n2 == -1)
n2 = v;
else {
n3 = v;
break;
}
if (depth[n2] < depth[n3]) swap(n2, n3);
int d1 = depth[i], d2 = depth[n2], d3 = depth[n3];
if ((1 + d1 - d2) % 3 != 0) {
cout << 1 + d1 - d2 << "\n";
out(i, n2);
} else if ((1 + d1 - d3) % 3 != 0) {
cout << 1 + d1 - d3 << "\n";
out(i, n3);
} else if ((1 + d2 - d3 + 1) % 3 != 0) {
cout << 1 + d2 - d3 + 1 << "\n";
cout << i + 1 << " ";
out(n2, n3);
}
cout << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 1;
int n, m;
string s;
int a[maxn];
int main() {
cin >> n >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u' || s[i] == 'y') {
m++;
if (m == 1) {
cout << s[i];
}
} else {
cout << s[i];
m = 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char str[200005];
char s[3][100005];
int p[200005];
int KMP(char* s1, char* s2) {
int n = strlen(s1);
int m = strlen(s2);
int j = -1;
p[0] = -1;
for (int i = 1; i < m; i++) {
while (j >= 0 && s2[i] != s2[j + 1]) j = p[j];
if (s2[i] == s2[j + 1]) j++;
p[i] = j;
}
j = -1;
for (int i = 0; i < n; i++) {
if (j == m - 1) return 0;
while (j >= 0 && s1[i] != s2[j + 1]) j = p[j];
if (s1[i] == s2[j + 1]) j++;
}
return m - 1 - j;
}
int combine(char* s1, char* s2, char* s3) {
int ret;
ret = KMP(s1, s2);
str[0] = '\0';
strcat(str, s1);
strcat(str, s2 + strlen(s2) - ret);
ret = KMP(str, s3);
return ret + strlen(str);
}
int main() {
int ret, ans = 0x7fffffff;
scanf("%s%s%s", s[0], s[1], s[2]);
ret = combine(s[0], s[1], s[2]);
if (ret < ans) ans = ret;
ret = combine(s[0], s[2], s[1]);
if (ret < ans) ans = ret;
ret = combine(s[1], s[0], s[2]);
if (ret < ans) ans = ret;
ret = combine(s[1], s[2], s[0]);
if (ret < ans) ans = ret;
ret = combine(s[2], s[0], s[1]);
if (ret < ans) ans = ret;
ret = combine(s[2], s[1], s[0]);
if (ret < ans) ans = ret;
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1e6 + 5;
int n;
long long a[N], sum[N], ans[N];
map<long long, int> Last;
int Q;
struct Node {
int l, r, id;
bool operator<(Node ort) const {
if (r != ort.r)
return r < ort.r;
else
return l < ort.l;
}
} que[N];
void read() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
sum[i] = sum[i - 1] ^ a[i];
}
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d %d", &que[i].l, &que[i].r);
que[i].id = i;
}
}
const int maxn = 1000005 * 4;
struct Tree {
int l, r;
long long sum;
};
Tree node[maxn];
void PushUp(int i) { node[i].sum = node[i << 1].sum ^ node[(i << 1) | 1].sum; }
void build(int i, int l, int r) {
node[i].l = l;
node[i].r = r;
if (l == r) {
node[i].sum = 0;
return;
}
int mid = (l + r) / 2;
build(i << 1, l, mid);
build((i << 1) | 1, mid + 1, r);
PushUp(i);
}
long long getsum(int i, int l, int r) {
if (node[i].l == l && node[i].r == r) return node[i].sum;
int mid = (node[i].l + node[i].r) / 2;
if (r <= mid)
return getsum(i << 1, l, r);
else if (l > mid)
return getsum((i << 1) | 1, l, r);
else
return getsum(i << 1, l, mid) ^ getsum((i << 1) | 1, mid + 1, r);
}
void add(int i, int k, long long v) {
if (node[i].l == k && node[i].r == k) {
node[i].sum ^= v;
return;
}
int mid = (node[i].l + node[i].r) / 2;
if (k <= mid)
add(i << 1, k, v);
else
add((i << 1) | 1, k, v);
PushUp(i);
}
void init() {
sort(que + 1, que + 1 + Q);
build(1, 1, n);
}
void solve() {
int p = 1;
int askP = 1;
while (p <= n) {
if (Last[a[p]] != 0) {
add(1, Last[a[p]], a[p]);
add(1, p, a[p]);
} else
add(1, p, a[p]);
Last[a[p]] = p;
while (que[askP].r == p) {
ans[que[askP].id] = getsum(1, que[askP].l, que[askP].r) ^
(sum[que[askP].r] ^ sum[que[askP].l - 1]);
askP++;
}
p++;
}
for (int i = 1; i <= Q; i++) printf("%lld\n", ans[i]);
}
int main() {
read();
init();
solve();
}
| 6 |
#include <bits/stdc++.h>
inline int read() {
char c, _c;
int x;
for (c = _c = getchar(); !isdigit(c); c = getchar()) {
_c = c;
}
for (x = 0; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
return _c == '-' ? -x : x;
}
const int mod = 1e9 + 7, inv2 = (mod + 1) / 2;
struct Point {
long long x, y;
};
Point operator+(const Point &u, const Point &v) {
return (Point){u.x + v.x, u.y + v.y};
}
Point operator-(const Point &u, const Point &v) {
return (Point){u.x - v.x, u.y - v.y};
}
long long operator^(const Point &u, const Point &v) {
return u.x * v.y - u.y * v.x;
}
const int N = 1e6 + 5;
int n, ans;
long long f[N], g[N];
Point p[N], q[N];
int main() {
n = read();
for (int i = 1; i <= n; i++) {
p[i].x = read();
p[i].y = read();
q[i] = q[i - 1] + p[i];
q[i].x %= mod;
q[i].y %= mod;
}
for (int i = 2; i <= n; i++) {
f[i] = f[i - 1] + (p[i - 1] ^ p[i]);
g[i] = (g[i - 1] + f[i]) % mod;
}
f[n + 1] = f[n] + (p[n] ^ p[1]);
for (int i = 3, j = 1; i <= n; i++) {
for (; j < i - 1 &&
std::abs(f[n + 1]) < std::abs((f[i] - f[j]) + (p[i] ^ p[j])) * 2.0L;
j++)
;
ans = (ans + f[i] % mod * (i - j - 1) - (g[i - 2] - g[j - 1]) +
(p[i] ^ (q[i - 2] - q[j - 1]))) %
mod;
ans = (ans + (f[n + 1] - f[i]) % mod * (j - 1) + g[j - 1] -
(p[i] ^ q[j - 1])) %
mod;
}
ans = (ans + mod) * 2ll % mod;
ans = (ans + std::abs(f[n + 1]) % mod * inv2 % mod * n % mod * (n - 3)) % mod;
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
double const EPS = 1e-8, PI = acos(-1);
const int N = 1e9 + 9, M = 1e6 + 1, OO = 1e9 + 1;
const long long MOD = 1e9 + 7;
void INPUT() {
cout << fixed << setprecision(0);
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
}
int n, m, a, b;
int main() {
INPUT();
cin >> n >> m >> a >> b;
int arr1[n], arr2[m];
for (int i = 0; i < n; ++i) {
cin >> arr1[i];
}
for (int i = 0; i < m; ++i) {
cin >> arr2[i];
}
bool can = (arr1[a - 1] < arr2[m - b]);
cout << (can ? "YES\n" : "NO\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n % 2 == 0)
cout << 2 << endl;
else
cout << 1 << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, a, b, k;
cin >> n >> a >> b >> k;
priority_queue<long long, vector<long long>, greater<long long> > q;
long long cnt = 0;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
if (x % (a + b) && x % (a + b) <= a)
cnt++;
else {
long long y = x % (a + b) ? x % (a + b) : a + b;
long long z = (y + a - 1) / a;
q.push(z - 1);
}
}
while (q.size() && k >= q.top()) {
cnt += 1;
k -= q.top();
q.pop();
}
cout << cnt << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int fast_expo(long long int x, long long int p) {
if (p == 0)
return 1;
else if (p % 2 == 0) {
long long int t = fast_expo(x, p / 2) % 998244353;
return (t * t) % 998244353;
} else
return (x * (fast_expo(x, p - 1)) % 998244353) % 998244353;
}
int main() {
long long int n, m;
cin >> n >> m;
long long int p = n / 2 + 1;
long long int neg = 0;
long long int ans = 0;
long long int pos = (n * (n - 1)) / 2;
for (long long int i = 1; i <= n; i++) {
neg += abs(i - p);
}
long long int x, d;
for (int i = 0; i < m; i++) {
cin >> x >> d;
ans += (x * n);
if (d < 0)
ans += neg * d;
else
ans += pos * d;
}
double res = (double)ans / n;
cout << fixed << setprecision(8) << res << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int N, A[100022], Pair[100022];
int Sum[100022];
char S[100022];
inline void Up(int &a, int b) {
if (a < b) a = b;
}
inline char Match(char a) {
if (a == '[') return ']';
if (a == '(') return ')';
if (a == ']') return '[';
if (a == ')') return '(';
assert(0);
return 'F';
}
int main() {
scanf("%s", S + 1);
N = strlen(S + 1);
Sum[0] = 0;
for (int i = 1; i <= N; ++i) {
Sum[i] = Sum[i - 1] + (S[i] == '[');
}
static pair<char, int> Stack[100022];
int Stop = 0;
Pair[0] = 1000000000;
for (int i = 1; i <= N; ++i) {
int &res = Pair[i] = 1000000000;
char c = S[i];
if (c == '(' || c == '[') {
Stack[++Stop] = pair<char, int>(c, i);
res = 1000000000;
continue;
}
assert(c == ')' || c == ']');
if (Stop == 0 || Stack[Stop].first != Match(c)) {
res = 1000000000;
Stop = 0;
continue;
}
int left = res = Stack[Stop].second;
if (left == 1 || Pair[left - 1] == 1000000000)
res = left;
else
res = Pair[left - 1];
--Stop;
}
int ans = 0;
for (int i = 1; i <= N; ++i)
if (Pair[i] != 1000000000) Up(ans, Sum[i] - Sum[Pair[i] - 1]);
printf("%d\n", ans);
if (ans == 0) {
printf("\n");
return 0;
}
for (int i = 1; i <= N; ++i)
if (Pair[i] != 1000000000)
if (Sum[i] - Sum[Pair[i] - 1] == ans) {
for (int itr = Pair[i]; itr <= i; ++itr) putchar(S[itr]);
puts("");
break;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:255000000")
bool firstout = 1;
template <class T>
T &minn(T &a, T b) {
if (b < a) a = b;
return a;
}
template <class T>
T &maxx(T &a, T b) {
if (a < b) a = b;
return a;
}
int &madd(int &a, int b) {
a += b;
if (a >= 1000000009) a -= 1000000009;
return a;
}
int &msub(int &a, int b) {
a -= b;
if (a < 0) a += 1000000009;
return a;
}
int &mmult(int &a, int b) { return a = (long long)a * b % 1000000009; }
int mdiv(long long a, long long b, long long m) {
a = (a % m + m) % m;
b = (b % m + m) % m;
if (a % b == 0) return a / b;
return (a + m * mdiv(-a, m, b)) / b;
}
int n, m;
int A[501234];
int T[501234];
int P[501234];
void fnd(int i, int p) {
if (A[i] >= p) return;
fnd(P[i], p);
A[i] = A[P[i]];
T[i] += T[P[i]];
P[i] = P[P[i]];
}
int main() {
int i, j, k;
char c;
int a, d;
int ts;
for (ts = 1; scanf("%"
"d",
&(n)) > 0;
++ts) {
for (i = (0); i < (n); ++i)
scanf(
"%"
"d",
&(A[i]));
reverse(A, A + n);
for (i = (n); i < (2 * n); ++i) A[i] = A[i - n];
for (i = (0); i < (2 * n); ++i) A[i] += i;
for (i = (0); i < (2 * n); ++i) T[i] = 1;
set<pair<int, int> > s;
s.insert(make_pair(2 * n - 1, A[2 * n - 1]));
for (i = (2 * n - 1) - 1; i >= (0); --i) {
P[i] = (--s.lower_bound(make_pair(A[i], 1012345678)))->first;
for (; s.size() && s.begin()->second <= A[i]; s.erase(s.begin()))
;
s.insert(make_pair(i, A[i]));
}
long long res = 0;
for (i = (0); i < (n); ++i) {
fnd(i, i + n - 1);
res += T[i];
}
printf(
"%"
"I64d",
(res));
printf("\n"), firstout = 1;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
string s;
cin >> t;
set<char> st;
vector<char> v;
while (t--) {
cin >> s;
for (int i = 0; i < s.size(); i++) {
char ch = s.at(i);
st.insert(ch);
}
if (st.size() == 1) {
cout << -1 << endl;
} else {
for (int i = 0; i < s.size(); i++) {
v.push_back(s.at(i));
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
cout << v[i];
}
cout << endl;
v.clear();
}
st.clear();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
int n = s1.length(), m = s2.length();
int ans = 0;
for (int i = 1; i <= min(n, m); i++) {
if (n % i == 0 && m % i == 0) {
set<string> is;
for (int j = 0; j < n; j += i) {
is.insert(s1.substr(j, i));
if (is.size() > 1) break;
}
for (int j = 0; j < m; j += i) {
is.insert(s2.substr(j, i));
if (is.size() > 1) break;
}
if (is.size() == 1) {
ans++;
}
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long llinf = (1LL << 61);
const int inf = (1 << 30);
const int nmax = 1e3 + 50;
const int mod = 1e9 + 7;
using namespace std;
int n, m, i, j, a[nmax][nmax], aa[nmax][nmax], b[nmax][nmax], bb[nmax][nmax],
ca[nmax][nmax], cb[nmax][nmax], mn;
char c[nmax][nmax];
vector<pair<pair<int, int>, int> > ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n >> m;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) cin >> c[i][j];
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++)
if (c[i][j] == '*') a[i][j] = a[i][j - 1] + 1;
for (j = m; j >= 1; j--)
if (c[i][j] == '*') aa[i][j] = aa[i][j + 1] + 1;
}
for (i = 1; i <= m; i++) {
for (j = 1; j <= n; j++)
if (c[j][i] == '*') b[j][i] = b[j - 1][i] + 1;
for (j = n; j >= 1; j--)
if (c[j][i] == '*') bb[j][i] = bb[j + 1][i] + 1;
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (c[i][j] == '*') {
mn = min(min(a[i][j], aa[i][j]), min(b[i][j], bb[i][j]));
if (mn > 1) {
ca[i][j - mn + 1]++;
ca[i][j + mn]--;
cb[i - mn + 1][j]++;
cb[i + mn][j]--;
ans.push_back({{i, j}, mn - 1});
}
}
}
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) ca[i][j] += ca[i][j - 1];
for (i = 1; i <= m; i++)
for (j = 1; j <= n; j++) cb[j][i] += cb[j - 1][i];
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (c[i][j] == '*' && !ca[i][j] && !cb[i][j])
return cout << -1 << endl, 0;
cout << ans.size() << endl;
for (i = 0; i < ans.size(); i++)
cout << ans[i].first.first << " " << ans[i].first.second << " "
<< ans[i].second << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
vector<int> adj[N];
int W[N], degree[N], val[N], root;
void pre_dfs(int i = 1, int p = -1) {
W[i] = 1;
for (auto x : adj[i])
if (x != p) pre_dfs(x, i), W[i] += W[x];
}
int getCentroid(int i = 1, int p = -1) {
for (auto x : adj[i])
if (x != p)
if (2 * W[x] > n) return getCentroid(x, i);
return i;
}
void dfs(int i = root, int p = -1, int depth = 0) {
if (val[depth] == 0)
val[depth] = degree[i];
else if (val[depth] != degree[i])
val[depth] = -1;
for (auto x : adj[i])
if (x != p) dfs(x, i, depth + 1);
}
pair<int, int> getEndOfChain(int i, int p) {
if (degree[i] == 1) return make_pair(1, i);
if (degree[i] != 2) return make_pair(-1, -1);
for (auto x : adj[i])
if (x != p) {
pair<int, int> temp = getEndOfChain(x, i);
if (temp.second == -1) return temp;
return make_pair(temp.first + 1, temp.second);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
degree[u]++;
degree[v]++;
}
pre_dfs();
root = getCentroid();
pair<int, int> mn = {1e6, -1}, mx = {-1, -1};
for (auto x : adj[root]) {
pair<int, int> temp = getEndOfChain(x, root);
if (temp.second != -1) {
mn = min(mn, temp);
mx = max(mx, temp);
}
}
bool ok = true;
dfs(root);
for (int i = 0; i < N; i++)
if (val[i] == -1) ok = false;
if (ok) return cout << root << '\n', 0;
if (mn.second != -1) {
memset(val, 0, sizeof(val));
dfs(mn.second);
ok = true;
for (int i = 0; i < N; i++)
if (val[i] == -1) ok = false;
if (ok) return cout << mn.second << '\n', 0;
}
if (mx.second != -1) {
memset(val, 0, sizeof(val));
dfs(mx.second);
ok = true;
for (int i = 0; i < N; i++)
if (val[i] == -1) ok = false;
if (ok) return cout << mx.second << '\n', 0;
}
cout << "-1\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
unsigned int logceil(int first) {
return 8 * sizeof(int) - __builtin_clz(first);
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
template <unsigned int N>
class Field {
inline unsigned int pow(unsigned int a, unsigned int p) {
unsigned int r = 1, e = a;
while (p) {
if (p & 1) {
r = ((unsigned long long)r * e) % N;
}
e = ((unsigned long long)e * e) % N;
p >>= 1;
}
return r;
}
inline unsigned int inv(unsigned int a) { return pow(a, N - 2); }
public:
inline Field(int first = 0) : v(first) {}
inline Field<N> pow(int p) { return (*this) ^ p; }
inline Field<N> operator^(int p) { return {(int)pow(v, (unsigned int)p)}; }
inline Field<N>& operator+=(const Field<N>& o) {
if ((long long)v + o.v >= N)
v += o.v - N;
else
v += o.v;
return *this;
}
inline Field<N>& operator-=(const Field<N>& o) {
if (v < o.v)
v -= o.v - N;
else
v -= o.v;
return *this;
}
inline Field<N>& operator*=(const Field<N>& o) {
v = (unsigned long long)v * o.v % N;
return *this;
}
inline Field<N>& operator/=(const Field<N>& o) { return *this *= inv(o.v); }
inline Field<N> operator+(const Field<N>& o) const {
Field<N> r{*this};
return r += o;
}
inline Field<N> operator-(const Field<N>& o) const {
Field<N> r{*this};
return r -= o;
}
inline Field<N> operator*(const Field<N>& o) const {
Field<N> r{*this};
return r *= o;
}
inline Field<N> operator/(const Field<N>& o) const {
Field<N> r{*this};
return r /= o;
}
inline Field<N> operator-() {
if (v)
return {(int)(N - v)};
else
return {0};
};
inline Field<N>& operator++() {
++v;
if (v == N) v = 0;
return *this;
}
inline Field<N> operator++(int) {
Field<N> r{*this};
++*this;
return r;
}
inline Field<N>& operator--() {
--v;
if (v == -1) v = N - 1;
return *this;
}
inline Field<N> operator--(int) {
Field<N> r{*this};
--*this;
return r;
}
inline bool operator==(const Field<N>& o) const { return o.v == v; }
inline bool operator!=(const Field<N>& o) const { return o.v != v; }
inline explicit operator unsigned int() const { return v; }
inline static vector<Field<N>> fact(int t) {
vector<Field<N>> F(t + 1, 1);
for (int i = 2; i <= t; ++i) {
F[i] = F[i - 1] * i;
}
return F;
}
inline static vector<Field<N>> invfact(int t) {
vector<Field<N>> F(t + 1, 1);
Field<N> X{1};
for (int i = 2; i <= t; ++i) {
X = X * i;
}
F[t] = 1 / X;
for (int i = t - 1; i >= 2; --i) {
F[i] = F[i + 1] * (i + 1);
}
return F;
}
private:
unsigned int v;
};
template <unsigned int N>
istream& operator>>(std::istream& is, Field<N>& f) {
unsigned int v;
is >> v;
f = v;
return is;
}
template <unsigned int N>
ostream& operator<<(std::ostream& os, const Field<N>& f) {
return os << (unsigned int)f;
}
template <unsigned int N>
Field<N> operator+(int i, const Field<N>& f) {
return Field<N>(i) + f;
}
template <unsigned int N>
Field<N> operator-(int i, const Field<N>& f) {
return Field<N>(i) - f;
}
template <unsigned int N>
Field<N> operator*(int i, const Field<N>& f) {
return Field<N>(i) * f;
}
template <unsigned int N>
Field<N> operator/(int i, const Field<N>& f) {
return Field<N>(i) / f;
}
struct Ring {
static int div(int p, int q, int N) {
long long t = 0, nt = 1, r = N, nr = q;
while (nr) {
long long q = r / nr;
t -= q * nt;
r -= q * nr;
swap(t, nt);
swap(r, nr);
}
t = (t < 0) ? t + N : t;
r = (r < 0) ? r + N : r;
if (gcd(p, N) % r) {
return 0;
}
return (int)(((long long)t * (long long)p / r) % N);
}
};
class intervalcubing {
public:
vector2<Field<95542721>> D;
vector<int> S;
int M;
Field<95542721> sum(int I, int L, int R, int l, int r) {
if (l <= L && r >= R) return D[I][S[I]];
if (l >= R || r <= L) return 0;
if (S[I]) {
rotate(D[I].begin(), D[I].begin() + S[I], D[I].end());
(S[2 * I] += S[I]) %= 48;
(S[2 * I + 1] += S[I]) %= 48;
S[I] = 0;
}
return sum(2 * I, L, (L + R) / 2, l, r) +
sum(2 * I + 1, (L + R) / 2, R, l, r);
}
void update(int I, int L, int R, int l, int r) {
if (l <= L && r >= R) {
(++S[I]) %= 48;
return;
} else if (l >= R || r <= L)
return;
if (S[I]) {
(S[2 * I] += S[I]) %= 48;
(S[2 * I + 1] += S[I]) %= 48;
S[I] = 0;
}
update(2 * I, L, (L + R) / 2, l, r);
update(2 * I + 1, (L + R) / 2, R, l, r);
for (int i = 0; i < 48; ++i) {
D[I][i] =
D[2 * I][(i + S[2 * I]) % 48] + D[2 * I + 1][(i + S[2 * I + 1]) % 48];
}
}
void solve(istream& cin, ostream& cout) {
int N;
cin >> N;
vector<int> A(N);
cin >> A;
M = 1 << logceil(N);
D = vector2<Field<95542721>>(2 * M, 48, 0);
S = vector<int>(2 * M, 0);
for (int i = 0; i < N; ++i) {
D[i + M][0] = A[i] % 95542721;
for (int j = 1; j < 48; ++j)
D[i + M][j] = D[i + M][j - 1] * D[i + M][j - 1] * D[i + M][j - 1];
}
for (int i = M - 1; i > 0; --i) {
for (int j = 0; j < 48; ++j) {
D[i][j] = D[2 * i][j] + D[2 * i + 1][j];
}
}
int Q;
cin >> Q;
for (int q = 0; q < Q; ++q) {
int t, l, r;
cin >> t >> l >> r;
--l;
if (t == 1) {
cout << sum(1, 0, M, l, r) << '\n';
} else {
update(1, 0, M, l, r);
}
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
intervalcubing solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int ddx[] = {1, 0};
int ddy[] = {1, 1};
int n;
vector<int> vec;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
vec.push_back(a);
}
vector<pair<int, int> > aux;
int maxi = 0;
set<int> divi;
for (int i = 0; i < int(vec.size()); i++) {
aux.push_back({(vec[i]) / n, (vec[i]) % n});
divi.insert(vec[i] / n);
}
for (auto a : divi) {
for (int j = 0; j < int(aux.size()); j++) {
int d = aux[j].first, r = aux[j].second;
if (d < a) {
cout << j + 1 << "\n";
return 0;
} else if (d == a) {
if (j >= r) {
cout << j + 1 << "\n";
return 0;
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = 3.1415926535897932384626433832795;
unsigned long long mod = 1000 * 1000 * 1000 + 7;
vector<int> v(20000001, 1);
int main() {
int a, n;
cin >> a >> n;
for (int i = 1; i * i < a + n; i++) {
int sq = i * i;
for (int j = sq; j < a + n; j += sq) v[j] = sq;
}
long long res = 0;
for (int i = a; i < a + n; i++) res += i / v[i];
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, m, k;
cin >> n >> m >> k;
int a[105];
for (i = 0; i < n; i++) {
cin >> a[i];
}
int sum = 0;
for (i = 0; i < n - m; i++) {
sum += a[i];
}
for (i = n - m; i < n; i++) {
sum += k;
}
cout << sum << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
long long solve(long long m, long long d, long long w) {
auto gcd = [&](long long a, long long b) {
while (a != 0) {
b %= a;
swap(a, b);
}
return b;
};
long long res = 0;
auto n = min(m, d);
long long g = 0;
if (d % w == 0) {
g = w;
} else {
auto gg = gcd(d - 1, w);
g = w / gg;
}
if (g == -1) {
res = n * (n - 1);
} else {
long long p = n / g;
res = n * p - p * (p + 1) / 2 * g;
}
return res;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
Solution sol;
int t;
cin >> t;
while (t-- > 0) {
int m, d, w;
cin >> m >> d >> w;
cout << sol.solve(m, d, w) << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int a[111111], mn = 999, mx, x, y, sum, n, m, i, j, c, z, l, r;
string s;
int main() {
cin >> x >> y >> n >> m;
c = max(3 * x / 10, x - x / 250 * n);
z = max(3 * y / 10, y - y / 250 * m);
if (c > z) {
cout << "Misha";
} else if (z > c) {
cout << "Vasya";
} else {
cout << "Tie";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long inf = 2147383647;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
inline long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
long long ext_gcd(long long A, long long B, long long* X, long long* Y) {
long long x2, y2, x1, y1, x, y, r2, r1, q, r;
x2 = 1;
y2 = 0;
x1 = 0;
y1 = 1;
for (r2 = A, r1 = B; r1 != 0;
r2 = r1, r1 = r, x2 = x1, y2 = y1, x1 = x, y1 = y) {
q = r2 / r1;
r = r2 % r1;
x = x2 - (q * x1);
y = y2 - (q * y1);
}
*X = x2;
*Y = y2;
return r2;
}
inline long long modInv(long long a, long long m) {
long long x, y;
ext_gcd(a, m, &x, &y);
if (x < 0) x += m;
return x;
}
inline long long power(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
inline long long bigmod(long long a, long long p, long long m) {
long long res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
using namespace std;
template <typename T>
ostream& operator<<(ostream& out, vector<T> v) {
out << "[ ";
for (int i = 0; i < (((int)(v).size())); i++) {
if (i) out << ", ";
out << v[i];
}
out << " ]";
return out;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> p) {
out << "( " << p.first << ", " << p.second << ")";
return out;
}
template <typename T>
ostream& operator,(ostream& out, T x) {
out << x << " ";
return out;
}
int matA[57][57], matB[57][57];
int N, M;
bool isIncreasing(int mat[57][57]) {
for (int i = 0; i < (N); i++) {
for (int j = 0; j < (M); j++) {
if (i > 0 && mat[i - 1][j] >= mat[i][j]) {
return false;
}
if (j > 0 && mat[i][j - 1] >= mat[i][j]) {
return false;
}
}
}
return true;
}
bool solve() {
for (int i = 0; i < (N); i++) {
for (int j = 0; j < (M); j++) {
if (matA[i][j] > matB[i][j]) {
swap(matA[i][j], matB[i][j]);
}
}
}
return isIncreasing(matA) && isIncreasing(matB);
}
int main() {
scanf("%d %d", &N, &M);
for (int i = 0; i < (N); i++) {
for (int j = 0; j < (M); j++) {
scanf("%d", &matA[i][j]);
}
}
for (int i = 0; i < (N); i++) {
for (int j = 0; j < (M); j++) {
scanf("%d", &matB[i][j]);
}
}
if (solve()) {
printf("Possible\n");
} else {
printf("Impossible\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long ans[110];
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long f[110];
for (long long i = 0; i < m; i++) cin >> f[i];
long long mm[110];
for (long long i = 0; i < k; i++) cin >> mm[i];
long long mn = 999999999999;
for (long long i = 0; i < m; i++) {
for (long long j = 0; j < k; j++) {
if (mm[j] % f[i] == 0) ans[i + 1]++;
}
mn = min(mn, ans[i + 1]);
}
long long xx = 0;
for (long long i = 1; i <= m; i++) {
if (ans[i] == mn) xx++;
}
cout << xx << '\n';
for (long long i = 1; i <= m; i++) {
if (ans[i] == mn) cout << i << ' ';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline bool iseq(double x, double y) {
if (fabs(x - y) < 1e-8) return true;
return false;
}
template <typename T>
inline T hpt(T x1, T y1, T x2, T y2) {
return hypot(x1 - x2, y1 - y2);
}
template <typename T>
inline T gcd(T a, T b) {
if (!b)
return a;
else
return gcd(b, a % b);
}
template <typename T>
inline void extended_euclid(T a, T b, T &x, T &y) {
if (a % b == 0)
x = 0, y = 1;
else {
extended_euclid(b, a % b, x, y);
T temp = x;
x = y;
y = -y * (a / b) + temp;
}
}
template <typename T>
inline T bigmod(T b, T p, T m) {
if (!p)
return 1;
else if (!(p % 2)) {
T x = bigmod(b, p / 2, m);
return (x * x) % m;
} else
return ((b % m) * bigmod(b, p - 1, m)) % m;
}
int prime[5 / 32 + 1];
void setbit(int i) {
int p = i >> 5, q = i & 31;
prime[p] |= (1 << q);
}
bool checkbit(int i) {
int p = i >> 5, q = i & 31;
return prime[p] & (1 << q) ? true : false;
}
void buildprime(int n) {
int i, j, k = sqrt(double(n));
prime[0] = 3;
for (i = 4; i < n; i += 2) setbit(i);
for (i = 3; i <= k; i += 2) {
if (!checkbit(i)) {
int ii = i + i;
for (j = i * i; j < n; j += ii) setbit(j);
}
}
}
int sum, r, n, N, R, C, m;
int power[105], player[25], dp[20][1 << 20];
bool nisi[20][1 << 20];
string cmd[25];
int doit(int p, int bit) {
if (m <= p) return 0;
int &ret = dp[p][bit];
if (nisi[p][bit]) return ret;
nisi[p][bit] = true;
if (player[p] == 1)
ret = -(1 << 30);
else
ret = (1 << 30);
for (int i = 0; i < m; ++i)
if ((bit & (1 << i)) == 0) {
int extra = 0;
if (cmd[p] == "p") extra = power[i];
int tem = doit(p + 1, bit | (1 << i));
if (player[p] == 1)
ret = max(ret, tem + extra);
else
ret = min(ret, tem - extra);
}
return ret;
}
int main() {
int i, j, k;
while (scanf("%d", &n) == 1) {
for ((i) = (0); (i) < (n); (i)++) scanf("%d", &power[i]);
sort(power, power + n);
reverse(power, power + n);
scanf("%d", &m);
for ((i) = (0); (i) < (m); (i)++) cin >> cmd[i] >> player[i];
memset(nisi, 0, sizeof(nisi));
int ans = doit(0, 0);
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans[222];
int main() {
int n;
scanf("%d", &n);
int lb = 1, rb = n + 1;
for (int mid = (lb + rb) / 2; lb < rb - 1; mid = (lb + rb) / 2)
if (mid * (mid - 1) / 2 <= n)
lb = mid;
else
rb = mid;
printf("%d\n", lb);
for (int i = 1; i <= lb; i++)
for (int j = i + 1; j <= lb; j++) {
static int idx = 0;
ans[i].push_back(++idx);
ans[j].push_back(idx);
}
for (int i = 1; i <= lb; i++) {
for (int j = 0; j < (int)ans[i].size(); j++) printf("%d ", ans[i][j]);
printf("\n");
}
}
| 4 |
#include <bits/stdc++.h>
const int N = 200010;
const int MOD = 1e9 + 7;
using namespace std;
struct nn {
int cost, qui;
} a[N];
int ta[N], tc[N];
int n, m, tot = 0, RT = 0;
int ans[N], val[N], son[N][2], rnd[N];
int APL(int num) {
int x = ++tot;
son[x][0] = son[x][1] = 0;
val[x] = num;
rnd[x] = rand();
return x;
}
int cmp(nn A, nn B) {
if (A.qui == B.qui) return A.cost < B.cost;
return A.qui > B.qui;
}
void PUSHD(int x) {
if (!x) return;
ans[x] += ta[x];
val[x] += tc[x];
if (son[x][0]) ta[son[x][0]] += ta[x], tc[son[x][0]] += tc[x];
if (son[x][1]) ta[son[x][1]] += ta[x], tc[son[x][1]] += tc[x];
ta[x] = tc[x] = 0;
}
void PUSH(int x) {
if (!x) return;
PUSHD(x);
if (son[x][0]) PUSH(son[x][0]);
if (son[x][1]) PUSH(son[x][1]);
}
void SPLT(int x, int num, int &L, int &R) {
if (!x) {
L = R = 0;
return;
}
PUSHD(x);
if (val[x] <= num)
L = x, SPLT(son[x][1], num, son[L][1], R);
else
R = x, SPLT(son[x][0], num, L, son[x][0]);
PUSHD(L);
PUSHD(R);
}
int MERGE(int L, int R) {
PUSHD(L);
PUSHD(R);
if (L * R == 0) return L + R;
if (rnd[L] < rnd[R]) {
son[L][1] = MERGE(son[L][1], R);
return L;
} else {
son[R][0] = MERGE(L, son[R][0]);
return R;
}
}
int GETMX(int x) {
int now = x;
PUSHD(now);
while (son[now][1]) now = son[now][1], PUSHD(now);
return val[now];
}
void ADD(int &rt, int now) {
if (!now) return;
PUSHD(now);
if (son[now][0]) ADD(rt, son[now][0]);
if (son[now][1]) ADD(rt, son[now][1]);
son[now][0] = son[now][1] = 0;
int y, z;
SPLT(rt, val[now], y, z);
rt = MERGE(MERGE(y, now), z);
}
void READ() {
int x, y, num;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].cost, &a[i].qui);
sort(a + 1, a + n + 1, cmp);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &num);
SPLT(RT, num, x, y);
RT = MERGE(MERGE(x, APL(num)), y);
}
}
void SOLVE() {
int x, y, z;
for (int i = 1; i <= n; i++) {
SPLT(RT, a[i].cost - 1, x, z);
if (!z) continue;
ta[z]++;
tc[z] -= a[i].cost;
SPLT(z, GETMX(x) - 1, y, z);
ADD(x, y);
RT = MERGE(x, z);
}
PUSH(RT);
for (int i = 1; i <= m; i++) printf("%d ", ans[i]);
}
int main() {
srand(time(NULL));
READ();
SOLVE();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long ar[5][5], jawab;
char s[5];
void kerja(int depth) {
if (depth == 4)
jawab = min(jawab, ar[depth][1]);
else {
vector<long long> v;
long long bla = 0LL;
for (int i = 1; i <= (4 - depth); i++) {
for (int j = i + 1; j <= 4 - depth + 1; j++) {
v.clear();
if (s[depth] == '+')
bla = ar[depth][i] + ar[depth][j];
else
bla = ar[depth][i] * ar[depth][j];
for (int k = 1; k < i; k++) v.push_back(ar[depth][k]);
v.push_back(bla);
for (int k = i + 1; k <= 4 - depth + 1; k++) {
if (k == j) continue;
v.push_back(ar[depth][k]);
}
for (int k = 0; k < v.size(); k++) ar[depth + 1][k + 1] = v[k];
kerja(depth + 1);
}
}
}
}
int main() {
scanf("%I64d %I64d %I64d %I64d\n", &ar[1][1], &ar[1][2], &ar[1][3],
&ar[1][4]);
scanf("%c %c %c", &s[1], &s[2], &s[3]);
jawab = 1000000000002LL;
kerja(1);
printf("%I64d\n", jawab);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct gadget {
int a;
int b;
double t;
};
bool cmp(gadget g1, gadget g2) { return g1.t < g2.t; }
int main() {
cin.sync_with_stdio(0);
cin.tie(NULL);
cout << fixed << setprecision(25);
int n, p;
cin >> n >> p;
vector<gadget> gl(n);
for (int i = 0; i < n; i++) {
gadget g;
cin >> g.a >> g.b;
g.t = double(g.b) / g.a;
gl[i] = g;
}
sort(gl.begin(), gl.end(), cmp);
long long sa = 0, sb = 0;
for (int i = 0; i < n - 1; i++) {
sa += gl[i].a;
sb += gl[i].b;
if (0) {
continue;
}
double t = double(sb) / (sa - p);
if (t > 0 && t <= gl[i + 1].t) {
cout << t << endl;
return 0;
}
}
sa += gl[n - 1].a;
sb += gl[n - 1].b;
if (sa <= p)
cout << -1;
else
cout << double(sb) / (sa - p);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
using namespace std;
template <typename T = int>
T yh() {
T ret = 0;
bool f = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == EOF) return -1;
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) ret = (ret << 3) + (ret << 1) + (c ^ 48), c = getchar();
return f ? -ret : ret;
}
template <typename T>
void yh(T& ret) {
ret = 0;
bool f = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == EOF) return ret = -1, void();
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) ret = (ret << 3) + (ret << 1) + (c ^ 48), c = getchar();
ret = f ? -ret : ret;
}
const int maxn = 2005, mod = 1e9 + 7;
map<int, int> cycles;
vector<int> a;
long long dp[2005][4010][2];
bool vis[maxn];
vector<int> adj[maxn];
int n, m;
int stoploopsize = 0;
long long solve(int pos, int diff, bool takeAll) {
if (pos == (int)a.size()) {
if (takeAll)
return diff == max((int)0, stoploopsize - 1);
else
return diff < stoploopsize - 1;
}
long long& ans = dp[pos][diff][takeAll];
if (~ans) return ans;
ans = 0;
ans += solve(pos + 1, diff + a[pos], takeAll);
ans += solve(pos + 1, abs(diff - a[pos]), takeAll);
ans %= mod;
if (takeAll == 0) ans += solve(pos + 1, diff, takeAll);
return ans % mod;
}
long long calc(int siz, bool takeAll) {
memset(dp, -1, sizeof(dp));
a.clear();
if (siz > 0) cycles[siz]--;
for (auto p : cycles) {
for (register int __ = (1); __ <= (p.second); __++) a.push_back(p.first);
}
if (siz > 0) cycles[siz]++;
stoploopsize = siz;
long long ans = 0;
if (takeAll == 0) ans += solve(0, 0, 0);
ans += solve(0, 0, 1);
return ans % mod;
}
signed main() {
n = yh(), m = yh();
for (register int i = (1); i <= (m); i++) {
int x = yh(), y = yh();
adj[x].push_back(y);
adj[y].push_back(x);
}
for (auto y : adj[1])
if (!vis[y]) {
int yn = y, yo = 1;
int sz = 0;
if (adj[yn][0] == adj[yn][1]) {
vis[yn] = 1;
cycles[2]++;
continue;
}
while (yn != 1) {
vis[yn] = 1;
sz++;
for (auto ynn : adj[yn]) {
if (ynn != yo) {
yo = yn, yn = ynn;
break;
}
}
}
cycles[sz + 1]++;
}
long long ans = 0;
for (auto p : cycles) {
ans = (ans + 2ll * p.second * calc(p.first, 0) % mod) % mod;
}
ans += calc(0, 1) % mod;
cout << ans % mod;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3fLL;
const long long N = 3e5 + 10;
const long long MOD = 1e9 + 7;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n / 2; i++) {
for (long long j = 0; j < m; j++) {
cout << i + 1 << ' ' << j + 1 << '\n';
cout << n - i - 1 + 1 << ' ' << m - j - 1 + 1 << '\n';
}
}
if (n & 1) {
long long mid = n / 2;
for (long long i = 0; i < m / 2; i++) {
cout << mid + 1 << ' ' << i + 1 << '\n';
cout << mid + 1 << ' ' << m - i - 1 + 1 << '\n';
}
if (m & 1) {
cout << mid + 1 << ' ' << m / 2 + 1 << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
void go(int &u, int t) {
for (int i = t; i > 0; --i) {
if (u < m) {
u += i;
} else {
u -= i;
}
u += (u < 0) ? n : 0;
u -= (u >= n) ? n : 0;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int s;
long long t;
cin >> n >> m >> s >> t;
go(--s, t % n);
t /= n;
vector<int> visited(n, -1);
vector<int> cycle = {s};
visited[s] = 0;
for (int i = 1; i <= t; ++i) {
go(s, n);
if (visited[s] != -1) {
t -= i;
t %= i - visited[s];
cout << cycle[visited[s] + t] + 1 << "\n";
exit(0);
}
visited[s] = i;
cycle.push_back(s);
}
cout << s + 1 << "\n";
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<int, vector<string> > flag;
map<string, int> mp;
int n;
cin >> n;
while (n--) {
string name;
int score;
cin >> name >> score;
mp[name] = mp[name] + score;
if (mp[name] >= 0) {
for (int i = 0; i <= mp[name]; i++) {
flag[i].push_back(name);
}
}
}
int maax = -1;
map<string, int>::iterator i;
for (i = mp.begin(); i != mp.end(); ++i) {
if (i->second > maax) {
maax = i->second;
}
}
vector<string> winner;
for (i = mp.begin(); i != mp.end(); ++i) {
if (i->second == maax) {
winner.push_back(i->first);
}
}
for (auto i = flag[maax].begin(); i != flag[maax].end(); i++) {
if (mp[*i] == maax) {
cout << *i << endl;
break;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &item) {
out << '(' << item.first << ", " << item.second << ')';
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
for (const auto &item : v) out << item << ' ';
return out;
}
int t, n, m, k;
int V[3505], A[3505];
int main() {
cin >> t;
while (t--) {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> V[i];
}
k = min(k, m - 1);
int rem = n - m + 1;
for (int i = rem; i <= n; i++) {
A[i] = max(V[i - rem + 1], V[i]);
}
int a = 1, b = n - k;
int out = m - k - 1;
multiset<int> S;
for (int i = b; i >= b - out; i--) {
S.insert(A[i]);
}
int ans = -1e9;
for (; b <= n; a++, b++) {
ans = max(ans, *(S.begin()));
S.erase(S.find(A[b - out]));
S.insert(A[b + 1]);
}
for (int i = rem; i <= n; i++) A[i] = 0;
for (int i = 1; i <= n; i++) V[i] = 0;
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int arr[n];
for (long long int i = 0; i <= n - 1; i++) {
cin >> arr[i];
}
long long int g = 0;
for (long long int i = 0; i <= n - 2; i++) {
if (arr[i] < arr[i + 1]) {
g = g + ((arr[i + 1] - arr[i]) * (n - arr[i + 1] + 1));
} else {
g = g + (arr[i + 1] * (arr[i] - arr[i + 1]));
}
}
g = g + (arr[0] * (n - arr[0] + 1));
cout << g << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[105];
int c[105];
int b[105];
int dp[200015];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
b[i] *= k;
c[i] = a[i] - b[i];
}
dp[100000] = 1;
for (int i = 0; i < n; i++) {
if (c[i] < 0) {
for (int j = 0; j < 200005; j++)
if (dp[j - c[i]]) dp[j] = max(dp[j], dp[j - c[i]] + a[i]);
} else {
for (int j = 200005; j >= 0; j--)
if (dp[j - c[i]]) dp[j] = max(dp[j], dp[j - c[i]] + a[i]);
}
}
if (dp[100000] == 1)
printf("-1\n");
else
printf("%d\n", dp[100000] - 1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[100009];
int main() {
int l, i, c, m, n;
cin >> s;
l = strlen(s);
for (i = 0, c = 0; i < l; i++) {
if (s[i] == 'a') c++;
}
if (c == 0) {
for (i = 0; i < l; i++) s[i] = s[i] - 1;
} else {
for (i = 0, m = 0, n = 0; i < l; i++) {
if (s[i] != 'a') {
m = 1;
s[i] = s[i] - 1;
n++;
} else if (m == 1 && s[i] == 'a')
break;
}
}
if (n == 0) s[l - 1] = 'z';
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<long long, long long>;
ostream& operator<<(ostream& os, const pii& seg) {
return os << "[" << seg.first << ", " << seg.second << "]";
}
istream& operator>>(istream& is, pii& p) {
is >> p.first >> p.second;
return is;
}
int main() {
ios_base::sync_with_stdio(0);
auto& in = cin;
auto& out = cout;
int n;
in >> n;
vector<string> promo(n);
for (auto& p : promo) in >> p;
int min_res = 6;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
int d = 0;
for (int k = 0; k < 6; ++k) d += promo[i][k] != promo[j][k];
min_res = min(min_res, (d - 1) >> 1);
}
}
out << min_res << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
int main() {
int k;
cin >> k;
long long a;
while (k--) {
cin >> a;
long long g = gcd(a + 1, a * 4);
long long l = (a + 1) * a * 4 / g;
cout << l / (a + 1) + 1 << ' ';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int powr(long long int a, long long int n) {
if (n == 0) return 1LL;
if (n == 1) return a;
if (n % 2 == 1)
return (a * powr((a * a) % 1000000009, n / 2)) % 1000000009;
else
return powr((a * a) % 1000000009, n / 2);
}
char s[100005];
int main() {
long long int n, a, b, k, tmp;
scanf("%lld %lld %lld", &n, &a, &b);
scanf("%lld", &k);
scanf("%s", s);
long long int ans = 0, m = 1;
for (long long int i = 0; i < k; i = i + 1) {
if (s[i] == '+')
ans = (ans + ((powr(a, n - i) * m) % 1000000009)) % 1000000009;
else
ans = (ans - ((powr(a, n - i) * m) % 1000000009)) % 1000000009;
m = (m * b) % 1000000009;
}
tmp = (b * powr(a, 1000000009 - 2)) % 1000000009;
tmp = powr(tmp, k);
if (tmp < 0) tmp += 1000000009;
if (tmp == 1) {
ans = (ans * ((n + 1) / k)) % 1000000009;
if (ans < 0) ans += 1000000009;
printf("%lld\n", ans);
return 0;
}
ans = (ans * (powr(tmp, (n + 1) / k) - 1)) % 1000000009;
ans = (ans * powr(tmp - 1, 1000000009 - 2)) % 1000000009;
if (ans < 0) ans += 1000000009;
printf("%lld\n", ans);
return 0;
ans = (ans * powr(a, k)) % 1000000009;
ans = (ans * ((powr(b, n + 1) - powr(a, n + 1)) % 1000000009)) % 1000000009;
tmp =
(powr(a, n + 1) * ((powr(b, k) - powr(a, k) + 1000000009) % 1000000009)) %
1000000009;
if (tmp < 0) tmp += 1000000009;
tmp = powr(tmp, 1000000009 - 2);
ans = (ans * tmp) % 1000000009;
if (ans < 0) ans += 1000000009;
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int r1, r2, c1, c2, d1, d2;
int main() {
scanf("%d%d%d%d%d%d", &r1, &r2, &c1, &c2, &d1, &d2);
int tag = 0;
for (int i = 1; i <= 9; ++i) {
for (int j = 1; j <= 9; ++j) {
for (int k = 1; k <= 9; ++k) {
for (int l = 1; l <= 9; ++l) {
if (i == j || i == k) continue;
if (i == l || j == k) continue;
if (j == l || k == l) continue;
if (i + j == r1 && i + k == c1 && k + l == r2 && j + l == c2 &&
i + l == d1 && j + k == d2) {
printf("%d %d\n", i, j);
printf("%d %d\n", k, l);
tag = 1;
break;
}
}
if (tag) break;
}
if (tag) break;
}
if (tag) break;
}
if (!tag) printf("-1\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const deque<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const deque<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::iterator find(vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename C, typename T, typename OP>
vector<T> prefixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = 0; i < (int((v).size())); i++) r[i + 1] = op(r[i], v[i]);
return r;
}
template <typename C, typename T, typename OP>
vector<T> suffixes(const C& v, T id, OP op) {
vector<T> r(int((v).size()) + 1, id);
for (int i = (int((v).size())) - 1; i >= 0; i--) r[i] = op(v[i], r[i + 1]);
return r;
}
} // namespace __algorithm
using namespace __algorithm;
struct monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) monostate& ms) {
return os;
}
} ms;
template <typename W = monostate>
struct wedge {
int u, v, i;
W w;
wedge<W>(int _u = -1, int _v = -1, int _i = -1) : u(_u), v(_v), i(_i) {}
int operator[](int loc) const { return u ^ v ^ loc; }
friend void re(wedge& e) {
re(e.u, e.v, e.w);
--e.u, --e.v;
}
friend void pr(const wedge& e) { pr(e.u, "<-", e.w, "->", e.v); }
};
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
void solve() {
int N, M;
re(N, M);
vvi a(M, vi(N));
for (int i = 0; i < (N); i++)
for (int j = 0; j < (M); j++) re(a[j][i]);
ckmin(M, N);
nth_element(a.begin(), a.begin() + M, a.end(), [](vi& a, vi& b) {
return *max_element((a).begin(), (a).end()) >
*max_element((b).begin(), (b).end());
});
a.resize(M);
vb lead(1 << N, true);
for (int m = 0; m < (int((lead).size())); m++) {
int t = m;
for (int r = (1); r < (N); r++) {
t = (t >> 1) + ((t & 1) << (N - 1));
if (t > m) lead[m] = false;
}
}
vi leads;
for (int i = 0; i < (int((lead).size())); i++)
if (lead[i]) leads.push_back(i);
vi dp(1 << N);
for (auto& col : a) {
for (int m = 0; m < (int((dp).size())); m++)
for (int i = 0; i < (N); i++)
if (!(m & (1 << i))) ckmax(dp[m ^ (1 << i)], dp[m] + col[i]);
for (auto& m : leads) {
int t = m;
for (int r = (1); r < (N); r++) {
t = (t >> 1) + ((t & 1) << (N - 1));
ckmax(dp[m], dp[t]);
}
t = m;
for (int r = (1); r < (N); r++) {
t = (t >> 1) + ((t & 1) << (N - 1));
ckmax(dp[t], dp[m]);
}
}
}
ps(*max_element((dp).begin(), (dp).end()));
}
int main() {
setIO();
int T;
re(T);
for (int t = 0; t < (T); t++) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "{" << p.first << "," << p.second << "}";
return os;
}
const int N = 3e5 + 5;
const int oo = 1e9 + 7;
int tot[2];
int ache[2][2];
set<int> st[2];
long long sum[2];
map<int, int> type;
inline void add_single(int i, int d, int typ) {
sum[i] += d;
ache[i][typ]++;
st[i].insert(d);
}
inline void rem_single(int i, int d, int typ) {
sum[i] -= d;
ache[i][typ]--;
st[i].erase(d);
}
inline void swap_(int l, int r) {
int lt = type[l];
int rt = type[r];
rem_single(0, l, lt);
rem_single(1, r, rt);
add_single(0, r, rt);
add_single(1, l, lt);
}
inline void equalize() {
while (tot[1] > st[1].size()) {
assert(!st[0].empty());
int l = *st[0].rbegin();
int lt = type[l];
rem_single(0, l, lt);
add_single(1, l, lt);
}
while (tot[1] < st[1].size()) {
assert(!st[1].empty());
int r = *st[1].begin();
int rt = type[r];
rem_single(1, r, rt);
add_single(0, r, rt);
}
int l, r;
while (!st[0].empty() and !st[1].empty() and
(l = *st[0].rbegin()) > (r = *st[1].begin())) {
swap_(l, r);
}
assert(tot[1] == st[1].size());
}
inline void add(int d, int typ) {
tot[typ]++;
type[d] = typ;
ache[0][typ]++;
st[0].insert(d);
sum[0] += d;
equalize();
}
inline void rem(int d, int typ) {
tot[typ]--;
type.erase(d);
for (int i = 0; i < 2; i++)
if (st[i].find(d) != st[i].end()) {
st[i].erase(d);
ache[i][typ]--;
sum[i] -= d;
}
equalize();
}
void pr() {
cerr << "line " << 90 << " : "
<< "tot[0]"
<< " --> " << (tot[0]) << endl;
cerr << "line " << 91 << " : "
<< "tot[1]"
<< " --> " << (tot[1]) << endl;
for (int i = 0; i < 2; i++) {
cerr << "line " << 93 << " : "
<< "i"
<< " --> " << (i) << endl;
cerr << "line " << 94 << " : "
<< "sum[i]"
<< " --> " << (sum[i]) << endl;
cerr << "line " << 95 << " : "
<< "ache[i][0]"
<< " --> " << (ache[i][0]) << endl;
cerr << "line " << 96 << " : "
<< "ache[i][1]"
<< " --> " << (ache[i][1]) << endl;
cerr << "line " << 97 << " : "
<< "&st[i]"
<< " --> " << (&st[i]) << endl;
for (int j : st[i]) cout << j << " ";
cout << endl;
cout << endl;
}
cout << endl;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
while (n--) {
int tp, d;
cin >> tp >> d;
if (d > 0) {
add(d, tp);
} else
rem(-d, tp);
long long ans = sum[0] + sum[1] * 2;
if (tot[1] == ache[1][1]) {
if (tot[1]) {
ans -= *st[1].begin();
if (!st[0].empty()) ans += *st[0].rbegin();
}
}
cout << ans << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int dx[5] = {-1, 0, 1, 0};
int dy[5] = {0, -1, 0, 1};
int dp[1001][1001][41];
bool colour[45];
vector<pair<int, int>> v1[45];
queue<pair<int, int>> q1;
int n, m, K;
bool check(int r, int c) {
if (r <= 0 || r > n || c <= 0 || c > m) {
return false;
}
return true;
}
void bfs(int col) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (dp[i][j][0] == col) {
q1.push(make_pair(i, j));
}
}
}
for (int i = 1; i <= K; i++) {
colour[i] = false;
}
while (!q1.empty()) {
auto hold = q1.front();
q1.pop();
int x = hold.first;
int y = hold.second;
if (!colour[dp[x][y][0]]) {
colour[dp[x][y][0]] = true;
for (auto i : v1[dp[x][y][0]]) {
if (dp[i.first][i.second][col] > dp[x][y][col] + 1) {
dp[i.first][i.second][col] = dp[x][y][col] + 1;
q1.push(make_pair(i.first, i.second));
}
}
}
for (int i = 0; i < 4; i++) {
int nextx = x + dx[i];
int nexty = y + dy[i];
if (check(nextx, nexty) && dp[nextx][nexty][col] > dp[x][y][col] + 1) {
dp[nextx][nexty][col] = dp[x][y][col] + 1;
q1.push(make_pair(nextx, nexty));
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> K;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = 1; k <= K; k++) {
dp[i][j][k] = 1e9;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> dp[i][j][0];
v1[dp[i][j][0]].push_back(make_pair(i, j));
dp[i][j][dp[i][j][0]] = 0;
}
}
for (int i = 1; i <= K; i++) {
bfs(i);
}
int q;
cin >> q;
while (q--) {
int r1, c1, r2, c2;
cin >> r1 >> c1 >> r2 >> c2;
int res = abs(r1 - r2) + abs(c1 - c2);
for (int i = 1; i <= K; i++) {
res = min(res, dp[r1][c1][i] + 1 + dp[r2][c2][i]);
}
cout << res << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> rx[100005];
vector<int> ry[100005];
typedef struct {
int xi;
int yi;
int xj;
int yj;
int in;
} query;
query q[200005];
int ans[200005];
bool compx(query a, query b) {
if (a.xi == b.xi)
return a.yi < b.yi;
else
return a.xi < b.xi;
}
bool compy(query a, query b) {
if (a.yi == b.yi)
return a.xi < b.xi;
else
return a.yi < b.yi;
}
typedef struct {
int mn;
int mx;
int min;
} st;
int deg[200005];
st s[4 * 200005];
int lx, ly;
void buildy(int lo, int hi, int at) {
if (lo == hi) {
s[at].mx = s[at].mn = rx[lo][0];
s[at].min = lo;
return;
}
int mid = (lo + hi) / 2;
int l = 2 * at;
int r = 2 * at + 1;
buildy(lo, mid, l);
buildy(mid + 1, hi, r);
s[at].mx = max(s[l].mx, s[r].mx);
s[at].mn = min(s[l].mn, s[r].mn);
if (s[l].mn <= s[r].mn)
s[at].min = s[l].min;
else
s[at].min = s[r].min;
}
void buildx(int lo, int hi, int at) {
if (lo == hi) {
s[at].mx = s[at].mn = ry[lo][0];
s[at].min = lo;
return;
}
int mid = (lo + hi) / 2;
int l = 2 * at;
int r = 2 * at + 1;
buildx(lo, mid, l);
buildx(mid + 1, hi, r);
s[at].mx = max(s[l].mx, s[r].mx);
s[at].mn = min(s[l].mn, s[r].mn);
if (s[l].mn <= s[r].mn)
s[at].min = s[l].min;
else
s[at].min = s[r].min;
}
st que(int lo, int hi, int at, int from, int to) {
if (lo == from && hi == to) return s[at];
int mid = (lo + hi) / 2;
st i, j;
if (to <= mid)
return que(lo, mid, 2 * at, from, to);
else {
if (from > mid)
return que(mid + 1, hi, 2 * at + 1, from, to);
else {
i = que(lo, mid, 2 * at, from, mid);
j = que(mid + 1, hi, 2 * at + 1, mid + 1, to);
}
}
if (i.mn <= j.mn) return i;
return j;
}
st qmax(int lo, int hi, int at, int from, int to) {
if (lo == from && hi == to) return s[at];
int mid = (lo + hi) / 2;
st i, j;
if (to <= mid)
return qmax(lo, mid, 2 * at, from, to);
else {
if (from > mid)
return qmax(mid + 1, hi, 2 * at + 1, from, to);
else {
i = qmax(lo, mid, 2 * at, from, mid);
j = qmax(mid + 1, hi, 2 * at + 1, mid + 1, to);
}
}
if (i.mx >= j.mx) return i;
return j;
}
void update(int lo, int hi, int at, int val, int in) {
if (lo == hi) {
s[at].mn = val;
s[at].mx = val;
return;
}
int mid = (lo + hi) / 2;
if (in <= mid)
update(lo, mid, 2 * at, val, in);
else
update(mid + 1, hi, 2 * at + 1, val, in);
int l = 2 * at;
int r = 2 * at + 1;
s[at].mx = max(s[l].mx, s[r].mx);
s[at].mn = min(s[l].mn, s[r].mn);
if (s[l].mn <= s[r].mn)
s[at].min = s[l].min;
else
s[at].min = s[r].min;
}
void modify(int z) {
int a, b, c, d, e, x, y;
st i;
while (1) {
i = que(1, lx, 1, 1, lx);
if (i.mn >= z) break;
e = i.min;
for (a = deg[e]; a < rx[e].size(); a++) {
if (rx[e][a] >= z) {
deg[e] = a;
update(1, lx, 1, rx[e][a], e);
break;
}
}
}
}
void modifx(int z) {
int a, b, c, d, e, x, y;
st i;
while (1) {
i = que(1, ly, 1, 1, ly);
if (i.mn >= z) break;
e = i.min;
for (a = deg[e]; a < ry[e].size(); a++) {
if (ry[e][a] >= z) {
deg[e] = a;
update(1, ly, 1, ry[e][a], e);
break;
}
}
}
}
int main() {
int a, b, c, d, e, x, y, z, n, k, qu, m;
scanf("%d %d %d %d", &lx, &ly, &k, &qu);
for (a = 0; a < k; a++) {
scanf("%d %d", &x, &y);
rx[x].push_back(y);
ry[y].push_back(x);
}
for (a = 0; a < qu; a++) {
scanf("%d %d %d %d", &q[a].xi, &q[a].yi, &q[a].xj, &q[a].yj);
q[a].in = a + 1;
}
for (a = 1; a <= lx; a++) {
rx[a].push_back(ly + 2);
sort(rx[a].begin(), rx[a].end());
deg[a] = 0;
}
sort(q, q + qu, compy);
buildy(1, lx, 1);
z = -1;
st u;
for (a = 0; a < qu; a++) {
if (q[a].yi != z) {
modify(q[a].yi);
z = q[a].yi;
}
u = qmax(1, lx, 1, q[a].xi, q[a].xj);
if (u.mx > q[a].yj) {
} else {
ans[q[a].in]++;
}
}
for (a = 1; a <= ly; a++) {
ry[a].push_back(lx + 2);
sort(ry[a].begin(), ry[a].end());
deg[a] = 0;
}
buildx(1, ly, 1);
sort(q, q + qu, compx);
z = -1;
for (a = 0; a < qu; a++) {
if (q[a].xi != z) {
modifx(q[a].xi);
z = q[a].xi;
}
u = qmax(1, ly, 1, q[a].yi, q[a].yj);
if (u.mx > q[a].xj) {
} else {
ans[q[a].in]++;
}
}
for (a = 1; a <= qu; a++)
if (ans[a])
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
namespace patch {
template <typename T>
std::string to_string(const T& n) {
std::ostringstream stm;
stm << n;
return stm.str();
}
} // namespace patch
using namespace std;
long long int col[1005], row[1005], tot;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long int N, M;
char arr[1005][1005];
cin >> N >> M;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cin >> arr[i][j];
if (arr[i][j] == '*') {
tot++;
col[i]++;
row[j]++;
}
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (col[i] + row[j] - (arr[i][j] == '*') == tot) {
cout << "YES" << '\n' << i + 1 << " " << j + 1;
return 0;
}
}
}
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int Maxn = 300000;
int revv(int x, int bits) {
int ret = 0;
for (int i = 0; i < bits; i++) {
ret <<= 1;
ret |= x & 1;
x >>= 1;
}
return ret;
}
void FFT(double *a, double *b, int n, bool rev) {
int bits = 0;
while (1 << bits < n) ++bits;
for (int i = 0; i < n; i++) {
int j = revv(i, bits);
if (i < j) {
double t = a[i];
a[i] = a[j];
a[j] = t;
t = b[i];
b[i] = b[j];
b[j] = t;
}
}
for (int len = 2; len <= n; len <<= 1) {
int half = len >> 1;
double wmx = cos(2 * pi / len);
double wmy = sin(2 * pi / len);
if (rev) wmy = -wmy;
for (int i = 0; i < n; i += len) {
double wx = 1;
double wy = 0;
for (int j = 0; j < half; j++) {
double cx = a[i + j];
double cy = b[i + j];
double dx = a[i + j + half];
double dy = b[i + j + half];
double ex = dx * wx - dy * wy;
double ey = dx * wy + dy * wx;
a[i + j] = cx + ex;
b[i + j] = cy + ey;
a[i + j + half] = cx - ex;
b[i + j + half] = cy - ey;
double wnx = wx * wmx - wy * wmy;
double wny = wx * wmy + wy * wmx;
wx = wnx;
wy = wny;
}
}
}
if (rev) {
for (int i = 0; i < n; i++) {
a[i] /= n;
b[i] /= n;
}
}
}
int Getlen(int x) {
int ans = 1;
while (x > ans) ans <<= 1;
return ans;
}
string s1, s2;
int T, N, M;
int A[Maxn], B[Maxn], C[Maxn];
int f[70][200005];
int mk = 0;
int lim = 3005;
int a[200010], b[200010];
double tAx[Maxn], tAy[Maxn], tBx[Maxn], tBy[Maxn], tCx[Maxn], tCy[Maxn];
inline void read(int &x) {
char c;
for (c = getchar(); c < '0' || c > '9'; c = getchar())
;
for (x = 0; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - '0';
}
int main(int argc, char const *argv[]) {
cin >> s1 >> s2;
N = s1.size(), M = s2.size();
cin >> T;
reverse(s2.begin(), s2.end());
for (int i = 0; i < N; i++) A[i] = s1[i] - '0';
for (int i = 0; i < M; i++) b[i] = s2[i] - '0';
int nC = N + lim - 1, m = Getlen(nC);
for (int i = 0; i < m; i++) tAx[i] = 0, tAy[i] = 0;
for (int i = 0; i < N; i++) tAx[i] = A[i], tAy[i] = !A[i];
FFT(tAx, tAy, m, 0);
for (int i = 0; i < M / lim; i++) {
for (int j = i * lim, k = 0; k < lim; k++) B[k] = b[j + k];
for (int j = 0; j < m; j++) tBx[j] = 0, tBy[j] = 0;
for (int j = 0; j < lim; j++) tBx[j] = B[j], tBy[j] = !B[j];
FFT(tBx, tBy, m, 0);
for (int j = 0; j < m; j++) {
tCx[j] = tAx[j] * tBx[j] - tAy[j] * tBy[j];
tCy[j] = tAx[j] * tBy[j] + tBx[j] * tAy[j];
}
FFT(tCx, tCy, m, 1);
for (int j = 0; j <= N - lim; j++) f[i][j] = tCy[j + lim - 1] + 0.5;
}
int cs = 0;
while (T--) {
int x, y, l, r, len;
read(x);
read(l);
read(len);
y = x + len - 1;
r = M - l - 1;
l = r - len + 1;
int ans = 0;
for (; l % lim && l <= r; l++, y--) ans += A[y] != b[l];
for (int k = l / lim; l + lim <= r; l += lim, y -= lim, k++)
ans += f[k][y - lim + 1];
for (; l <= r; l++, y--) ans += A[y] != b[l];
printf("%d\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename elemType>
inline void Read(elemType &T) {
elemType X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
T = (w ? -X : X);
}
int a[505], b[505];
long long Sum[505], dp[505][505];
bool exist[505][505];
int N, K;
int main() {
Read(N);
Read(K);
exist[0][0] = true;
register int i, j, temp, p, l, r, s;
long long sum;
for (i = 1; i <= N; ++i) {
Read(a[i]);
Read(b[i]);
Sum[i] = Sum[i - 1] + a[i] + b[i];
for (j = 0; j < K; ++j) {
sum = Sum[i - 1] - dp[i - 1][j] * (long long)K;
if (!exist[i - 1][j]) continue;
temp = (j + a[i]) % K;
dp[i][temp] = dp[i - 1][j] + (j + a[i]) / K +
(sum - (long long)j + (long long)b[i]) / (long long)K;
exist[i][temp] = true;
l = max(0, K - b[i]), r = min(a[i], K);
for (s = l; s <= r; ++s) {
p = (j - s + a[i]) % K;
dp[i][p] = max(dp[i][p], dp[i - 1][j] + 1LL + (j - s + a[i]) / K +
(sum - j - K + s + b[i]) / K);
exist[i][p] = true;
}
}
}
long long Ans = 0;
for (i = 0; i < K; ++i) Ans = max(Ans, dp[N][i]);
printf("%I64d\n", Ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
using namespace std;
long long t, n, k, len[1005];
long long belong[1005];
string s;
long long check(long long l, long long r) {
cout << "? " << r - l + 1;
for (long long i = l; i <= r; i++) cout << " " << i;
cout << endl;
long long x;
cin >> x;
return x;
}
long long uncheck(long long id) {
cout << "? " << n - len[belong[id]];
for (long long i = 1; i <= n; i++)
if (belong[i] != belong[id]) cout << " " << i;
cout << endl;
long long x;
cin >> x;
return x;
}
signed main() {
cin >> t;
while (t--) {
memset(len, 0, sizeof(len));
memset(belong, 0, sizeof(belong));
cin >> n >> k;
len[0] = 1;
for (long long i = 1, x; i <= k; i++) {
cin >> len[i];
for (long long j = 1, x; j <= len[i]; j++) cin >> x, belong[x] = i;
}
long long l = 1, r = n, maxx = check(l, r);
while (l < r) {
long long mid = l + r >> 1;
if (check(l, mid) == maxx)
r = mid;
else
l = mid + 1;
}
long long lmax = uncheck(l);
cout << "!";
for (long long i = 1; i <= k; i++)
cout << " " << ((i == belong[l]) ? lmax : maxx);
cout << endl;
cin >> s;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, N = 100000;
struct Segment_tree1 {
int T[400010];
void Build(int now, int l, int r) {
T[now] = INF;
if (l == r) return;
int mid = l + r >> 1;
Build(now << 1, l, mid), Build(now << 1 | 1, mid + 1, r);
}
void Update(int now, int l, int r, int L, int R, int x) {
if (l == L && r == R) {
T[now] = min(T[now], x);
return;
}
int mid = l + r >> 1;
if (R <= mid)
Update(now << 1, l, mid, L, R, x);
else if (L > mid)
Update(now << 1 | 1, mid + 1, r, L, R, x);
else
Update(now << 1, l, mid, L, mid, x),
Update(now << 1 | 1, mid + 1, r, mid + 1, R, x);
}
int Query(int now, int l, int r, int pos) {
if (l == r) return T[now];
int mid = l + r >> 1;
if (pos <= mid) return min(T[now], Query(now << 1, l, mid, pos));
return min(T[now], Query(now << 1 | 1, mid + 1, r, pos));
}
} R[2];
struct Segment_tree2 {
int mx1[400010], cnt[400010], mx2[400010];
long long sum[400010];
void pushup(int now) {
mx1[now] = max(mx1[now << 1], mx1[now << 1 | 1]);
cnt[now] = (mx1[now] == mx1[now << 1] ? cnt[now << 1] : 0) +
(mx1[now] == mx1[now << 1 | 1] ? cnt[now << 1 | 1] : 0);
mx2[now] = max(
mx1[now] == mx1[now << 1] ? mx2[now << 1] : mx1[now << 1],
mx1[now] == mx1[now << 1 | 1] ? mx2[now << 1 | 1] : mx1[now << 1 | 1]);
sum[now] = sum[now << 1] + sum[now << 1 | 1];
}
void Build(int now, int l, int r) {
if (l == r) {
mx1[now] = 0, cnt[now] = 1, mx2[now] = -1, sum[now] = 0;
return;
}
int mid = l + r >> 1;
Build(now << 1, l, mid), Build(now << 1 | 1, mid + 1, r);
pushup(now);
}
void pushdown(int now) {
if (mx1[now << 1] > mx1[now]) {
sum[now << 1] -= 1ll * (mx1[now << 1] - mx1[now]) * cnt[now << 1];
mx1[now << 1] = mx1[now];
}
if (mx1[now << 1 | 1] > mx1[now]) {
sum[now << 1 | 1] -=
1ll * (mx1[now << 1 | 1] - mx1[now]) * cnt[now << 1 | 1];
mx1[now << 1 | 1] = mx1[now];
}
}
void Update(int now, int l, int r, int L, int R, int x) {
if (l == L && r == R) {
if (x >= mx1[now]) return;
if (x > mx2[now]) {
sum[now] -= 1ll * (mx1[now] - x) * cnt[now];
mx1[now] = x;
return;
}
pushdown(now);
int mid = l + r >> 1;
Update(now << 1, l, mid, l, mid, x),
Update(now << 1 | 1, mid + 1, r, mid + 1, r, x);
pushup(now);
return;
}
pushdown(now);
int mid = l + r >> 1;
if (R <= mid)
Update(now << 1, l, mid, L, R, x);
else if (L > mid)
Update(now << 1 | 1, mid + 1, r, L, R, x);
else
Update(now << 1, l, mid, L, mid, x),
Update(now << 1 | 1, mid + 1, r, mid + 1, R, x);
pushup(now);
}
void Modify(int now, int l, int r, int pos, int x) {
if (l == r) {
mx1[now] = x, cnt[now] = 1, mx2[now] = -1, sum[now] = x;
return;
}
pushdown(now);
int mid = l + r >> 1;
if (pos <= mid)
Modify(now << 1, l, mid, pos, x);
else
Modify(now << 1 | 1, mid + 1, r, pos, x);
pushup(now);
}
long long Query(int now, int l, int r, int L, int R) {
if (l == L && r == R) return sum[now];
pushdown(now);
int mid = l + r >> 1;
if (R <= mid) return Query(now << 1, l, mid, L, R);
if (L > mid) return Query(now << 1 | 1, mid + 1, r, L, R);
return Query(now << 1, l, mid, L, mid) +
Query(now << 1 | 1, mid + 1, r, mid + 1, R);
}
} seg[2];
set<int> S[4];
int main() {
R[0].Build(1, 1, N), R[1].Build(1, 1, N), seg[0].Build(1, 1, N),
seg[1].Build(1, 1, N);
for (int i = 1; i <= N; i++) S[3].insert(i);
int q;
scanf("%d", &q);
while (q--) {
int op, l, r, x;
scanf("%d%d%d", &op, &l, &r), r--;
if (op == 2)
printf("%lld\n",
seg[0].Query(1, 1, N, l, r) + seg[1].Query(1, 1, N, l, r));
else {
scanf("%d", &x);
int d = 0;
if (x < 0) x = -x, d = 1;
seg[d].Update(1, 1, N, l, r, x), R[d].Update(1, 1, N, l, r, x);
for (int i = 0; i < 4; i++) {
if (i >> d & 1) {
set<int>::iterator it = S[i].lower_bound(l);
while (it != S[i].end() && *it <= r) {
S[i ^ 1 << d].insert(*it);
if ((i ^ 1 << d) == 0) {
seg[0].Modify(1, 1, N, *it, R[0].Query(1, 1, N, *it));
seg[1].Modify(1, 1, N, *it, R[1].Query(1, 1, N, *it));
}
it = S[i].erase(it);
}
}
}
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
int cnt[N + 1];
int check[N + 1];
set<pair<int, int> > s;
int main() {
int n, A;
scanf("%d %d", &n, &A);
for (int i = 1; i <= N; i++) {
cnt[i] = 0;
s.insert({cnt[i], i});
}
for (int i = 0; i < n; i++) {
int foo;
scanf("%d", &foo);
if (!check[foo]) {
s.erase(s.find({cnt[foo], foo}));
s.insert({++cnt[foo], foo});
}
while ((!s.empty()) && s.begin()->first < cnt[A]) {
check[s.begin()->second] = 1;
s.erase(s.begin());
}
}
for (auto x : s) {
if (x.second != A) {
cout << x.second << endl;
return 0;
}
}
puts("-1");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[1000001], b[1000001];
bitset<2010> dp[2];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int i, j;
for (i = 1; i <= k; i++) {
scanf("%d", &a[i]);
a[i] -= n;
}
sort(a + 1, a + 1 + k);
int tot = 1;
b[1] = a[1];
for (i = 2; i <= k; i++) {
if (a[i] != a[i - 1]) {
tot++;
b[tot] = a[i];
}
}
for (i = 1; i <= tot; i++) a[i] = b[i];
dp[0][1000] = 1;
int p = 1, q = 0;
for (i = 1; i <= 1000; i++) {
for (j = 1; j <= tot; j++) {
if (a[j] < 0)
dp[p] |= (dp[q] >> (-a[j]));
else
dp[p] |= (dp[q] << (a[j]));
}
if (dp[p][1000] != 0) {
printf("%d\n", i);
return 0;
}
dp[q].reset();
p = 1 - p;
q = 1 - q;
}
printf("-1\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
uint64_t N;
scanf("%I64u", &N);
int digit_count[10] = {0};
uint64_t M = N;
int dlen = 0;
std::vector<int> digits;
while (M > 0) {
dlen++;
digit_count[M % 10]++;
digits.push_back(M % 10);
M /= 10;
}
int steps_method[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
if (digit_count[0] >= 2) {
auto first_zero = std::find(digits.begin(), digits.end(), 0);
auto second_zero = std::find(first_zero + 1, digits.end(), 0);
steps_method[0] =
(first_zero - digits.begin()) + (second_zero - digits.begin()) - 1;
}
if (digit_count[0] >= 1 && digit_count[5] >= 1) {
auto first_zero = std::find(digits.begin(), digits.end(), 0);
auto second_five = std::find(digits.begin(), digits.end(), 5);
int move1 = first_zero - digits.begin();
int move2 = second_five - (digits.begin() + 1);
if (move2 < move1) move2++;
steps_method[1] = move1 + move2;
}
if (digit_count[2] >= 1 && digit_count[5] >= 1) {
auto first_five = std::find(digits.begin(), digits.end(), 5);
auto second_two = std::find(digits.begin(), digits.end(), 2);
int move1 = first_five - digits.begin();
int move2 = second_two - (digits.begin() + 1);
if (move2 < move1) move2++;
steps_method[2] = move1 + move2;
if ((first_five == digits.end() - 1 || second_two == digits.end() - 1) &&
*(digits.end() - 2) == 0) {
if (dlen == 3)
steps_method[2] = INT_MAX;
else {
int add_swaps = 1;
while (*(digits.end() - 2 - add_swaps) == 0) add_swaps++;
steps_method[2] += add_swaps;
}
}
}
if (digit_count[7] >= 1 && digit_count[5] >= 1) {
auto first_five = std::find(digits.begin(), digits.end(), 5);
auto second_seven = std::find(digits.begin(), digits.end(), 7);
int move1 = first_five - digits.begin();
int move2 = second_seven - (digits.begin() + 1);
if (move2 < move1) move2++;
steps_method[3] = move1 + move2;
if ((first_five == digits.end() - 1 || second_seven == digits.end() - 1) &&
*(digits.end() - 2) == 0) {
if (dlen == 3)
steps_method[3] = INT_MAX;
else {
int add_swaps = 1;
while (*(digits.end() - 2 - add_swaps) == 0) add_swaps++;
steps_method[3] += add_swaps;
}
}
}
int min_swaps = *std::min_element(steps_method, steps_method + 4);
if (min_swaps == INT_MAX) {
printf("-1");
} else {
printf("%d", min_swaps);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
template <typename T>
bool chkmin(T &a, T b) {
return b < a ? a = b, true : false;
}
template <typename T>
bool chkmax(T &a, T b) {
return b > a ? a = b, true : false;
}
template <class T>
void read(T &first) {
char c;
int flag = 1;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag = -1;
first = c - '0';
while ((c = getchar()) >= '0' && c <= '9') first = first * 10 + c - '0';
first *= flag;
}
template <class T>
void write(T first) {
if (first < 0) putchar('-'), first = -first;
static char s[20];
int top = 0;
while (first) s[++top] = first % 10 + '0', first /= 10;
if (top == 0) putchar('0');
while (top) putchar(s[top--]);
}
const int MAXN = 1e6 + 100;
const int mod = 1e9 + 7;
long long pwr(long long first, long long k, long long p) {
long long ret = 1;
for (; k; k >>= 1, first = first * first % p)
if (k & 1) ret = ret * first % p;
return ret;
}
int id = 0;
int mex[MAXN];
int N, M;
int sg(int n) {
if (!M) {
if (n == 1) return 1;
if (n == 2) return 2;
return n & 1 ? 0 : 1;
}
if (n == 1 || n == 3) return 1;
if (n == 2) return 0;
if (n == 4) return 2;
if (n & 1) return 0;
return (sg(n >> 1) == 1) ? 2 : 1;
}
int main() {
read(N), read(M);
M = M & 1;
int SG = 0;
for (int i = 1, first; i <= N; ++i) read(first), SG ^= sg(first);
puts(SG != 0 ? "Kevin" : "Nicky");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, lb, rb, ky[10000069], ps[10000069], pwk;
bitset<10000069> vtd;
long long pw(long long x, long long y) {
if (!y) {
return 1;
}
pwk = pw(x, y / 2);
pwk = min(pwk * pwk, rb + 1);
if (y % 2) {
pwk = min(pwk * x, rb + 1);
}
return pwk;
}
int main() {
long long i, j, r, k, c, z = 0;
scanf("%lld%lld%lld", &n, &lb, &rb);
if (n == 1) {
printf("%lld\n", rb - lb + 1);
return 0;
}
for (i = 1; i <= rb; i++) {
ky[i] = i;
}
for (i = 2; i <= rb; i++) {
if (!vtd[i]) {
for (j = i; j <= rb; j += i) {
vtd[j] = 1;
for (c = 0; ky[j] % i == 0; ky[j] /= i, c++)
;
for (r = 0; r < c % (n - 1); r++, ky[j] *= i)
;
}
}
}
for (i = 1; 1; i++) {
k = pw(i, n - 1);
if (k > rb) {
break;
}
ps[k]++;
}
for (i = 1; i <= rb; i++) {
ps[i] += ps[i - 1];
}
for (i = lb; i <= rb; i++) {
z += ps[rb / ky[i]] - ps[(lb - 1) / ky[i]] - 1;
}
printf("%lld\n", z);
}
| 8 |
#include <bits/stdc++.h>
int main() {
int a[110] = {0, 1, 2, 4, 6};
int n, i;
scanf("%d", &n);
for (i = 5; i < 110; i++) {
a[i] = 2 * a[i - 1] - 2 * a[i - 3] + a[i - 4];
}
printf("%d", a[n]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int P(998244353);
long long mpower(long long a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = ret * a % P;
a = a * a % P;
b >>= 1;
}
return ret;
}
int n, p, cp[2005][2005], st[2005], ans[2005];
int main() {
{
int a, b;
scanf("%d%d%d", &n, &a, &b);
p = a * mpower(b, P - 2) % P;
}
cp[0][0] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= i; ++j)
cp[i][j] = (cp[i - 1][j] * mpower(P + 1 - p, j) +
(j ? cp[i - 1][j - 1] * mpower(p, i - j) : 0)) %
P;
for (int i = 1; i <= n; ++i) {
st[i] = 1;
for (int j = 1; j < i; ++j)
st[i] = (st[i] - (long long)st[j] * cp[i][j]) % P;
if (st[i] < 0) st[i] += P;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < i; ++j)
ans[i] = (ans[i] + ((long long)j * (i - j) + (long long)j * (j - 1) / 2 +
ans[j] + ans[i - j]) %
P * st[j] % P * cp[i][j]) %
P;
ans[i] = (ans[i] + (long long)i * (i - 1) / 2 % P * st[i]) % P;
ans[i] = ans[i] * mpower((P + 1 - st[i]) % P, P - 2) % P;
}
printf("%d\n", ans[n]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int cnt[3] = {0};
int n, T, len, type;
int dp1[51][2501];
int dp2[51][51][2501];
int f[3][51][51][51];
long long int fac[51], ans = 0;
void init(void) {
dp1[0][0] = dp2[0][0][0] = 1;
fac[0] = fac[1] = 1;
for (int i = 2; i <= n; i++) fac[i] = fac[i - 1] * i % 1000000007;
f[0][1][0][0] = f[1][0][1][0] = f[2][0][0][1] = 1;
for (int sum = 2; sum <= n; sum++)
for (int i = 0; i <= sum; i++)
for (int j = 0; i + j <= sum; j++) {
int k = sum - i - j;
if (i >= 1)
f[0][i][j][k] = (f[1][i - 1][j][k] + f[2][i - 1][j][k]) % 1000000007;
if (j >= 1)
f[1][i][j][k] = (f[0][i][j - 1][k] + f[2][i][j - 1][k]) % 1000000007;
if (k >= 1)
f[2][i][j][k] = (f[0][i][j][k - 1] + f[1][i][j][k - 1]) % 1000000007;
}
return;
}
int main(void) {
scanf("%d%d", &n, &T);
init();
for (int i = 0; i < n; i++) {
scanf("%d%d", &len, &type);
cnt[type - 1]++;
if (type == 1)
for (int i = cnt[0]; i > 0; i--)
for (int j = cnt[1]; j >= 0; j--)
for (int k = T; k >= len; k--)
dp2[i][j][k] = (dp2[i][j][k] + dp2[i - 1][j][k - len]) % 1000000007;
else if (type == 2)
for (int i = cnt[0]; i >= 0; i--)
for (int j = cnt[1]; j > 0; j--)
for (int k = T; k >= len; k--)
dp2[i][j][k] = (dp2[i][j][k] + dp2[i][j - 1][k - len]) % 1000000007;
else
for (int i = cnt[2]; i > 0; i--)
for (int j = T; j >= len; j--)
dp1[i][j] = (dp1[i][j] + dp1[i - 1][j - len]) % 1000000007;
}
for (int i = 0; i <= n; i++)
for (int j = 0; i + j <= n; j++)
for (int k = 0; i + j + k <= n; k++)
for (int t = 0; t <= T; t++) {
long long int p = fac[i] * fac[j] % 1000000007 * fac[k] % 1000000007;
p = p *
((long long int)f[0][i][j][k] + f[1][i][j][k] + f[2][i][j][k]) %
1000000007;
p = p * dp1[k][T - t] % 1000000007 * dp2[i][j][t];
ans = (ans + p) % 1000000007;
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> g(200000);
long long a[200000];
long long s[200000];
void dfs(long long v, bool h = true, long long p = -1) {
if (s[v] != -1) {
if (!h) {
cout << -1;
exit(0);
}
for (auto i : g[v]) {
dfs(i, !h, v);
}
return;
}
long long pz = s[p];
long long mi = (long long)1e18;
for (auto i : g[v]) {
mi = min(mi, s[i]);
}
if (mi == (long long)1e18) {
mi = pz;
}
if (mi < pz) {
cout << -1;
exit(0);
}
s[v] = mi;
for (auto i : g[v]) {
dfs(i, !h, v);
}
}
void df(int v, int p = -1) {
if (v != 0) a[v] = s[v] - s[p];
for (auto i : g[v]) {
df(i, v);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long p;
cin >> p;
g[p - 1].emplace_back(i + 1);
}
for (long long i = 0; i < n; i++) {
cin >> s[i];
}
dfs(0);
df(0);
a[0] = s[0];
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += a[i];
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
#define clr(x) memset(x,0,sizeof(x))
#define For(i,a,b) for (int i=(a);i<=(b);i++)
#define Fod(i,b,a) for (int i=(b);i>=(a);i--)
#define fi first
#define se second
#define kill _z_kill
#define y0 _z_y0
#define y1 _z_y1
#define x0 _z_x0
#define x1 _z_x1
#define pb push_back
#define mp(x,y) make_pair(x,y)
using namespace std;
typedef long long LL;
typedef unsigned long long ull;
typedef unsigned uint;
typedef long double LD;
typedef vector <int> vi;
typedef pair <int,int> pii;
void enable_comma(){}
string tostring(char c){
string s="";
s+=c;
return s;
}
string tostring(string s){
return "\""+s+"\"";
}
string tostring(const char *c){
return tostring((string)c);
}
string tostring(long long x){
if (x<0)
return "-"+tostring(-x);
if (x>9)
return tostring(x/10)+tostring(char('0'+x%10));
else
return tostring(char('0'+x));
}
string tostring(int x){
return tostring((long long)x);
}
string tostring(unsigned long long x){
if (x>9)
return tostring((long long)(x/10))+tostring(char('0'+x%10));
else
return tostring(char('0'+x));
}
string tostring(unsigned x){
return tostring((long long)x);
}
string tostring(double x){
static char res[114];
sprintf(res,"%lf",x);
string s=tostring(res);
return s.substr(1,(int)s.size()-2);
}
string tostring(long double x){
return tostring((double)x);
}
template <class A,class B> string tostring(pair <A,B> p){
return "("+tostring(p.fi)+","+tostring(p.se)+")";
}
template <class T> string tostring(T v){
string res="";
for (auto p : v)
res+=(res.size()?",":"{")+tostring(p);
return res.size()?res+"}":"{}";
}
template <class A> string tostring(A* a,int L,int R){
return tostring(vector <A>(a+L,a+R+1));
};
template <class A> string tostring(A a,int L,int R){
return tostring(a.data(),L,R);
}
string tostrings(){
return "";
}
template <typename Head,typename... Tail>
string tostrings(Head H,Tail... T){
return tostring(H)+" "+tostrings(T...);
}
#define User_Time ((double)clock()/CLOCKS_PER_SEC)
#ifdef zzd
#define outval(x) cerr<<#x" = "<<tostring(x)<<endl
#define outvals(...) cerr<<"["<<#__VA_ARGS__<<"]: "<<\
tostrings(__VA_ARGS__)<<endl
#define outtag(x) cerr<<"--------------"#x"---------------"<<endl
#define outsign(x) cerr<<"<"#x">"<<endl
#define outarr(a,L,R) cerr<<#a"["<<(L)<<".."<<(R)<<"] = "<<\
tostring(a,L,R)<<endl
#else
#define outval(x) enable_comma()
#define outvals(...) enable_comma()
#define outtag(x) enable_comma()
#define outsign(x) enable_comma()
#define outarr(a,L,R) enable_comma()
#endif
#ifdef ONLINE_JUDGE
#ifdef assert
#undef assert
#endif
#define assert(x) (!(x)?\
cout<<"Assertion failed!"<<endl<<\
"function: "<<__FUNCTION__<<endl<<\
"line: "<<__LINE__<<endl<<\
"expression: "<<#x<<endl,exit(3),0:1)
#endif
LL read(){
LL x=0,f=0;
char ch=getchar();
while (!isdigit(ch))
f=ch=='-',ch=getchar();
while (isdigit(ch))
x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
return f?-x:x;
}
template <class T> void ckmax(T &x,const T y){
if (x<y)
x=y;
}
template <class T> void ckmin(T &x,const T y){
if (x>y)
x=y;
}
//int Pow(int x,LL y){
// y=(y%(mod-1)+(mod-1))%(mod-1);
// int ans=1;
// for (;y;y>>=1,x=(LL)x*x%mod)
// if (y&1)
// ans=(LL)ans*x%mod;
// return ans;
//}
//void Add(int &x,int y){
// if ((x+=y)>=mod)
// x-=mod;
//}
//void Del(int &x,int y){
// if ((x-=y)<0)
// x+=mod;
//}
//int Add(int x){
// return x>=mod?x-mod:x;
//}
//int Del(int x){
// return x<0?x+mod:x;
//}
//int md(LL x){
// return (x%mod+mod)%mod;
//}
const int N=500005;
int n;
char a[N];
int pre[N];
int vis[1<<18];
int ans;
void dfs(int x){
if (vis[x])
return;
vis[x]=1;
ckmin(ans,x);
// outval(x);
For(i,0,n-1){
int c0=0,c1=0;
For(j,i,n-1){
if (x>>j&1)
c1++;
else
c0++;
if (c0==c1){
int y=x;
For(k,i,j)
y^=1<<k;
for (int l=i,r=j;l<r;l++,r--){
int v0=y>>l&1,v1=y>>r&1;
y^=v0<<l;
y^=v1<<r;
y^=v0<<r;
y^=v1<<l;
}
dfs(y);
}
}
}
}
void bf(){
clr(vis);
int v=0;
For(i,1,n)
v|=(a[i]-'0')<<(i-1);
ans=v;
dfs(v);
For(i,0,n-1)
putchar(ans>>i&1?'1':'0');
puts("");
}
void solve(){
scanf("%s",a+1);
n=strlen(a+1);
#ifdef zzd
bf();
#endif
unordered_map <int,int> cnt;
int s=0,mx=-1;
For(i,1,n){
ckmax(mx,s);
s+=a[i]=='1'?1:-1;
pre[i]=s;
cnt[min(pre[i],pre[i-1])]++;
}
int now=0;
// outval(cnt);
For(i,1,n){
if (i==n){
if (cnt[now])
a[i]='1';
else
assert(cnt[now-1]),a[i]='0';
break;
}
if (cnt[now-1]>0&&(now-1!=s||cnt[now-1]+cnt[now-2]>2)&&(cnt[now-1]>1||!cnt[now])){
a[i]='0';
now--;
assert(cnt[now]>0);
cnt[now]--;
}
else {
a[i]='1';
assert(cnt[now]>0);
cnt[now]--;
now++;
}
// outval(now);
}
For(i,1,n)
putchar(a[i]);
puts("");
}
int main(){
int T=read();
while (T--)
solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string lower(string second) {
for (int i = 0; i < second.size(); i++)
if (second[i] >= 'A' && second[i] <= 'Z') second[i] = second[i] - 'A' + 'a';
return second;
}
char reg(char c, char t) {
if (c >= 'A' && c <= 'Z') return t - 'a' + 'A';
return t;
}
string second, a[105], sl;
bool u[105];
int n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] = lower(a[i]);
}
char let;
cin >> second >> let;
sl = lower(second);
for (int i = 0; i < second.size(); i++)
for (int j = 0; j < n; j++)
if (i + a[j].size() <= second.size() &&
sl.substr(i, a[j].size()) == a[j]) {
for (int k = i; k < i + a[j].size(); k++) u[k] = true;
}
for (int i = 0; i < second.size(); i++)
if (u[i]) {
if (sl[i] == let) {
if (sl[i] == 'a')
second[i] = reg(second[i], 'b');
else
second[i] = reg(second[i], 'a');
} else
second[i] = reg(second[i], let);
}
cout << second;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
string s;
cin >> s;
s = '*' + s;
set<long long> alpha[26];
for (long long i = 1; i < s.size(); i++) alpha[s[i] - 'a'].insert(i);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (n == 1) {
long long x;
char y;
cin >> x >> y;
char c = s[x];
alpha[c - 'a'].erase(x);
alpha[y - 'a'].insert(x);
s[x] = y;
} else {
long long p, q;
cin >> p >> q;
long long ans = 0;
for (long long i = 0; i < 26; i++) {
auto it = alpha[i].lower_bound(p);
if (it != alpha[i].end() && (*it) >= p && (*it) <= q) ans++;
}
cout << ans << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class PQNode {
friend class PQTree;
friend class QNodeChildrenIterator;
public:
enum PQNode_types { leaf, pnode, qnode };
enum PQNode_marks { unmarked, queued, blocked, unblocked };
enum PQNode_labels { empty, full, partial };
PQNode_types Type();
int LeafValue();
void Children(vector<PQNode*>* children);
private:
list<PQNode*> circular_link_;
int ChildCount();
PQNode* CircularChildWithLabel(PQNode_labels label);
void MoveFullChildren(PQNode* new_node);
void ReplaceCircularLink(PQNode* old_child, PQNode* new_child);
PQNode* endmost_children_[2];
PQNode* pseudo_neighbors_[2];
bool pseudonode_, pseudochild_;
PQNode* EndmostChildWithLabel(PQNode_labels label);
PQNode* ImmediateSiblingWithLabel(PQNode_labels label);
PQNode* ImmediateSiblingWithoutLabel(PQNode_labels label);
void AddImmediateSibling(PQNode* sibling);
void RemoveImmediateSibling(PQNode* sibling);
void ClearImmediateSiblings();
int ImmediateSiblingCount() const;
void ReplaceEndmostChild(PQNode* old_child, PQNode* new_child);
void ReplaceImmediateSibling(PQNode* old_child, PQNode* new_child);
void ReplacePartialChild(PQNode* old_child, PQNode* new_child);
void ForgetChildren();
bool ConsecutiveFullPartialChildren();
set<PQNode*> full_children_;
set<PQNode*> partial_children_;
PQNode* immediate_siblings_[2];
enum PQNode_labels label_;
enum PQNode_marks mark_;
enum PQNode_types type_;
PQNode* parent_;
int pertinent_child_count;
int pertinent_leaf_count;
int leaf_value_;
PQNode* CopyAsChild(const PQNode& to_copy);
void Copy(const PQNode& copy);
PQNode& operator=(const PQNode& to_copy);
PQNode* QNextChild(PQNode* last) const;
void ReplaceChild(PQNode* old_child, PQNode* new_child);
void SwapQ(PQNode* toInsert);
PQNode* Parent() const;
PQNode(const PQNode& to_copy);
PQNode(int value);
PQNode();
~PQNode();
void LabelAsFull();
void FindLeaves(map<int, PQNode*>& leafAddress);
void FindFrontier(list<int>& ordering);
void Reset();
void Print(string* out) const;
void Identify() const;
};
class QNodeChildrenIterator {
public:
QNodeChildrenIterator(PQNode* parent, PQNode* begin_side = NULL);
PQNode* Current();
void Next();
void Reset(PQNode* begin_side = NULL);
bool IsDone();
private:
void NextPseudoNodeSibling();
PQNode* parent_;
PQNode* current_;
PQNode* next_;
PQNode* prev_;
};
PQNode::PQNode_types PQNode::Type() { return type_; }
int PQNode::LeafValue() {
assert(type_ == leaf);
return leaf_value_;
}
void PQNode::Children(vector<PQNode*>* children) {
assert(children->empty());
if (type_ == pnode) {
for (list<PQNode*>::const_iterator i = circular_link_.begin();
i != circular_link_.end(); ++i)
children->push_back(*i);
} else if (type_ == qnode) {
for (QNodeChildrenIterator qit(this); !qit.IsDone(); qit.Next())
children->push_back(qit.Current());
}
}
int PQNode::ChildCount() { return circular_link_.size(); }
PQNode* PQNode::CopyAsChild(const PQNode& to_copy) {
PQNode* temp = new PQNode(to_copy);
temp->parent_ = this;
return temp;
}
PQNode::PQNode(const PQNode& to_copy) { Copy(to_copy); }
void PQNode::Copy(const PQNode& to_copy) {
leaf_value_ = to_copy.leaf_value_;
pertinent_leaf_count = to_copy.pertinent_leaf_count;
pertinent_child_count = to_copy.pertinent_child_count;
type_ = to_copy.type_;
mark_ = to_copy.mark_;
label_ = to_copy.label_;
pseudonode_ = to_copy.pseudonode_;
pseudochild_ = to_copy.pseudochild_;
parent_ = NULL;
partial_children_.clear();
full_children_.clear();
circular_link_.clear();
endmost_children_[0] = NULL;
endmost_children_[1] = NULL;
ClearImmediateSiblings();
ForgetChildren();
for (list<PQNode*>::const_iterator i = to_copy.circular_link_.begin();
i != to_copy.circular_link_.end(); i++)
circular_link_.push_back(CopyAsChild(**i));
if (type_ == qnode) {
PQNode *current, *last;
PQNode *curCopy, *lastCopy, *nextCopy;
endmost_children_[0] = CopyAsChild(*to_copy.endmost_children_[0]);
curCopy = to_copy.endmost_children_[0];
lastCopy = NULL;
last = endmost_children_[0];
nextCopy = curCopy->QNextChild(lastCopy);
while (nextCopy != NULL) {
lastCopy = curCopy;
curCopy = nextCopy;
current = CopyAsChild(*curCopy);
current->AddImmediateSibling(last);
last->AddImmediateSibling(current);
last = current;
nextCopy = curCopy->QNextChild(lastCopy);
}
endmost_children_[1] = current;
}
}
PQNode& PQNode::operator=(const PQNode& to_copy) {
if (&to_copy == this) return *this;
Copy(to_copy);
return *this;
}
void PQNode::LabelAsFull() {
label_ = full;
if (parent_) parent_->full_children_.insert(this);
}
PQNode* PQNode::QNextChild(PQNode* last) const {
if (immediate_siblings_[0] == last) {
return immediate_siblings_[1];
} else {
if (!last && 2 == ImmediateSiblingCount()) return immediate_siblings_[1];
return immediate_siblings_[0];
}
}
void PQNode::ReplaceChild(PQNode* old_child, PQNode* new_child) {
if (type_ == pnode) {
ReplaceCircularLink(old_child, new_child);
} else {
for (int i = 0; i < 2 && old_child->immediate_siblings_[i]; ++i) {
PQNode* sibling = old_child->immediate_siblings_[i];
sibling->ReplaceImmediateSibling(old_child, new_child);
}
ReplaceEndmostChild(old_child, new_child);
}
new_child->parent_ = old_child->parent_;
if (new_child->label_ == partial)
new_child->parent_->partial_children_.insert(new_child);
if (new_child->label_ == full)
new_child->parent_->full_children_.insert(new_child);
}
void PQNode::SwapQ(PQNode* toInsert) {
toInsert->pseudochild_ = pseudochild_;
toInsert->ClearImmediateSiblings();
for (int i = 0; i < 2; ++i) {
if (parent_->endmost_children_[i] == this)
parent_->endmost_children_[i] = toInsert;
if (immediate_siblings_[i])
immediate_siblings_[i]->ReplaceImmediateSibling(this, toInsert);
}
ClearImmediateSiblings();
parent_ = NULL;
}
PQNode* PQNode::Parent() const {
if (immediate_siblings_[0] == NULL || immediate_siblings_[1] == NULL)
return parent_;
return NULL;
}
PQNode::PQNode(int value) {
leaf_value_ = value;
type_ = leaf;
parent_ = NULL;
label_ = empty;
mark_ = unmarked;
pertinent_child_count = 0;
pertinent_leaf_count = 0;
endmost_children_[0] = NULL;
endmost_children_[1] = NULL;
ClearImmediateSiblings();
ForgetChildren();
}
PQNode::PQNode() {
pseudonode_ = false;
parent_ = NULL;
label_ = empty;
mark_ = unmarked;
pertinent_child_count = 0;
pertinent_leaf_count = 0;
endmost_children_[0] = NULL;
endmost_children_[1] = NULL;
ClearImmediateSiblings();
ForgetChildren();
}
PQNode::~PQNode() {
if (type_ == qnode) {
PQNode* last = NULL;
PQNode* current = endmost_children_[0];
while (current) {
PQNode* next = current->QNextChild(last);
delete last;
last = current;
current = next;
}
delete last;
} else if (type_ == pnode) {
for (list<PQNode*>::iterator i = circular_link_.begin();
i != circular_link_.end(); i++)
delete *i;
circular_link_.clear();
}
}
PQNode* PQNode::CircularChildWithLabel(PQNode_labels label) {
for (list<PQNode*>::iterator i = circular_link_.begin();
i != circular_link_.end(); i++) {
if ((*i)->label_ == label) return *i;
}
return NULL;
}
PQNode* PQNode::EndmostChildWithLabel(PQNode_labels label) {
for (int i = 0; i < 2; ++i)
if (endmost_children_[i] && endmost_children_[i]->label_ == label)
return endmost_children_[i];
return NULL;
}
PQNode* PQNode::ImmediateSiblingWithLabel(PQNode_labels label) {
for (int i = 0; i < 2 && immediate_siblings_[i]; ++i)
if (immediate_siblings_[i]->label_ == label) return immediate_siblings_[i];
return NULL;
}
PQNode* PQNode::ImmediateSiblingWithoutLabel(PQNode_labels label) {
for (int i = 0; i < 2 && immediate_siblings_[i]; ++i)
if (immediate_siblings_[i]->label_ != label) return immediate_siblings_[i];
return NULL;
}
void PQNode::AddImmediateSibling(PQNode* sibling) {
int null_idx = ImmediateSiblingCount();
assert(null_idx < 2);
immediate_siblings_[null_idx] = sibling;
}
void PQNode::RemoveImmediateSibling(PQNode* sibling) {
if (immediate_siblings_[0] == sibling) {
immediate_siblings_[0] = immediate_siblings_[1];
immediate_siblings_[1] = NULL;
} else if (immediate_siblings_[1] == sibling) {
immediate_siblings_[1] = NULL;
} else {
assert(false);
}
}
void PQNode::ClearImmediateSiblings() {
for (int i = 0; i < 2; ++i) immediate_siblings_[i] = NULL;
}
int PQNode::ImmediateSiblingCount() const {
int count = 0;
for (int i = 0; (i < 2) && immediate_siblings_[i]; ++i) ++count;
return count;
}
void PQNode::ReplaceEndmostChild(PQNode* old_child, PQNode* new_child) {
for (int i = 0; i < 2; ++i) {
if (endmost_children_[i] == old_child) {
endmost_children_[i] = new_child;
return;
}
}
}
void PQNode::ReplaceImmediateSibling(PQNode* old_child, PQNode* new_child) {
for (int i = 0; i < 2 && immediate_siblings_[i]; ++i)
if (immediate_siblings_[i] == old_child) immediate_siblings_[i] = new_child;
new_child->immediate_siblings_[new_child->ImmediateSiblingCount()] = this;
}
void PQNode::ReplacePartialChild(PQNode* old_child, PQNode* new_child) {
new_child->parent_ = this;
partial_children_.insert(new_child);
partial_children_.erase(old_child);
if (type_ == pnode) {
circular_link_.remove(old_child);
circular_link_.push_back(new_child);
} else {
old_child->SwapQ(new_child);
}
}
void PQNode::ForgetChildren() {
for (int i = 0; i < 2; ++i) endmost_children_[i] = NULL;
}
bool PQNode::ConsecutiveFullPartialChildren() {
if (full_children_.size() + partial_children_.size() <= 1) return true;
map<PQNode_labels, int> counts;
for (set<PQNode*>::iterator it = full_children_.begin();
it != full_children_.end(); ++it) {
for (int i = 0; i < 2 && (*it)->immediate_siblings_[i]; ++i)
counts[(*it)->immediate_siblings_[i]->label_]++;
}
for (set<PQNode*>::iterator it = partial_children_.begin();
it != partial_children_.end(); ++it) {
for (int i = 0; i < 2 && (*it)->immediate_siblings_[i]; ++i)
counts[(*it)->immediate_siblings_[i]->label_]++;
}
if (counts[partial] != partial_children_.size()) return false;
if (counts[full] != (full_children_.size() * 2) - (2 - counts[partial]))
return false;
return true;
}
void PQNode::MoveFullChildren(PQNode* new_node) {
for (set<PQNode*>::iterator i = full_children_.begin();
i != full_children_.end(); ++i) {
circular_link_.remove(*i);
new_node->circular_link_.push_back(*i);
(*i)->parent_ = new_node;
}
}
void PQNode::ReplaceCircularLink(PQNode* old_child, PQNode* new_child) {
circular_link_.remove(old_child);
circular_link_.push_back(new_child);
}
void PQNode::FindLeaves(map<int, PQNode*>& leafAddress) {
if (type_ == leaf) {
leafAddress[leaf_value_] = this;
} else if (type_ == pnode) {
for (list<PQNode*>::iterator i = circular_link_.begin();
i != circular_link_.end(); i++)
(*i)->FindLeaves(leafAddress);
} else if (type_ == qnode) {
PQNode* last = NULL;
PQNode* current = endmost_children_[0];
while (current) {
current->FindLeaves(leafAddress);
PQNode* next = current->QNextChild(last);
last = current;
current = next;
}
}
}
void PQNode::FindFrontier(list<int>& ordering) {
if (type_ == leaf) {
ordering.push_back(leaf_value_);
} else if (type_ == pnode) {
for (list<PQNode*>::iterator i = circular_link_.begin();
i != circular_link_.end(); i++)
(*i)->FindFrontier(ordering);
} else if (type_ == qnode) {
PQNode* last = NULL;
PQNode* current = endmost_children_[0];
while (current) {
current->FindFrontier(ordering);
PQNode* next = current->QNextChild(last);
last = current;
current = next;
}
}
}
void PQNode::Reset() {
if (type_ == pnode) {
for (list<PQNode*>::iterator i = circular_link_.begin();
i != circular_link_.end(); i++)
(*i)->Reset();
} else if (type_ == qnode) {
PQNode* last = NULL;
PQNode* current = endmost_children_[0];
while (current) {
current->Reset();
PQNode* next = current->QNextChild(last);
last = current;
current = next;
}
}
full_children_.clear();
partial_children_.clear();
label_ = empty;
mark_ = unmarked;
pertinent_child_count = 0;
pertinent_leaf_count = 0;
pseudochild_ = false;
pseudonode_ = false;
}
int answer = 1;
const int mod = 998244353;
using ll = long long;
void PQNode::Print(string* out) const {
if (type_ == leaf) {
char value_str[10];
sprintf(value_str, "%d", leaf_value_);
*out += value_str;
} else if (type_ == pnode) {
*out += "(";
int cnt = 0;
for (list<PQNode*>::const_iterator i = circular_link_.begin();
i != circular_link_.end(); i++) {
(*i)->Print(out);
cnt++;
answer = (answer * (ll)cnt) % mod;
if (++i != circular_link_.end()) *out += " ";
--i;
}
*out += ")";
} else if (type_ == qnode) {
*out += "[";
PQNode* last = NULL;
PQNode* current = endmost_children_[0];
while (current) {
current->Print(out);
PQNode* next = current->QNextChild(last);
last = current;
current = next;
if (current) *out += " ";
}
answer = (answer * (ll)2) % mod;
*out += "]";
}
}
void PQNode::Identify() const {
cout << "Node: " << this;
cout << " Parent: " << parent_ << endl;
if (type_ == leaf) {
cout << "Type: leaf Value: " << leaf_value_ << endl;
} else {
string value;
Print(&value);
if (type_ == pnode) cout << "Type: pnode Value: " << value << endl;
if (type_ == qnode) cout << "Type: qnode Value: " << value << endl;
}
}
QNodeChildrenIterator::QNodeChildrenIterator(PQNode* parent,
PQNode* begin_side) {
parent_ = parent;
Reset(begin_side);
}
void QNodeChildrenIterator::Reset(PQNode* begin_side) {
current_ = parent_->endmost_children_[0];
if (begin_side) current_ = begin_side;
prev_ = NULL;
next_ = current_->immediate_siblings_[0];
}
PQNode* QNodeChildrenIterator::Current() { return current_; }
void QNodeChildrenIterator::NextPseudoNodeSibling() {
prev_ = current_;
current_ = current_->ImmediateSiblingWithLabel(PQNode::full);
if (!current_)
current_ = current_->ImmediateSiblingWithLabel(PQNode::partial);
}
void QNodeChildrenIterator::Next() {
if (IsDone()) return;
if (prev_ == NULL && current_->ImmediateSiblingCount() == 2) {
NextPseudoNodeSibling();
} else {
prev_ = current_;
current_ = next_;
}
if (current_) {
next_ = current_->immediate_siblings_[0];
if (next_ == prev_) next_ = current_->immediate_siblings_[1];
}
}
bool QNodeChildrenIterator::IsDone() { return current_ == NULL; }
class PQTree {
private:
PQNode* root_;
int block_count_;
int blocked_nodes_;
int off_the_top_;
list<set<int>> reductions_;
map<int, PQNode*> leaf_address_;
PQNode* pseudonode_;
bool invalid_;
int UnblockSiblings(PQNode* sibling);
bool TemplateL1(PQNode* candidate_node);
bool TemplateQ1(PQNode* candidate_node);
bool TemplateQ2(PQNode* candidate_node);
bool TemplateQ3(PQNode* candidate_node);
bool TemplateP1(PQNode* candidate_node, bool is_reduction_root);
bool TemplateP2(PQNode* candidate_node);
bool TemplateP3(PQNode* candidate_node);
bool TemplateP4(PQNode* candidate_node);
bool TemplateP5(PQNode* candidate_node);
bool TemplateP6(PQNode* candidate_node);
bool Bubble(set<int> S);
bool ReduceStep(set<int> S);
public:
PQTree(set<int> S);
PQTree(const PQTree& to_copy);
~PQTree();
PQNode* Root();
string Print() const;
void CleanPseudo();
bool SafeReduce(set<int>);
bool SafeReduceAll(list<set<int>>);
bool Reduce(set<int> S);
bool ReduceAll(list<set<int>> L);
list<int> Frontier();
PQTree& operator=(const PQTree& to_copy);
void CopyFrom(const PQTree& to_copy);
list<int> ReducedFrontier();
list<set<int>> GetReductions();
set<int> GetContained();
};
PQTree::PQTree(const PQTree& to_copy) { CopyFrom(to_copy); }
PQTree& PQTree::operator=(const PQTree& to_copy) {
if (&to_copy != this) CopyFrom(to_copy);
return *this;
}
void PQTree::CopyFrom(const PQTree& to_copy) {
root_ = new PQNode(*to_copy.root_);
block_count_ = to_copy.block_count_;
blocked_nodes_ = to_copy.blocked_nodes_;
invalid_ = to_copy.invalid_;
off_the_top_ = to_copy.off_the_top_;
pseudonode_ = NULL;
reductions_ = to_copy.reductions_;
leaf_address_.clear();
root_->FindLeaves(leaf_address_);
}
int PQTree::UnblockSiblings(PQNode* candidate_node) {
assert(candidate_node->mark_ == PQNode::unblocked);
int unblocked_count = 0;
for (int i = 0; i < 2 && candidate_node->immediate_siblings_[i]; ++i) {
PQNode* sibling = candidate_node->immediate_siblings_[i];
if (sibling->mark_ == PQNode::blocked) {
sibling->parent_ = candidate_node->parent_;
sibling->mark_ = PQNode::unblocked;
unblocked_count++;
unblocked_count += UnblockSiblings(sibling);
}
}
return unblocked_count;
}
bool PQTree::TemplateL1(PQNode* candidate_node) {
if (candidate_node->type_ != PQNode::leaf) return false;
candidate_node->LabelAsFull();
return true;
}
bool PQTree::TemplateQ1(PQNode* candidate_node) {
if (candidate_node->type_ != PQNode::qnode) return false;
for (QNodeChildrenIterator it(candidate_node); !it.IsDone(); it.Next()) {
if (it.Current()->label_ != PQNode::full) return false;
}
candidate_node->LabelAsFull();
return true;
}
bool PQTree::TemplateQ2(PQNode* candidate_node) {
if (candidate_node->type_ != PQNode::qnode || candidate_node->pseudonode_ ||
candidate_node->partial_children_.size() > 1 ||
!candidate_node->ConsecutiveFullPartialChildren())
return false;
bool has_partial = candidate_node->partial_children_.size() > 0;
bool has_full = candidate_node->full_children_.size() > 0;
if (has_full && !candidate_node->EndmostChildWithLabel(PQNode::full))
return false;
if (!has_full && !candidate_node->EndmostChildWithLabel(PQNode::partial))
return false;
if (has_partial) {
PQNode* to_merge = *candidate_node->partial_children_.begin();
for (int i = 0; i < 2; ++i) {
PQNode* child = to_merge->endmost_children_[i];
PQNode* sibling = to_merge->ImmediateSiblingWithLabel(child->label_);
if (sibling) {
sibling->ReplaceImmediateSibling(to_merge, child);
} else {
candidate_node->ReplaceEndmostChild(to_merge, child);
child->parent_ = candidate_node;
}
}
to_merge->ForgetChildren();
delete to_merge;
}
candidate_node->label_ = PQNode::partial;
if (candidate_node->parent_)
candidate_node->parent_->partial_children_.insert(candidate_node);
return true;
}
bool PQTree::TemplateQ3(PQNode* candidate_node) {
if (candidate_node->type_ != PQNode::qnode ||
candidate_node->partial_children_.size() > 2 ||
!candidate_node->ConsecutiveFullPartialChildren())
return false;
for (set<PQNode*>::iterator j = candidate_node->partial_children_.begin();
j != candidate_node->partial_children_.end(); j++) {
PQNode* to_merge = *j;
for (int i = 0; i < 2; ++i) {
PQNode* sibling = to_merge->immediate_siblings_[i];
if (sibling) {
PQNode* child = to_merge->EndmostChildWithLabel(sibling->label_);
if (!child) child = to_merge->EndmostChildWithLabel(PQNode::full);
sibling->ReplaceImmediateSibling(to_merge, child);
} else {
PQNode* empty_child = to_merge->EndmostChildWithLabel(PQNode::empty);
empty_child->parent_ = candidate_node;
candidate_node->ReplaceEndmostChild(to_merge, empty_child);
}
}
to_merge->ForgetChildren();
delete to_merge;
}
return true;
}
bool PQTree::TemplateP1(PQNode* candidate_node, bool is_reduction_root) {
if (candidate_node->type_ != PQNode::pnode ||
candidate_node->full_children_.size() != candidate_node->ChildCount())
return false;
candidate_node->label_ = PQNode::full;
if (!is_reduction_root)
candidate_node->parent_->full_children_.insert(candidate_node);
return true;
}
bool PQTree::TemplateP2(PQNode* candidate_node) {
if (candidate_node->type_ != PQNode::pnode ||
!candidate_node->partial_children_.empty())
return false;
if (candidate_node->full_children_.size() >= 2) {
PQNode* new_pnode = new PQNode;
new_pnode->type_ = PQNode::pnode;
new_pnode->parent_ = candidate_node;
candidate_node->MoveFullChildren(new_pnode);
candidate_node->circular_link_.push_back(new_pnode);
}
candidate_node->label_ = PQNode::partial;
return true;
}
bool PQTree::TemplateP3(PQNode* candidate_node) {
if (candidate_node->type_ != PQNode::pnode ||
!candidate_node->partial_children_.empty())
return false;
PQNode* new_qnode = new PQNode;
new_qnode->type_ = PQNode::qnode;
new_qnode->label_ = PQNode::partial;
candidate_node->parent_->ReplacePartialChild(candidate_node, new_qnode);
PQNode* full_child;
if (candidate_node->full_children_.size() == 1) {
full_child = *candidate_node->full_children_.begin();
candidate_node->circular_link_.remove(full_child);
} else {
full_child = new PQNode;
full_child->type_ = PQNode::pnode;
full_child->label_ = PQNode::full;
candidate_node->MoveFullChildren(full_child);
}
full_child->parent_ = new_qnode;
full_child->label_ = PQNode::full;
new_qnode->endmost_children_[0] = full_child;
new_qnode->full_children_.insert(full_child);
PQNode* empty_child;
if (candidate_node->circular_link_.size() == 1) {
empty_child = *candidate_node->circular_link_.begin();
candidate_node->circular_link_.clear();
delete candidate_node;
} else {
empty_child = candidate_node;
}
empty_child->parent_ = new_qnode;
empty_child->label_ = PQNode::empty;
new_qnode->endmost_children_[1] = empty_child;
empty_child->immediate_siblings_[0] = full_child;
full_child->immediate_siblings_[0] = empty_child;
return true;
}
bool PQTree::TemplateP4(PQNode* candidate_node) {
if (candidate_node->type_ != PQNode::pnode ||
candidate_node->partial_children_.size() != 1)
return false;
PQNode* partial_qnode = *candidate_node->partial_children_.begin();
PQNode* empty_child = partial_qnode->EndmostChildWithLabel(PQNode::empty);
PQNode* full_child = partial_qnode->EndmostChildWithLabel(PQNode::full);
if (!empty_child || !full_child) return false;
if (!candidate_node->full_children_.empty()) {
PQNode* full_children_root;
if (candidate_node->full_children_.size() == 1) {
full_children_root = *(candidate_node->full_children_.begin());
candidate_node->circular_link_.remove(full_children_root);
} else {
full_children_root = new PQNode;
full_children_root->type_ = PQNode::pnode;
full_children_root->label_ = PQNode::full;
candidate_node->MoveFullChildren(full_children_root);
}
full_children_root->parent_ = partial_qnode;
partial_qnode->ReplaceEndmostChild(full_child, full_children_root);
partial_qnode->full_children_.insert(full_children_root);
full_child->AddImmediateSibling(full_children_root);
full_children_root->AddImmediateSibling(full_child);
}
if (candidate_node->circular_link_.size() == 1) {
if (candidate_node->Parent()) {
candidate_node->parent_->ReplaceChild(candidate_node, partial_qnode);
} else {
partial_qnode->parent_ = NULL;
if (root_ == candidate_node) {
root_ = partial_qnode;
} else {
for (int i = 0; i < 2; ++i) {
PQNode* sibling = candidate_node->immediate_siblings_[i];
sibling->ReplaceImmediateSibling(candidate_node, partial_qnode);
}
}
}
candidate_node->circular_link_.clear();
delete candidate_node;
}
return true;
}
bool PQTree::TemplateP5(PQNode* candidate_node) {
if (candidate_node->type_ != PQNode::pnode ||
candidate_node->partial_children_.size() != 1)
return false;
PQNode* partial_qnode = *candidate_node->partial_children_.begin();
assert(partial_qnode->type_ == PQNode::qnode);
PQNode* empty_child = partial_qnode->EndmostChildWithLabel(PQNode::empty);
PQNode* full_child = partial_qnode->EndmostChildWithLabel(PQNode::full);
PQNode* empty_sibling = candidate_node->CircularChildWithLabel(PQNode::empty);
if (!empty_child || !full_child) return false;
candidate_node->parent_->ReplaceChild(candidate_node, partial_qnode);
partial_qnode->pertinent_leaf_count = candidate_node->pertinent_leaf_count;
candidate_node->circular_link_.remove(partial_qnode);
if (!candidate_node->full_children_.empty()) {
PQNode* full_children_root;
if (candidate_node->full_children_.size() == 1) {
full_children_root = *candidate_node->full_children_.begin();
candidate_node->circular_link_.remove(full_children_root);
} else {
full_children_root = new PQNode;
full_children_root->type_ = PQNode::pnode;
full_children_root->label_ = PQNode::full;
candidate_node->MoveFullChildren(full_children_root);
}
full_children_root->parent_ = partial_qnode;
full_child->AddImmediateSibling(full_children_root);
full_children_root->AddImmediateSibling(full_child);
partial_qnode->ReplaceEndmostChild(full_child, full_children_root);
}
if (candidate_node->ChildCount()) {
PQNode* empty_children_root;
if (candidate_node->ChildCount() == 1) {
empty_children_root = empty_sibling;
} else {
empty_children_root = candidate_node;
empty_children_root->label_ = PQNode::empty;
empty_children_root->ClearImmediateSiblings();
}
empty_children_root->parent_ = partial_qnode;
empty_child->AddImmediateSibling(empty_children_root);
empty_children_root->AddImmediateSibling(empty_child);
partial_qnode->ReplaceEndmostChild(empty_child, empty_children_root);
}
if (candidate_node->ChildCount() < 2) {
candidate_node->circular_link_.clear();
delete candidate_node;
}
return true;
}
bool PQTree::TemplateP6(PQNode* candidate_node) {
if (candidate_node->type_ != PQNode::pnode ||
candidate_node->partial_children_.size() != 2)
return false;
PQNode* partial_qnode1 = *candidate_node->partial_children_.begin();
PQNode* partial_qnode2 = *(++(candidate_node->partial_children_.begin()));
PQNode* empty_child1 = partial_qnode1->EndmostChildWithLabel(PQNode::empty);
PQNode* full_child1 = partial_qnode1->EndmostChildWithLabel(PQNode::full);
if (!empty_child1 || !full_child1) return false;
PQNode* empty_child2 = partial_qnode2->EndmostChildWithLabel(PQNode::empty);
PQNode* full_child2 = partial_qnode2->EndmostChildWithLabel(PQNode::full);
if (!empty_child2 || !full_child2) return false;
if (!candidate_node->full_children_.empty()) {
PQNode* full_children_root = NULL;
if (candidate_node->full_children_.size() == 1) {
full_children_root = *candidate_node->full_children_.begin();
candidate_node->circular_link_.remove(full_children_root);
} else {
full_children_root = new PQNode;
full_children_root->type_ = PQNode::pnode;
full_children_root->label_ = PQNode::full;
candidate_node->MoveFullChildren(full_children_root);
}
full_children_root->parent_ = partial_qnode1;
full_child2->parent_ = partial_qnode1;
full_child1->AddImmediateSibling(full_children_root);
full_child2->AddImmediateSibling(full_children_root);
full_children_root->AddImmediateSibling(full_child1);
full_children_root->AddImmediateSibling(full_child2);
} else {
full_child1->AddImmediateSibling(full_child2);
full_child2->AddImmediateSibling(full_child1);
}
partial_qnode1->ReplaceEndmostChild(full_child1, empty_child2);
empty_child2->parent_ = partial_qnode1;
candidate_node->circular_link_.remove(partial_qnode2);
partial_qnode2->ForgetChildren();
delete partial_qnode2;
if (candidate_node->circular_link_.size() == 1) {
partial_qnode1->parent_ = candidate_node->parent_;
partial_qnode1->pertinent_leaf_count = candidate_node->pertinent_leaf_count;
partial_qnode1->label_ = PQNode::partial;
if (candidate_node->parent_) {
candidate_node->parent_->partial_children_.insert(partial_qnode1);
if (candidate_node->parent_->type_ == PQNode::pnode) {
candidate_node->parent_->ReplaceCircularLink(candidate_node,
partial_qnode1);
} else {
for (int i = 0; i < 2 && candidate_node->immediate_siblings_[i]; ++i) {
PQNode* sibling = candidate_node->immediate_siblings_[i];
sibling->ReplaceImmediateSibling(candidate_node, partial_qnode1);
}
candidate_node->parent_->ReplaceEndmostChild(candidate_node,
partial_qnode1);
}
} else {
root_ = partial_qnode1;
partial_qnode1->parent_ = NULL;
candidate_node->circular_link_.clear();
delete candidate_node;
}
}
return true;
}
bool PQTree::Bubble(set<int> reduction_set) {
queue<PQNode*> q;
block_count_ = 0;
blocked_nodes_ = 0;
off_the_top_ = 0;
set<PQNode*> blocked_list;
for (set<int>::iterator i = reduction_set.begin(); i != reduction_set.end();
++i) {
PQNode* temp = leaf_address_[*i];
assert(temp);
q.push(temp);
}
while (q.size() + block_count_ + off_the_top_ > 1) {
if (q.empty()) return false;
PQNode* candidate_node = q.front();
q.pop();
candidate_node->mark_ = PQNode::blocked;
set<PQNode*> unblocked_siblings;
set<PQNode*> blocked_siblings;
for (int i = 0; i < 2 && candidate_node->immediate_siblings_[i]; ++i) {
PQNode* sibling = candidate_node->immediate_siblings_[i];
if (sibling->mark_ == PQNode::blocked) {
blocked_siblings.insert(sibling);
} else if (sibling->mark_ == PQNode::unblocked) {
unblocked_siblings.insert(sibling);
}
}
if (!unblocked_siblings.empty()) {
candidate_node->parent_ = (*unblocked_siblings.begin())->parent_;
candidate_node->mark_ = PQNode::unblocked;
} else if (candidate_node->ImmediateSiblingCount() < 2) {
candidate_node->mark_ = PQNode::unblocked;
}
if (candidate_node->mark_ == PQNode::unblocked) {
if (!blocked_siblings.empty()) {
int list_size = UnblockSiblings(candidate_node);
candidate_node->parent_->pertinent_child_count += list_size;
blocked_nodes_ -= list_size;
}
if (!candidate_node->parent_) {
off_the_top_ = 1;
} else {
candidate_node->parent_->pertinent_child_count++;
if (candidate_node->parent_->mark_ == PQNode::unmarked) {
q.push(candidate_node->parent_);
candidate_node->parent_->mark_ = PQNode::queued;
}
}
block_count_ -= blocked_siblings.size();
} else {
block_count_ += 1 - blocked_siblings.size();
blocked_nodes_ += 1;
blocked_list.insert(candidate_node);
}
}
if (block_count_ > 1 || (off_the_top_ == 1 && block_count_ != 0))
return false;
if (block_count_ == 1 && blocked_nodes_ > 1) {
pseudonode_ = new PQNode;
pseudonode_->type_ = PQNode::qnode;
pseudonode_->pseudonode_ = true;
pseudonode_->pertinent_child_count = 0;
int side = 0;
for (set<PQNode*>::iterator i = blocked_list.begin();
i != blocked_list.end(); ++i) {
PQNode* blocked = *i;
if (blocked->mark_ == PQNode::blocked) {
pseudonode_->pertinent_child_count++;
pseudonode_->pertinent_leaf_count += blocked->pertinent_leaf_count;
for (int j = 0; j < 2; ++j) {
PQNode* sibling = blocked->immediate_siblings_[j];
if (sibling->mark_ == PQNode::unmarked) {
blocked->RemoveImmediateSibling(sibling);
sibling->RemoveImmediateSibling(blocked);
pseudonode_->pseudo_neighbors_[side] = sibling;
pseudonode_->endmost_children_[side++] = blocked;
break;
}
}
blocked->parent_ = pseudonode_;
blocked->pseudochild_ = true;
}
}
q.push(pseudonode_);
}
return true;
}
bool PQTree::ReduceStep(set<int> reduction_set) {
queue<PQNode*> q;
for (set<int>::iterator i = reduction_set.begin(); i != reduction_set.end();
i++) {
PQNode* candidate_node = leaf_address_[*i];
if (candidate_node == NULL) return false;
candidate_node->pertinent_leaf_count = 1;
q.push(candidate_node);
}
while (!q.empty()) {
PQNode* candidate_node = q.front();
q.pop();
if (candidate_node->pertinent_leaf_count < reduction_set.size()) {
PQNode* candidate_parent = candidate_node->parent_;
candidate_parent->pertinent_leaf_count +=
candidate_node->pertinent_leaf_count;
candidate_parent->pertinent_child_count--;
if (candidate_parent->pertinent_child_count == 0)
q.push(candidate_parent);
if (TemplateL1(candidate_node)) {
} else if (TemplateP1(candidate_node, false)) {
} else if (TemplateP3(candidate_node)) {
} else if (TemplateP5(candidate_node)) {
} else if (TemplateQ1(candidate_node)) {
} else if (TemplateQ2(candidate_node)) {
} else {
CleanPseudo();
return false;
}
} else {
if (TemplateL1(candidate_node)) {
} else if (TemplateP1(candidate_node, true)) {
} else if (TemplateP2(candidate_node)) {
} else if (TemplateP4(candidate_node)) {
} else if (TemplateP6(candidate_node)) {
} else if (TemplateQ1(candidate_node)) {
} else if (TemplateQ2(candidate_node)) {
} else if (TemplateQ3(candidate_node)) {
} else {
CleanPseudo();
return false;
}
}
}
CleanPseudo();
return true;
}
void PQTree::CleanPseudo() {
if (pseudonode_) {
PQNode* last = NULL;
PQNode* current = pseudonode_->endmost_children_[0];
while (current) {
current->parent_ = NULL;
PQNode* next = current->QNextChild(last);
last = current;
current = next;
}
for (int i = 0; i < 2; i++) {
pseudonode_->endmost_children_[i]->AddImmediateSibling(
pseudonode_->pseudo_neighbors_[i]);
pseudonode_->pseudo_neighbors_[i]->AddImmediateSibling(
pseudonode_->endmost_children_[i]);
}
pseudonode_->ForgetChildren();
delete pseudonode_;
pseudonode_ = NULL;
}
}
PQTree::PQTree(set<int> reduction_set) {
root_ = new PQNode;
root_->type_ = PQNode::pnode;
invalid_ = false;
pseudonode_ = NULL;
block_count_ = 0;
blocked_nodes_ = 0;
off_the_top_ = 0;
for (set<int>::iterator i = reduction_set.begin(); i != reduction_set.end();
i++) {
PQNode* new_node;
new_node = new PQNode(*i);
leaf_address_[*i] = new_node;
new_node->parent_ = root_;
new_node->type_ = PQNode::leaf;
root_->circular_link_.push_back(new_node);
}
}
PQNode* PQTree::Root() { return root_; }
string PQTree::Print() const {
string out;
root_->Print(&out);
return out;
}
bool PQTree::SafeReduce(set<int> S) {
PQTree toCopy(*this);
if (!Reduce(S)) {
root_ = new PQNode(*toCopy.root_);
block_count_ = toCopy.block_count_;
blocked_nodes_ = toCopy.blocked_nodes_;
off_the_top_ = toCopy.off_the_top_;
invalid_ = toCopy.invalid_;
leaf_address_.clear();
root_->FindLeaves(leaf_address_);
return false;
}
return true;
}
bool PQTree::SafeReduceAll(list<set<int>> L) {
PQTree toCopy(*this);
if (!ReduceAll(L)) {
root_ = new PQNode(*toCopy.root_);
block_count_ = toCopy.block_count_;
blocked_nodes_ = toCopy.blocked_nodes_;
off_the_top_ = toCopy.off_the_top_;
invalid_ = toCopy.invalid_;
leaf_address_.clear();
root_->FindLeaves(leaf_address_);
return false;
}
return true;
}
bool PQTree::Reduce(set<int> reduction_set) {
if (reduction_set.size() < 2) {
reductions_.push_back(reduction_set);
return true;
}
if (invalid_) return false;
if (!Bubble(reduction_set)) {
invalid_ = true;
return false;
}
if (!ReduceStep(reduction_set)) {
invalid_ = true;
return false;
}
root_->Reset();
reductions_.push_back(reduction_set);
return true;
}
bool PQTree::ReduceAll(list<set<int>> L) {
for (list<set<int>>::iterator S = L.begin(); S != L.end(); S++) {
if (!Reduce(*S)) return false;
}
return true;
}
list<int> PQTree::Frontier() {
list<int> out;
root_->FindFrontier(out);
return out;
}
list<set<int>> PQTree::GetReductions() { return reductions_; }
PQTree::~PQTree() { delete root_; }
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
vector<vector<int>> ddd;
for (size_t i = 0; i < m; ++i) {
vector<int> g;
int k;
cin >> k;
g.resize(k);
for (int& j : g) cin >> j;
ddd.push_back(g);
}
vector<int> o(n);
iota(o.begin(), o.end(), 1);
set<int> ST{o.begin(), o.end()};
PQTree tree(ST);
for (auto g : ddd) {
if (!tree.Reduce({g.begin(), g.end()})) {
cout << 0;
return 0;
}
}
answer = 1;
tree.Print();
cout << answer;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
long long mod = 1000000007LL;
long long mod2 = 998244353LL;
long long t, l, r;
long long dp[5000005];
long long prm[5000005];
long long pw[5000005];
long long dfs(int x) {
if (dp[x] >= 0) return dp[x];
if (x == 1) return dp[x] = 0LL;
dp[x] = (long long)x * (long long)(x - 1) / 2LL;
dp[x] %= mod;
long long i;
if (x > 2 && x % 2 == 0) {
return dp[x] = (dfs(x / 2) + (2 * (2 - 1) / 2) % mod * (x / 2) % mod) % mod;
}
int d = prm[x];
if (d < 0) return dp[x];
return dp[x] = (dfs(x / d) + (d * (d - 1) / 2) % mod * (x / d) % mod) % mod;
}
long long getpw(long long x, long long y) {
long long res = 1LL;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod;
y /= 2;
}
return res;
}
int main() {
cin >> t >> l >> r;
memset(prm, -1, sizeof(prm));
for (int i = 2; i * i <= r; ++i) {
if (prm[i] < 0) {
for (int j = 2 * i; j <= r; j += i) {
if (prm[j] < 0) prm[j] = i;
}
}
}
pw[0] = 1LL;
for (int i = 1; i <= r; ++i) {
pw[i] = pw[i - 1] * (long long)t % mod;
}
memset(dp, -1, sizeof(dp));
long long res = 0LL;
for (int i = 2; i <= r; ++i) {
if (dp[i] < 0) {
dfs(i);
if (i >= l && i <= r) {
long long tmp = dp[i] * pw[i - l] % mod;
res = (res + tmp) % mod;
}
}
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxint = -1u >> 1;
template <class T>
bool get_max(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
template <class T>
bool get_min(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
long long n;
long long ans = 0;
long long coin[40];
int main() {
coin[1] = 1;
for (int i = 2; i < 40; ++i) {
coin[i] = coin[i - 1] * 3;
}
cin >> n;
if (n % 3 == 0) {
for (int i = 2; i < 40; ++i) {
if (n % coin[i] != 0) {
ans = n / coin[i] + 1;
break;
}
}
} else {
ans = n / 3 + 1;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void init() {
std::ios::sync_with_stdio(false);
cin.tie();
}
long long a, b;
long long x[105], y[105], xx, yy;
string op;
int check(int nowx, int nowy) {
long long disx = a - nowx, disy = b - nowy;
if (xx == 0 && yy == 0) {
if (disx == 0 && disy == 0)
return true;
else
return false;
} else if (xx == 0 && yy != 0) {
if (disy % yy == 0) {
if (disx == 0 && disy / yy >= 0)
return true;
else
return false;
} else
return false;
} else if (xx != 0 && yy == 0) {
if (disx % xx == 0) {
if (disy == 0 && disx / xx >= 0)
return true;
else
return false;
} else
return false;
} else {
if (disx % xx == 0 && disy % yy == 0) {
if (disx / xx >= 0 && disy / yy >= 0 && disx / xx == disy / yy)
return true;
else
return false;
} else
return false;
}
}
int main() {
init();
cin >> a >> b >> op;
x[0] = y[0] = 0;
int pos = 1;
for (int i = 0; i < op.length(); ++i, ++pos) {
if (op[i] == 'U') {
x[pos] = x[pos - 1];
y[pos] = y[pos - 1] + 1;
} else if (op[i] == 'D') {
x[pos] = x[pos - 1];
y[pos] = y[pos - 1] - 1;
} else if (op[i] == 'L') {
x[pos] = x[pos - 1] - 1;
y[pos] = y[pos - 1];
} else if (op[i] == 'R') {
x[pos] = x[pos - 1] + 1;
y[pos] = y[pos - 1];
}
}
xx = x[pos - 1];
yy = y[pos - 1];
for (int i = 0; i < pos; ++i) {
if (check(x[i], y[i])) {
cout << "Yes";
return 0;
}
}
cout << "No";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string myName;
cin >> myName;
int n;
cin >> n;
map<string, int> factor;
string name1, action, temp, name2;
for (int i = 0; i < n; i++) {
cin >> name1;
cin >> action;
if (action == "posted" || action == "commented") cin >> temp;
cin >> name2;
name2 = name2.substr(0, name2.length() - 2);
cin >> temp;
int val = 5;
if (action == "posted")
val = 15;
else if (action == "commented")
val = 10;
if (name1 == myName)
factor[name2] += val;
else
factor[name1];
if (name2 == myName)
factor[name1] += val;
else
factor[name2];
}
vector<pair<int, string> > ret;
for (map<string, int>::iterator it = factor.begin(); it != factor.end(); it++)
ret.push_back(make_pair(-it->second, it->first));
sort(ret.begin(), ret.end());
int m = ret.size();
for (int i = 0; i < m; i++) cout << ret[i].second << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const int N = 1e5 + 5;
struct PT {
double x, y;
PT(double _x = 0, double _y = 0) : x(_x), y(_y) {}
PT operator-(const PT& b) const { return PT(x - b.x, y - b.y); }
PT operator+(const PT& b) const { return PT(x + b.x, y + b.y); }
PT operator*(const double& k) const { return PT(x * k, y * k); }
PT operator/(const double& k) const { return PT(x / k, y / k); }
};
double ax[N], ay[N], bx[N], by[N];
double dist(PT a, PT b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
double go(PT stA, PT stB, PT vetorA, PT vetorB, double L, double R) {
double l = L, r = R;
for (int i = 0; i < 50; ++i) {
double m1 = l + (r - l) / 3.0;
double m2 = r - (r - l) / 3.0;
PT onA = stA + (vetorA * m1);
PT onB = stB + (vetorB * m1);
PT tonA = stA + (vetorA * m2);
PT tonB = stB + (vetorB * m2);
double d1 = dist(onA, onB);
double d2 = dist(tonA, tonB);
if (d1 > d2) {
l = m1;
} else {
r = m2;
}
}
return l;
}
double go2(PT stA, PT stB, PT vetorA, PT vetorB, double L, double R) {
double l = L, r = R;
for (int i = 0; i < 50; ++i) {
double m1 = l + (r - l) / 3.0;
double m2 = r - (r - l) / 3.0;
PT onA = stA + (vetorA * m1);
PT onB = stB + (vetorB * m1);
PT tonA = stA + (vetorA * m2);
PT tonB = stB + (vetorB * m2);
double d1 = dist(onA, onB);
double d2 = dist(tonA, tonB);
if (d1 < d2) {
l = m1;
} else {
r = m2;
}
}
return l;
}
int main() {
int n;
scanf("%d", &n);
double d1, d2;
scanf("%lf %lf", &d1, &d2);
for (int i = 0; i < n; ++i) {
scanf("%lf %lf %lf %lf", &ax[i], &ay[i], &bx[i], &by[i]);
}
double dmax;
bool talked = 0;
int ans = 0;
for (int i = 0; i < n - 1; ++i) {
PT a1 = PT(ax[i], ay[i]);
PT b1 = PT(bx[i], by[i]);
PT a2 = PT(ax[i + 1], ay[i + 1]);
PT b2 = PT(bx[i + 1], by[i + 1]);
PT vetorA = a2 - a1;
PT vetorB = b2 - b1;
double t = go(a1, b1, vetorA, vetorB, 0, 1.0);
double tm = go2(a1, b1, vetorA, vetorB, 0, t);
PT onA = a1 + vetorA * t;
PT onB = b1 + vetorB * t;
PT tonA = a1 + vetorA * tm;
PT tonB = b1 + vetorB * tm;
double mn = dist(onA, onB);
double mx = dist(tonA, tonB);
bool yes = 0;
if (talked) {
dmax = max(dmax, mx);
}
if (mn < d1 || (abs(mn - d1) < EPS)) {
if (!talked) {
talked = 1;
dmax = 0;
++ans;
yes = 1;
} else {
if (dmax > d2) {
++ans;
dmax = 0;
yes = 1;
}
}
}
if (yes) {
double td = go2(a1, b1, vetorA, vetorB, t, 1.0);
onA = a1 + vetorA * td;
onB = b1 + vetorB * td;
dmax = max(dmax, dist(onA, onB));
}
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
const long long INFll = 1ll * INF * INF;
const int MOD = 1000000007;
const int MAXN = 100005;
int n, m, x[1005][1005], a1[1005][1005], a2[1005][1005], b1[1005][1005],
b2[1005][1005];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> x[i][j];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
a1[i][j] = max(a1[i - 1][j], a1[i][j - 1]) + x[i][j];
for (int i = n; i >= 1; --i)
for (int j = 1; j <= m; ++j)
a2[i][j] = max(a2[i + 1][j], a2[i][j - 1]) + x[i][j];
for (int i = n; i >= 1; --i)
for (int j = m; j >= 1; --j)
b1[i][j] = max(b1[i + 1][j], b1[i][j + 1]) + x[i][j];
for (int i = 1; i <= n; ++i)
for (int j = m; j >= 1; --j)
b2[i][j] = max(b2[i - 1][j], b2[i][j + 1]) + x[i][j];
int ans = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
if (i == 1 || i == n || j == m || j == 1) continue;
ans = max(ans,
max(a1[i - 1][j] + a2[i][j - 1] + b1[i + 1][j] + b2[i][j + 1],
a1[i][j - 1] + a2[i + 1][j] + b1[i][j + 1] + b2[i - 1][j]));
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 1e5 + 1;
int N, maxA, maxB, K, Q, A[MAXN];
int BIT1[MAXN], BIT2[MAXN];
void BIT_U(int ii, int val) {
for (int i = ii + 1; i <= N; i += i & -i) BIT1[i] -= min(A[ii], maxB);
for (int i = N - ii; i <= N; i += i & -i) BIT2[i] -= min(A[ii], maxA);
A[ii] += val;
for (int i = ii + 1; i <= N; i += i & -i) BIT1[i] += min(A[ii], maxB);
for (int i = N - ii; i <= N; i += i & -i) BIT2[i] += min(A[ii], maxA);
}
int BIT_Q(int ii) {
int ret = 0;
for (int i = ii; i; i -= i & -i) ret += BIT1[i];
for (int i = N - ii - K; i; i -= i & -i) ret += BIT2[i];
return ret;
}
int main() {
scanf("%d", &N), scanf("%d", &K);
scanf("%d", &maxA), scanf("%d", &maxB);
scanf("%d", &Q);
memset(A, 0, sizeof(A));
memset(BIT1, 0, sizeof(BIT1));
memset(BIT2, 0, sizeof(BIT2));
for (int q = 0; q < (int)Q; q++) {
int t;
scanf("%d", &t);
if (t == 1) {
int d, a;
scanf("%d", &d), scanf("%d", &a);
BIT_U(d - 1, a);
} else {
int p;
scanf("%d", &p);
printf("%d\n", BIT_Q(p - 1));
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> pref[200010], suf[200010];
string s;
int X, Y;
bool check(pair<int, int> A, pair<int, int> B, int t) {
int d = abs(X - (A.first + B.first)) + abs(Y - (A.second + B.second));
if (t >= d && t % 2 == d % 2) return true;
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t >> s;
cin >> X >> Y;
for (int i = 0; i < s.size(); i++) {
if (i) pref[i] = pref[i - 1];
if (s[i] == 'U')
pref[i].second++;
else if (s[i] == 'D')
pref[i].second--;
else if (s[i] == 'R')
pref[i].first++;
else
pref[i].first--;
}
suf[0] = pref[t - 1];
for (int i = t - 1; i > 0; i--) {
suf[i] = {pref[t - 1].first - pref[i - 1].first,
pref[t - 1].second - pref[i - 1].second};
}
int ans = t, n = t;
if (!check({0, 0}, {0, 0}, t)) {
cout << "-1\n";
return 0;
}
for (int i = 0; i < t - 1; i++) {
for (int flag = 0; flag <= 1; flag++) {
int l = 0, r = n;
while (r - l > 1) {
int mid = (r + l) >> 1;
int p = n - flag - 2 * mid;
if (p <= i) {
r = mid;
continue;
}
if (check(pref[i], suf[p], p - i - 1)) {
l = mid;
} else
r = mid;
}
int p = n - flag - 2 * l;
if (p > i && p <= n && check(pref[i], suf[p], p - i - 1))
ans = min(ans, p - i - 1);
}
}
for (int i = 0; i < t; i++) {
if (check(pref[i], {0, 0}, t - i - 1)) ans = min(ans, t - i - 1);
}
for (int i = t - 1; i >= 0; i--) {
if (check(suf[i], {0, 0}, i)) ans = min(ans, i);
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define int long long
#define pii pair<int, int>
// #define debug
using namespace std;
struct Edge {
int to, nxt, idx;
};
const int MAX_N = 2e5 + 7;
Edge e[MAX_N << 1];
map<pii, int> mp;
vector<pii> ans;
int head[MAX_N << 1], dfn[MAX_N << 1];
bool vis[MAX_N];
int n, tot, cnt, ord;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
void add(int u, int v, int idx) {
e[++cnt].to = v; e[cnt].nxt = head[u]; head[u] = cnt; e[cnt].idx = idx;
}
int dfs(int u, int fa) {
dfn[u] = ++ord;
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (!dfn[v]) {
int res = dfs(v, u);
if (res) {
ans.push_back(pii(res, e[i].idx));
vis[res] = vis[e[i].idx] = true;
}
}
}
int lst = 0;
for (int i = head[u]; i; i = e[i].nxt) {
if (vis[e[i].idx] || e[i].to == fa) continue;
if (lst) {ans.push_back(pii(lst, e[i].idx));vis[lst] = vis[e[i].idx] = true;lst = 0;}
else lst = e[i].idx;
}
return lst;
}
signed main() {
#ifndef debug
scanf("%lld", &n);
for (int i = 1; i <= n; ++i) {
int a, b, c, d;
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
int up = c * b, dn = d * (a + b);
int _gcd = gcd(up, dn);
pii u1(up / _gcd, dn / _gcd);
up = (c + d) * b, dn = a * d;
_gcd = gcd(up, dn);
pii u2(up / _gcd, dn / _gcd);
if (!mp.count(u1)) {
++tot;
mp[u1] = tot;
}
if (!mp.count(u2)) {
++tot;
mp[u2] = tot;
}
int u = mp[u1], v = mp[u2];
add(u, v, i), add(v, u, i);
}
#endif
#ifdef debug
int m;
scanf("%lld%lld", &tot, &m);
for (int i = 1; i <= m; ++i) {
int u, v, id;
scanf("%lld%lld%lld", &u, &v, &id);
add(u, v, id), add(v, u, id);
}
#endif
for (int i = 1; i <= tot; ++i) {
if (!dfn[i]) dfs(i, 0);
}
#ifdef debug
// dfs(1, 0);
for (int i = 1; i <= tot; ++i) {
printf("%lld: %lld\n", i, dfn[i]);
}
#endif
printf("%lld\n", ans.size());
for (auto p : ans) {
printf("%lld %lld\n", p.first, p.second);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 100;
const int mod = 1e9 + 7;
const int inf = 1e9;
struct node {
int mx, sl, sr, ml, mr, sz;
node() {
sz = 0;
return;
}
};
int n, q;
node seg[2][maxn * 4];
node ndnl = node();
bool lz[maxn * 4];
string st;
node mrg(node l, node r) {
node a;
if (l.sz == 0) return r;
if (r.sz == 0) return l;
a.sz = l.sz + r.sz;
a.mx = max(max(l.mx, r.mx), max(l.mr + r.sl, l.sr + r.ml));
a.sr = r.sr;
if (r.sr == r.sz) a.sr += l.sr;
a.sl = l.sl;
if (l.sl == l.sz) a.sl += r.sl;
a.ml = l.ml;
if (l.ml == l.sz) a.ml += r.sl;
if (l.sr == l.sz) a.ml = max(a.ml, l.sr + r.ml);
a.mr = r.mr;
if (r.mr == r.sz) a.mr += l.sr;
if (r.sl == r.sz) a.mr = max(a.mr, r.sl + l.mr);
return a;
}
void bld(int id, int s, int e) {
if (e - s == 1) {
seg[0][id].sz = 1;
seg[0][id].mx = 1;
seg[0][id].ml = 1;
seg[0][id].mr = 1;
seg[1][id].sz = 1;
seg[1][id].mx = 1;
seg[1][id].ml = 1;
seg[1][id].mr = 1;
if (st[s] == '<') {
seg[0][id].sl = 1;
seg[0][id].sr = 0;
seg[1][id].sl = 0;
seg[1][id].sr = 1;
} else {
seg[1][id].sl = 1;
seg[1][id].sr = 0;
seg[0][id].sl = 0;
seg[0][id].sr = 1;
}
return;
}
int mid = (s + e) / 2;
bld(id * 2, s, mid);
bld(id * 2 + 1, mid, e);
seg[0][id] = mrg(seg[0][id * 2], seg[0][id * 2 + 1]);
seg[1][id] = mrg(seg[1][id * 2], seg[1][id * 2 + 1]);
return;
}
void upd(int id, int s, int e, int l, int r) {
if (r <= s || e <= l) return;
if (l <= s && e <= r) {
swap(seg[0][id], seg[1][id]);
lz[id] = !lz[id];
return;
}
int mid = (s + e) / 2;
if (lz[id]) {
swap(seg[0][id * 2], seg[1][id * 2]);
lz[id * 2] = !lz[id * 2];
swap(seg[0][id * 2 + 1], seg[1][id * 2 + 1]);
lz[id * 2 + 1] = !lz[id * 2 + 1];
lz[id] = 0;
}
upd(id * 2, s, mid, l, r);
upd(id * 2 + 1, mid, e, l, r);
seg[0][id] = mrg(seg[0][id * 2], seg[0][id * 2 + 1]);
seg[1][id] = mrg(seg[1][id * 2], seg[1][id * 2 + 1]);
return;
}
node get(int id, int s, int e, int l, int r) {
if (r <= s || e <= l) {
return ndnl;
}
if (l <= s && e <= r) {
return seg[0][id];
}
int mid = (s + e) / 2;
if (lz[id]) {
swap(seg[0][id * 2], seg[1][id * 2]);
lz[id * 2] = !lz[id * 2];
swap(seg[0][id * 2 + 1], seg[1][id * 2 + 1]);
lz[id * 2 + 1] = !lz[id * 2 + 1];
lz[id] = 0;
}
node p = mrg(get(id * 2, s, mid, l, r), get(id * 2 + 1, mid, e, l, r));
return p;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int l, r;
cin >> n >> q >> st;
bld(1, 0, n);
for (int i = 0; i < q; i++) {
cin >> l >> r;
upd(1, 0, n, l - 1, r);
cout << get(1, 0, n, l - 1, r).mx << '\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int sum1, sum2;
int n, e, d;
int a[1] = {1};
int b[1] = {5};
int main() {
ios::sync_with_stdio(false);
cin >> n >> d >> e;
e = e * 5;
int ans = n;
for (int i = 0; i <= (n / d); i++) {
ans = min(ans, (n - i * d) % e);
}
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 3e5 + 9, inf = 1e14 + 6;
long long n, m, a[30][30], dp[(1 << 21)], N;
string s[30];
long long bit(long long mask) {
for (int i = 0; i < n; i++)
if (mask & (1 << i)) return i;
}
long long solve(long long mask) {
long long &ret = dp[mask];
if (ret != -1) return ret;
if (!mask) return 0;
ret = inf;
long long x = bit(mask);
for (int i = 0; i < m; i++) {
char c = s[x][i];
long long mask1 = mask;
long long mx = 0;
long long cost = 0;
for (int j = 0; j < n; j++) {
if (s[j][i] == c) {
mx = max(mx, a[j][i]);
cost += a[j][i];
if (mask1 & (1 << j)) mask1 ^= (1 << j);
}
}
ret = min(ret, cost - mx + solve(mask1));
ret = min(ret, a[x][i] + solve(mask ^ (1 << x)));
}
return ret;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
N = (1 << n) - 1;
memset(dp, -1, sizeof(dp));
cout << solve(N) << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int tree[800010][2];
int a[200010][2];
int n;
void build(int idx, int l, int r) {
if (l == r) {
tree[idx][0] = a[l][0];
tree[idx][1] = a[l][1];
return;
}
int mid = (l + r) / 2;
build(idx * 2 + 1, l, mid);
build(idx * 2 + 2, mid + 1, r);
tree[idx][0] = max(tree[idx * 2 + 1][0], tree[idx * 2 + 2][0]);
tree[idx][1] = min(tree[idx * 2 + 1][1], tree[idx * 2 + 2][1]);
}
pair<int, int> get(int idx, int l, int r, int A, int B) {
if (l > B || r < A) return {-1e9 - 1, 1e9 + 1};
if (A >= l && B <= r) return {tree[idx][0], tree[idx][1]};
int mid = (A + B) / 2;
pair<int, int> p1, p2;
p1 = get(idx * 2 + 1, l, r, A, mid);
p2 = get(idx * 2 + 2, l, r, mid + 1, B);
return {max(p1.first, p2.first), min(p1.second, p2.second)};
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int j = 0; j < 2; j++)
for (int i = 0; i < n; i++) cin >> a[i][j];
build(0, 0, n - 1);
long long ans = 0;
int l, r, m;
pair<int, int> p;
int idx, idx2;
for (int i = 0; i < n; i++) {
l = i, r = n - 1;
idx = -1;
idx2 = -1;
while (l <= r) {
m = (l + r) / 2;
p = get(0, i, m, 0, n - 1);
if (p.first > p.second)
r = m - 1;
else if (p.first < p.second)
l = m + 1;
else
l = m + 1, idx = m;
}
l = i, r = n - 1;
while (l <= r) {
m = (l + r) / 2;
p = get(0, i, m, 0, n - 1);
if (p.first > p.second)
r = m - 1;
else if (p.first < p.second)
l = m + 1;
else
r = m - 1, idx2 = m;
}
if (idx != -1) ans += idx - idx2 + 1;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string transform(int x, int y, string s) {
string res = "";
int sum = 0;
for (int i = 0; i < s.length(); ++i) {
if (s[i] == '-') continue;
if (s[i] >= '0' && s[i] <= '9') {
sum = sum * x + s[i] - '0';
} else {
sum = sum * x + s[i] - 'A' + 10;
}
}
while (sum) {
char tmp = sum % y;
sum /= y;
if (tmp <= 9) {
tmp += '0';
} else {
tmp = tmp - 10 + 'A';
}
res = tmp + res;
}
if (res.length() == 0) res = "0";
if (s[0] == '-') res = '-' + res;
return res;
}
int b[16] = {1, 0, 0, 0, 1, 0, 1, 0, 2, 1, 1, 2, 0, 1, 0, 0};
int main() {
string s;
while (cin >> s) {
string res = transform(10, 16, s);
int len = res.length();
long long ans = 0;
for (int i = 0; i < len; i++) {
if (res[i] <= '9' && res[i] >= '0')
ans += b[res[i] - '0'];
else
ans += b[res[i] - 'A' + 10];
}
cout << ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e6;
const int N = 100005;
int s, k, v;
vector<int> x, y, z;
void operate(int id, vector<int>& a, int& tt) {
swap(a[id], a[id + 2]);
swap(a[id + 1], a[id + 2]);
if (tt == id) {
tt += 2;
return;
}
if (tt == id + 1) {
tt += 1;
return;
}
if (tt == id + 2) {
tt -= 2;
return;
}
}
int main() {
auto make = [](vector<int>& a, int pos) {
swap(a[pos + 1], a[pos + 2]);
swap(a[pos], a[pos + 1]);
};
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
int sig = 0;
vector<pair<int, int>> res(n), secure(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
res[i] = {a[i], i};
secure[i] = {a[i], i};
}
if (res[0].first == 249) sig = 1;
sort(res.begin(), res.end());
for (int i = 0; i < n; ++i) {
a[res[i].second] = i;
}
int cnt = 0;
if (sig)
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
if (a[i] > a[j] && secure[i].first == secure[j].first)
cout << "WRONG HERE AT i, secure[i]=" << i << " " << secure[i].first
<< "\n";
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
cnt += a[j] < a[i];
}
}
if (cnt & 1) {
for (int i = 0; i < n - 1; ++i) {
if (res[i].first == res[i + 1].first) {
swap(a[res[i].second], a[res[i + 1].second]);
break;
}
}
}
vector<int> ans;
for (int i = 0; i < n - 2; ++i) {
int pos = min_element(a.begin() + i, a.end()) - a.begin();
while (pos > i + 1) {
make(a, pos - 2);
ans.push_back(pos - 2);
pos -= 2;
}
if (pos != i) {
make(a, i);
make(a, i);
ans.push_back(i);
ans.push_back(i);
pos = i;
}
}
for (int i = 0; i < 2; ++i) {
if (is_sorted(a.begin(), a.end())) {
break;
}
make(a, n - 3);
ans.push_back(n - 3);
}
if (!is_sorted(a.begin(), a.end())) {
cout << -1 << endl;
} else {
cout << ans.size() << endl;
for (auto it : ans) cout << it + 1 << " ";
cout << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, a, b;
long long int fn(vector<vector<long long int>> &A, long long int mid) {
long long int i, j;
vector<long long int> mask((1 << m), -1);
for (i = 0; i < n; i++) {
long long int ans = 0;
for (j = 0; j < m; j++) {
if (A[i][j] >= mid) ans = ans ^ (1 << j);
}
mask[ans] = i + 1;
}
if (mask[(1 << m) - 1] != -1) {
a = mask[(1 << m) - 1];
b = mask[(1 << m) - 1];
return (1);
}
for (i = 0; i < (1 << m); i++) {
for (j = 0; j < (1 << m); j++) {
if (mask[i] != -1 && mask[j] != -1 && (i | j) == (1 << m) - 1) {
a = mask[i];
b = mask[j];
return (1);
}
}
}
return (0);
}
int main() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
long long int i, j, low = 1e11, mid, high = -1;
cin >> n >> m;
vector<vector<long long int>> A(n);
vector<long long int> temp(m);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> temp[j];
high = max(high, temp[j]);
low = min(low, temp[j]);
}
A[i] = temp;
}
while (low <= high) {
mid = (low + high) / 2;
if (fn(A, mid) == 1)
low = mid + 1;
else
high = mid - 1;
}
cout << a << " " << b;
return (0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
cout << pow(n - 1, 2) * 2 + 2 * n - 1;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename T>
constexpr int infValue =
std::is_same<T, int>::value ? 2000100007 : 8600000000000000007ll;
template <typename T>
constexpr int maxValue =
std::is_same<T, int>::value ? 1000000007 : 1000000000000000001ll;
const int INF = infValue<int>;
const long long MOD = 1000000007ll;
const double EPS = 1e-6;
const int MAX = maxValue<int>;
int n, m, pd = 1;
int d[300111];
bool p[300111];
vector<pair<int, int>> g[300111];
vector<int> answ;
bool u[300111];
bool dfs(int v) {
u[v] = true;
for (auto to : g[v]) {
if (!u[to.first]) {
if (dfs(to.first)) {
p[v] ^= 1;
answ.push_back(to.second);
}
}
}
if (d[v] == 1 && !p[v]) return true;
if (!d[v] && p[v]) return true;
return false;
}
int main(void) {
scanf("%d %d", &n, &m);
for (register int i = 1; i <= n; ++i) {
scanf("%d", d + i);
if (d[i] < 0) pd = i;
}
int u, v;
for (register int i = 1; i <= m; ++i)
scanf("%d %d", &u, &v), g[u].push_back({v, i}), g[v].push_back({u, i}),
p[v] ^= 1, p[u] ^= 1;
if (dfs(pd))
puts("-1");
else {
printf("%d\n", m - answ.size());
sort(answ.begin(), answ.end());
for (int i = 1, j = 0; i <= m; ++i) {
if (j < answ.size() && answ[j] == i) {
++j;
continue;
}
printf("%d\n", i);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, count = 0, index = 0;
string s;
cin >> n >> s;
if (n == 1) {
cout << "YES" << endl;
cout << s << endl;
return 0;
} else if (s.length() < n) {
cout << "NO" << endl;
return 0;
}
string *ans = new string[n];
int alphabets[26] = {0};
char prev = s[index];
alphabets[prev - 97] = 1;
ans[count++] = prev;
index++;
do {
char prev = s[index];
if (alphabets[prev - 97] == 1) {
ans[count - 1] += s[index];
index++;
} else {
alphabets[prev - 97] = 1;
ans[count] += prev;
index++;
count++;
}
} while (count != n && index != s.length());
if (count < n) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
while (index <= s.length() - 1) ans[n - 1] += s[index++];
for (int i = 0; i < n; i++) {
cout << ans[i] << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 1000000007;
const int MAXN = 200010;
pair<int, int> v[MAXN];
pair<int, int> va[MAXN];
int n, m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> v[i].first >> v[i].second;
if (v[i].first > v[i].second) swap(v[i].first, v[i].second);
}
sort(v, v + m);
for (int i = 1; i < n; i++) {
if ((n % i) == 0) {
for (int j = 0; j < m; j++) {
va[j] = {v[j].first + i, v[j].second + i};
if (va[j].first > n) va[j].first -= n;
if (va[j].second > n) va[j].second -= n;
if (va[j].first > va[j].second) swap(va[j].first, va[j].second);
}
sort(va, va + m);
bool igual = true;
for (int j = 0; j < m; j++) {
if (v[j] != va[j]) {
igual = false;
break;
}
}
if (igual) {
cout << "Yes" << '\n';
return 0;
}
}
}
cout << "No" << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 28;
const long long mod = 1LL;
char arr[210][210];
long long par[210];
bool col[210];
vector<long long> adj[210];
bool dfs(long long u) {
if (col[u]) return false;
long long i, k, v;
k = (int)adj[u].size();
for (i = 0; i < k; i++) {
v = adj[u][i];
if (col[v] == 0) {
col[v] = 1;
if (par[v] == -1 || dfs(par[v])) {
par[v] = u;
return true;
}
}
}
return false;
}
long long BPM(long long n) {
long long i, j, ret = 0;
for (i = 0; i <= 200; i++) par[i] = -1;
for (i = 1; i <= n; i++) {
for (j = 0; j <= 200; j++) col[j] = 0;
if (dfs(i)) ret++;
}
return ret;
}
int main() {
long long n, i, j, k, l;
while (cin >> n) {
for (i = 0; i < n; i++) adj[i].clear(), scanf(" %s", arr[i]);
k = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
if (arr[i][j] == '.') {
adj[i].push_back(j);
k++;
break;
}
}
if (k == n) {
for (i = 0; i < n; i++) printf("%I64d %I64d\n", i + 1, adj[i][0] + 1);
return 0;
}
k = 0;
for (i = 0; i <= n; i++) adj[i].clear();
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++)
if (arr[j][i] == '.') {
adj[i].push_back(j);
k++;
break;
}
}
if (k == n) {
for (i = 0; i < n; i++) printf("%I64d %I64d\n", adj[i][0] + 1, i + 1);
return 0;
}
printf("-1\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<pair<double, int> > PR(n);
for (int i = 0; i < n; i++) {
cin >> PR[i].second >> PR[i].first;
}
sort(PR.begin(), PR.end());
vector<int> S(n);
for (int i = 0; i < n; i++) {
S[i] = PR[i].second;
}
vector<int> O;
for (int i = 0; i < n; i++) {
auto it = upper_bound(O.begin(), O.end(), S[i]);
if (it == O.end()) {
O.push_back(S[i]);
} else {
int index = it - O.begin();
O[index] = S[i];
}
}
cout << n - O.size();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1550;
int in[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", in + i);
map<int, vector<pair<int, int>>> mp;
for (int r = 0; r < n; ++r) {
int s = 0;
for (int l = r; l >= 0; l--) {
s += in[l];
mp[s].emplace_back(l, r);
}
}
int sum = 0, best = 0;
for (const auto& it : mp) {
const auto& v = it.second;
int cur = 0;
int l = -1;
for (auto& x : v) {
if (x.first > l) {
l = x.second;
cur++;
}
}
if (cur > best) {
best = cur;
sum = it.first;
}
}
vector<pair<int, int>> ans;
int l = -1;
for (const auto& it : mp[sum]) {
if (it.first > l) {
l = it.second;
ans.emplace_back(it.first, it.second);
}
}
cout << ans.size() << endl;
for (const auto& x : ans) printf("%d %d\n", x.first + 1, x.second + 1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100002;
int n, k;
int v[N];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main(void) {
scanf("%d%d", &n, &k);
for (int(i) = (0); (i) < (n); ++(i)) {
scanf("%d", &v[i]);
}
for (int(i) = (1); (i) < (n); ++(i)) {
if ((v[i] - v[i - 1]) % k != 0) {
printf("-1\n");
return 0;
}
}
int menor = 1000000009;
for (int(i) = (0); (i) < (n); ++(i)) {
menor = min(menor, v[i]);
}
long long res = 0;
for (int(i) = (0); (i) < (n); ++(i)) {
res += ((long long)(v[i] - menor)) / k;
}
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
long long int a, b, c;
while (q--) {
cin >> a >> b >> c;
cout << (a + b + c) / 2 << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
template <class Class>
void Print(Class instance) {
std::cout << instance << std::endl;
}
void Print() { std::cout << std::endl; }
int main() {
std::ios_base::sync_with_stdio(false);
auto& input = std::cin;
auto& output = std::cout;
size_t n, k;
input >> n >> k;
std::set<int32_t> numbers;
for (size_t index = 0; index < n; ++index) {
int32_t number;
input >> number;
numbers.insert(number);
}
int32_t cur = 0;
for (size_t index = 0; index < k; ++index) {
auto min_it = numbers.begin();
if (min_it == numbers.end()) {
output << 0 << std::endl;
} else {
output << *min_it - cur << std::endl;
cur = *min_it;
numbers.erase(min_it);
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 7;
struct Node {
long long x, y;
} node[maxn];
bool cmp(Node a, Node b) { return a.x < b.x; }
long long n, k;
long long len[maxn];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> node[i].x;
for (int i = 0; i < n; i++) cin >> node[i].y;
sort(node, node + n, cmp);
long long tarl, tarr;
for (tarr = tarl = 0; tarr < n; tarr++) {
while (node[tarl].x < node[tarr].x - k) tarl++;
len[tarr] = tarr - tarl + 1;
}
long long ans = 0, Max = 0;
for (tarr = tarl = 0; tarr < n; tarr++) {
while (node[tarl].x < node[tarr].x - k) {
Max = max(Max, len[tarl]);
tarl++;
}
ans = max(Max + len[tarr], ans);
}
cout << ans << endl;
for (int i = 0; i < n; i++) len[i] = 0;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> lps;
bool cmp(pair<pair<int, int>, int> p1, pair<pair<int, int>, int> p2) {
if (p1.first.second != p2.first.second)
return p1.first.second > p2.first.second;
else
return p1.first.first > p2.first.first;
}
long long gcd(long long a, long long b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long m, b;
cin >> m >> b;
long long lo = 0;
long long hi = b;
while (lo < hi) {
long long l1 = lo + (hi - lo) / 3;
long long l2 = lo + (2 * (hi - lo)) / 3;
if (hi - lo == 2) {
l1 = lo;
l2 = lo + 1;
}
if (hi - lo == 1) l2 = hi;
long long x1 = m * (b - l1);
long long x2 = m * (b - l2);
long long cnt1 = -1, cnt2 = -1;
if (x1 >= 0) {
cnt1 =
((x1 * (x1 + 1)) / 2) * (l1 + 1) + ((l1 * (l1 + 1)) / 2) * (x1 + 1);
}
if (x2 > 0) {
cnt2 =
((x2 * (x2 + 1)) / 2) * (l2 + 1) + ((l2 * (l2 + 1)) / 2) * (x2 + 1);
}
if (cnt1 > cnt2) {
hi = l2 - 1;
} else {
lo = l1 + 1;
}
}
long long x = m * (b - lo);
long long cnt =
((x * (x + 1)) / 2) * (lo + 1) + ((lo * (lo + 1)) / 2) * (x + 1);
cout << cnt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int cont[1009], a[1009], b[10050];
void fun() {
for (int i = 2; i * i <= 1000 + 1; i++) {
if (cont[i] == 0) {
for (int j = 2; i * j <= 1000 + 1; j++) {
cont[i * j] = 1;
}
}
}
}
int main() {
fun();
int n, l = 1;
scanf("%d", &n);
if (n == 1) {
printf("0");
} else {
for (int j = 2; j <= 33; j++) {
for (int i = 2; i <= 10; i++) {
if (cont[j] != 0) {
break;
}
int num = powl(j, i);
if (num > 1000) {
break;
}
b[num] = 1;
}
}
for (int i = 2; i <= n; i++) {
if (cont[i] == 0 || b[i] == 1) {
a[l] = i;
l++;
continue;
}
}
printf("%d\n", l - 1);
for (int i = 1; i < l; i++) {
printf("%d ", a[i]);
}
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.