solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long a, b, num;
long long good(long long test) {
long long temp = (num * a) / b;
long long com = (test * a) / b;
return temp == com;
}
long long binary() {
long long low = 0;
long long high = num;
long long best;
long long mid;
while (low <= high) {
mid = (low + high) >> 1;
if (good(mid)) {
best = mid;
high = mid - 1;
} else
low = mid + 1;
}
return best;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n >> a >> b;
for (int i = 0; i < n; ++i) {
cin >> num;
if (i != 0) cout << ' ';
cout << num - binary();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
const int iinf = INT_MAX;
const long long linf = LONG_MAX;
const int MOD = 1e9 + 7;
inline int read() {
int 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();
return w ? -X : X;
}
void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
int n, s, num, ans, now, rem;
int x[N], y[N];
int main() {
scanf("%d%d", &n, &s);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
if (x[s] != 0) x[s] = 0, now = 1;
for (int i = 1; i <= n; i++)
if (i != s && x[i] == 0) num++;
for (int i = 1; i <= n; i++) y[x[i]]++;
num = n - 1;
rem = 0;
int ans = num;
for (int i = 1; i <= n; i++) {
num -= y[i];
if (y[i] == 0) rem++;
ans = min(ans, max(rem, num));
}
printf("%d\n", ans + now);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void reads(long long &x) {
int fx = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') fx = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = (x << 3) + (x << 1) + (s - '0');
s = getchar();
}
x = x * fx;
}
const int mod = 1e9 + 7;
struct mat {
long long m[109][109];
mat(long long x = 0) {
memset(m, 0, sizeof m);
for (long long i = 1; i < 109; i++) m[i][i] = x;
}
friend mat operator*(mat a, mat b) {
mat cnt;
for (long long i = 1; i < 109; i++)
for (long long j = 1; j < 109; j++)
for (long long k = 1; k < 109; k++)
cnt.m[i][j] = (cnt.m[i][j] + 1LL * a.m[i][k] * b.m[k][j] % mod) % mod;
return cnt;
}
};
int main() {
long long n, m;
cin >> n >> m;
mat a, b;
a.m[1][1] = 1;
for (long long i = 1; i <= m - 1; i++) b.m[i][i + 1] = 1;
b.m[1][1] = 1;
b.m[m][1] = 1;
while (n) {
if (n & 1) a = a * b;
b = b * b;
n >>= 1;
}
cout << a.m[1][1] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t, n, i;
cin >> t;
while (t--) {
cin >> n;
int a[n], b[n], x = 0, y = 0;
bool flag = true;
for (i = 0; i < n; ++i) cin >> a[i];
for (i = 0; i < n; ++i) cin >> b[i];
for (i = 0; i < n; ++i) {
if (b[i] - a[i] > 0 && x > 0)
;
else if (b[i] - a[i] < 0 && y > 0)
;
else if (b[i] == a[i])
;
else {
flag = false;
break;
}
if (a[i] == 1) ++x;
if (a[i] == -1) ++y;
}
if (flag)
cout << "YES\n";
else {
cout << "NO\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long a[100005];
long long p[300005], q[300005], r[300005];
long long t[300005], dp[300005];
long long ninv, minv;
long long modpow(long long a, long long n) {
if (n == 0) return 1;
if (n % 2) {
return ((a % 998244353) * (modpow(a, n - 1) % 998244353)) % 998244353;
} else {
return modpow((a * a) % 998244353, n / 2) % 998244353;
}
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], m += a[i];
ninv = modpow(n - 1, 998244353 - 2), minv = modpow(m, 998244353 - 2);
for (int i = 0; i < m; i++) {
p[i] = i * minv % 998244353;
r[i] = (m - i) * minv % 998244353 * ninv % 998244353;
q[i] = r[i] * (n - 2) % 998244353;
}
t[0] = modpow(r[0], 998244353 - 2);
for (int i = 1; i < m; i++) {
t[i] = p[i] * t[i - 1] % 998244353 + 1;
t[i] *=
modpow((1 - p[i] - q[i] + 2LL * 998244353) % 998244353, 998244353 - 2),
t[i] %= 998244353;
}
for (int i = m - 1; i >= 0; i--) dp[i] = dp[i + 1] + t[i], dp[i] %= 998244353;
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += dp[a[i]], ans %= 998244353;
}
ans += 998244353 - dp[0] * (n - 1) % 998244353, ans %= 998244353;
ans *= modpow(n, 998244353 - 2), ans %= 998244353;
cout << ans << endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1007;
long long qsum(int i, int j, int k) {
cout << 1 << ' ' << i << ' ' << j << ' ' << k << endl;
long long ans;
cin >> ans;
return ans;
}
int qcross(int i, int j, int k) {
cout << 2 << ' ' << i << ' ' << j << ' ' << k << endl;
int ans;
cin >> ans;
return ans;
}
long long sum[MAXN];
int cross[MAXN];
int id[MAXN];
inline bool cmp(int a, int b) {
if (cross[a] != cross[b]) return cross[a] < cross[b];
if (cross[a] > 0) {
return sum[a] > sum[b];
} else {
return sum[a] < sum[b];
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
int a = 1, b = 2, c = -1;
for (int i = 3; i <= n; i++) {
if (qcross(a, b, i) > 0) {
b = i;
}
}
sum[a] = sum[b] = 0;
long long mx = -1;
for (int i = 2; i <= n; i++)
if (i != b) {
sum[i] = qsum(a, b, i);
if (sum[i] > mx) c = i, mx = sum[i];
}
cross[a] = -3;
cross[b] = 9;
cross[c] = 0;
for (int i = 2; i <= n; i++)
if (i != b && i != c) {
cross[i] = qcross(a, c, i);
}
for (int i = 1; i <= n; i++) id[i] = i;
sort(id + 1 + 1, id + n + 1, cmp);
cout << "0 ";
for (int i = 1; i <= n; i++) {
cout << id[i] << " \n"[i == n];
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 10005;
int parent[MAX_N], my_rank[MAX_N];
int find_set(int v) {
if (v == parent[v]) return v;
parent[v] = find_set(parent[v]);
return parent[v];
}
void link_set(int x, int y) {
if (my_rank[x] > my_rank[y])
parent[y] = x;
else
parent[x] = y;
my_rank[y] += (my_rank[x] == my_rank[y]);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) parent[i] = i;
int cnt = n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
int a = find_set(i);
int b = find_set(x);
if (a != b) {
link_set(a, b);
cnt--;
}
}
cout << cnt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
double r, v, T, s, f, X;
int main() {
ios_base::sync_with_stdio(false);
int t1, t2;
scanf("%d%d%d", &n, &t1, &t2);
r = t1;
v = t2;
T = 2 *
3.141592653589793238462643383279502884197169399375105820974944592307816406286 *
r / v;
X = v * T + r * sin((v * T) / r);
while (n--) {
scanf("%d%d", &t1, &t2);
s = t1, f = t2;
f -= s;
double l = 0, h = f + X, m, d;
d = (f - floor(f / X) * X) / 2.0;
int mx = log2((h - l) * 1e7) * 2.0;
for (int i = 0; i < mx; ++i) {
m = (l + h) / 2.0;
if ((v * m + r * sin((m * v) / r)) >= d) {
h = m;
} else {
l = m;
}
}
printf("%.7lf\n", l * 2.0 + floor(f / X) * T);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct st {
int x, y;
};
bool cmp(st a, st b) { return a.x < b.x; }
int main() {
int n, m;
cin >> n >> m;
vector<st> b(m), r(n);
for (int i = 0; i < n; i++) cin >> r[i].x >> r[i].y;
for (int i = 0; i < m; i++) cin >> b[i].x >> b[i].y;
sort(r.begin(), r.end(), cmp);
vector<vector<int> > dl(n, vector<int>(n, 0));
vector<int> dt(n, 0);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
for (int k = 0; k < m; k++)
if (b[k].x >= r[i].x && b[k].x <= r[j].x)
if (r[i].y + (r[j].y - r[i].y) * (((long double)(b[k].x - r[i].x)) /
(r[j].x - r[i].x)) >=
b[k].y)
dl[i][j]++;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (r[i].x == b[j].x && r[i].y >= b[j].y) dt[i]++;
int res = 0;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
for (int k = j + 1; k < n; k++)
if (dl[i][k] == dl[i][j] + dl[j][k] - dt[j]) res++;
cout << res;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int t, n;
} e[110000 << 1];
int vi[110000], fi[110000], pi[110000], in0[110000], out0[110000], qi[110000];
int d1[110000], d2[110000], sz[110000], pre[110000], dep[110000], q[110000];
bool used[110000], can[110000];
int n, p, nk, m, tot, vnk;
struct Thas {
int fi[1999973], id[1999973], ha[110000], sz[110000], ne[110000], cnt;
inline void clear(void) { cnt = 0; }
void ins(int x) {
if (x < 0) x += p;
int t = x % 1999973;
if (id[t] != tot) id[t] = tot, fi[t] = -1;
for (int i = fi[t]; i != -1; i = ne[i])
if (ha[i] == x) {
sz[i]++;
return;
}
ha[++cnt] = x, sz[cnt] = 1, ne[cnt] = fi[t], fi[t] = cnt;
}
int get(int x) {
if (x < 0) x += p;
int t = x % 1999973;
if (id[t] == tot)
for (int i = fi[t]; i != -1; i = ne[i])
if (ha[i] == x) return sz[i];
return 0;
}
} h1, h2;
inline int mpow(int x, int y, int t = 1) {
for (; y; y >>= 1, x = x * 1LL * x % p)
if (y & 1) t = t * 1LL * x % p;
return t;
}
inline int inv(int x) { return mpow(x, p - 2); }
inline void insert(int x, int y) { e[++tot] = (node){y, fi[x]}, fi[x] = tot; }
int getrt(int x, int t = 1) {
pre[q[1] = x] = -1;
for (int h = 1, tt; h <= t; h++) {
can[x = q[h]] = true, sz[x] = 1;
for (int i = fi[x]; i != -1; i = e[i].n)
if ((tt = e[i].t) != pre[x] && !used[e[i].t]) pre[q[++t] = tt] = x;
}
for (int i = t; i >= 1; i--) {
x = q[i], sz[pre[x]] += sz[x];
if (sz[x] * 2 > t) can[pre[x]] = false;
if (sz[x] * 2 >= t && can[x]) return x;
}
}
void BFS(int x, int t = 1) {
pre[q[1] = x] = -1, d1[x] = vi[x], d2[x] = 0, dep[x] = 0;
for (int h = 1, tt; h <= t; h++)
for (int i = fi[x = q[h]]; i != -1; i = e[i].n)
if ((tt = e[i].t) != pre[x] && !used[e[i].t])
pre[q[++t] = tt] = x, d2[tt] = (d2[x] * 1LL * nk + vi[tt]) % p,
d1[tt] =
(d1[x] + vi[tt] * 1LL * pi[dep[tt] = dep[x] + 1]) % p;
for (int i = 1; i <= t; i++) {
if (d1[x = q[i]] == m) out0[q[1]]++, in0[x]++;
if (i > 1 && (d2[x] + vi[q[1]] * 1LL * pi[dep[x]]) % p == m)
in0[q[1]]++, out0[x]++;
}
}
void solve(int x, int t = 1) {
q[1] = x;
for (int h = 1; h <= t; h++)
for (int i = fi[x = q[h]]; i != -1; i = e[i].n)
if (e[i].t != pre[x] && !used[e[i].t]) q[++t] = e[i].t;
for (int i = 1; i <= t; i++)
in0[q[i]] += h2.get(d1[q[i]]),
out0[q[i]] += h1.get((m - d2[q[i]] + p) * 1LL * qi[dep[q[i]]] % p);
for (int i = 1; i <= t; i++)
h2.ins((m - d2[q[i]] + p) * 1LL * qi[dep[q[i]]] % p), h1.ins(d1[q[i]]);
}
int ch[110000];
void DFS(int x) {
used[x] = true, BFS(x);
int cs = 0;
for (int i = fi[x]; i != -1; i = e[i].n)
if (!used[e[i].t]) ch[++cs] = e[i].t;
tot++, h1.clear(), h2.clear();
for (int i = 1; i <= cs; i++) solve(ch[i]);
tot++, h1.clear(), h2.clear();
for (int i = cs; i >= 1; i--) solve(ch[i]);
for (int i = fi[x]; i != -1; i = e[i].n)
if (!used[e[i].t]) DFS(getrt(e[i].t));
}
int main(void) {
scanf("%d%d%d%d", &n, &p, &nk, &m), pi[0] = qi[0] = 1, vnk = inv(nk), m %= p;
for (int i = 1; i <= n + 1; i++)
pi[i] = pi[i - 1] * 1LL * nk % p, qi[i] = qi[i - 1] * 1LL * vnk % p;
fill(fi, fi + n + 1, -1), tot = 1;
for (int i = 1; i <= n; i++) scanf("%d", vi + i);
for (int i = 1; i <= n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y), insert(x, y), insert(y, x);
}
tot = 0, DFS(getrt(1));
long long ans = 0;
for (int i = 1; i <= n; i++)
ans += (in0[i] + out0[i]) * 1LL * (2 * n - out0[i] - in0[i]) +
in0[i] * 1LL * (n - in0[i]) + out0[i] * 1LL * (n - out0[i]);
ans = n * 1LL * n * n - (ans >> 1);
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 123456;
struct tre {
int a, b, c;
tre() {}
tre(int A, int B, int C) : a(A), b(B), c(C) {}
bool exi(int t) { return a == t || b == t || c == t; }
int minu(int x, int y) { return a ^ b ^ c ^ x ^ y; }
};
vector<tre> v[N];
vector<int> ans;
int vis[N];
void make(int pre, int now) {
ans.push_back(now);
for (int i = 0; i < v[now].size(); ++i)
if (v[now][i].exi(pre)) {
int tmp = v[now][i].minu(now, pre);
if (vis[tmp]) continue;
vis[tmp] = 1;
make(now, tmp);
return;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, a, b, c, d11 = -1, d12 = -1, d21 = -1, d22 = -1;
cin >> n;
for (int i = 1; i < n - 1; ++i) {
cin >> a >> b >> c;
tre tmp(a, b, c);
v[a].push_back(tmp);
v[b].push_back(tmp);
v[c].push_back(tmp);
}
for (int i = 1; i <= n; ++i) {
if (v[i].size() == 1) {
if (~d11)
d12 = i;
else
d11 = i;
} else if (v[i].size() == 2) {
if (~d21)
d22 = i;
else
d21 = i;
}
}
ans.push_back(d11);
if (v[d11][0].exi(d21)) {
vis[d11] = vis[d21] = 1;
make(d11, d21);
} else {
vis[d11] = vis[d22] = 1;
make(d11, d22);
}
for (int i = 0; i < ans.size(); ++i) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int count1 = 0;
vector<int> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i < n - 1; i++) {
if (arr[i] == 1) {
count1++;
} else {
break;
}
}
if (count1 % 2 == 0) {
cout << "First\n";
} else {
cout << "Second\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, d, i, j, y = 0;
cin >> n >> d;
map<long long int, long long int> a;
for (i = 0; i < n; i++) {
cin >> j;
a[j]++;
y = max(y, j);
}
if (a[d] > 0)
cout << "1\n";
else {
cout << max(2LL, (d - 1 + y) / y) << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) solve();
cerr << "\nTime elapsed: " << setprecision(5)
<< 1000.0 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 55;
const long long mod = 10000007;
long long n, t, len, a[maxn], f[maxn][maxn];
void get(long long x, bool pa) {
len = 0;
while (x) {
if (pa) a[len + 1] = x % 2;
x >>= 1;
len++;
}
}
long long dp(long long pos, long long num, long long ask, bool limit) {
if (pos == 0) return num == ask;
if (f[pos][num] != -1 && !limit) return f[pos][num];
long long up = limit ? a[pos] : 1;
long long ans = 0;
for (long long i = 0; i <= up; i++) {
ans += dp(pos - 1, num + i, ask, (limit && (i == up)));
}
return limit ? ans : f[pos][num] = ans;
}
long long fsm(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res % mod;
}
int main() {
cin >> n >> t;
n++;
get(n, 1);
if (t - (t & (-t)) != 0) {
puts("0");
return 0;
}
memset(f, -1, sizeof f);
long long ans = dp(len, 0, log2(t) + 1, 1);
if (t == 1) ans--;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
long long n, m, aa;
long long a[maxn], d[maxn], s[maxn];
long long q;
long long dfs(long long dep, long long tot) {
if (tot >= n) return (s[n] - s[(tot - 1) / q]) * dep;
long long ans = 0;
ans += (s[tot] - s[(tot - 1) / q]) * dep;
ans += dfs(dep + 1, tot * q + 1);
return ans;
}
bool cmp(long long a, long long b) { return a > b; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
sort(a + 1, a + 1 + n, cmp);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i], aa += a[i] * (i - 1);
cin >> m;
for (int i = 1; i <= m; i++) {
scanf("%I64d", &q);
if (q >= n && n > 1) q = n - 1;
if (q > 1)
printf("%I64d ", dfs(0, 1));
else
printf("%I64d ", aa);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, f, g, h, i, j;
cin >> a >> b >> c >> d;
e = 3 * a / 10;
f = 3 * b / 10;
g = a - (a / 250) * c;
h = b - (b / 250) * d;
if (e > g)
i = e;
else
i = g;
if (f > h)
j = f;
else
j = h;
if (i > j)
cout << "Misha" << endl;
else if (i == j)
cout << "Tie" << endl;
else
cout << "Vasya" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int IN() {
int x = 0, ch;
for (; (ch = getchar()) < '0' || ch > '9';)
;
for (; ch >= '0' && ch <= '9'; (ch = getchar())) (x *= 10) += ch - '0';
return x;
}
int N, Q, C, D, T, L[800005], R[800005], st[800005], Len[800005], Now[800005],
Ans[800005], Pos[800005];
char s[800005];
bool V[800005];
struct Lin {
int v, next;
} E[800005];
struct Opt {
int k, t, ID;
};
vector<Opt> G[800005];
void Link(int u, int v) {
E[++D] = (Lin){v, st[u]};
st[u] = D;
}
void DFS(int u) {
L[u] = ++C;
for (int i = st[u]; i; i = E[i].next) DFS(E[i].v);
R[u] = C;
}
struct SAM {
int T, D, F[800005], Max[800005], A[800005][26];
SAM() { T = D = 1; }
void Add(int x) {
if (A[D][x] && Max[A[D][x]] == Max[D] + 1) {
D = A[D][x];
return;
}
int np = ++T, p = D, q, nq;
Max[np] = Max[p] + 1;
for (; p && !A[p][x]; p = F[p]) A[p][x] = np;
if (!p)
F[np] = 1;
else if (Max[q = A[p][x]] == Max[p] + 1)
F[np] = q;
else {
Max[nq = ++T] = Max[p] + 1;
F[nq] = F[q];
for (int i = 0; i <= 25; i++) A[nq][i] = A[q][i];
F[np] = F[q] = nq;
for (; p && A[p][x] == q; p = F[p]) A[p][x] = nq;
}
D = np;
}
void Pre(int u) {
if (F[u]) Link(F[u], u);
V[u] = 1;
for (int i = 0; i <= 25; i++)
if (A[u][i] && !V[A[u][i]]) Pre(A[u][i]);
}
} S;
struct Bit {
int F[800005];
void Add(int x) {
for (; x <= C; x += x & -x) F[x]++;
}
int Ask(int x) {
int ret = 0;
for (; x; x -= x & -x) ret += F[x];
return ret;
}
} B;
int main() {
N = IN();
Q = IN();
for (int i = 1; i <= N; i++) {
scanf("%s", s + T);
S.D = 1;
for (; s[T]; T++, Len[i]++) S.Add(s[T] - 'a');
}
S.Pre(1);
DFS(1);
for (int i = 1, k = 0, x = 1; i <= N; i++, x = 1) {
for (int j = k; j <= k + Len[i] - 1; j++)
x = S.A[x][s[j] - 'a'], Pos[j] = x;
Now[i] = x;
k += Len[i];
}
for (int i = 1; i <= Q; i++) {
int l = IN(), r = IN(), k = IN();
G[l - 1].push_back((Opt){Now[k], -1, i});
G[r].push_back((Opt){Now[k], 1, i});
}
for (int i = 1, k = 0; i <= N; i++) {
for (int j = k; j <= k + Len[i] - 1; j++) B.Add(L[Pos[j]]);
k += Len[i];
for (int j = 0; j < G[i].size(); j++)
Ans[G[i][j].ID] +=
G[i][j].t * (B.Ask(R[G[i][j].k]) - B.Ask(L[G[i][j].k] - 1));
}
for (int i = 1; i <= Q; i++) printf("%d\n", Ans[i]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<ll, ll>;
using vi = vc<ll>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
template <class t, size_t n>
ostream& operator<<(ostream& os, const array<t, n>& first) {
return os << vc<t>(first.begin(), first.end());
}
template <ll i, class T>
void print_tuple(ostream&, const T&) {}
template <ll i, class T, class H, class... Args>
void print_tuple(ostream& os, const T& t) {
if (i) os << ",";
os << get<i>(t);
print_tuple<i + 1, T, Args...>(os, t);
}
template <class... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
os << "{";
print_tuple<0, tuple<Args...>, Args...>(os, t);
return os << "}";
}
template <class t>
void print(t x, ll suc = 1) {
cout << x;
if (suc == 1) cout << "\n";
if (suc == 2) cout << " ";
}
ll read() {
ll i;
cin >> i;
return i;
}
vi readvi(ll n, ll off = 0) {
vi v(n);
for (ll i = ll(0); i < ll(n); i++) v[i] = read() + off;
return v;
}
template <class T>
void print(const vector<T>& v, ll suc = 1) {
for (ll i = ll(0); i < ll(v.size()); i++)
print(v[i], i == ll(v.size()) - 1 ? suc : 2);
}
string readString() {
string s;
cin >> s;
return s;
}
template <class T>
T sq(const T& t) {
return t * t;
}
void yes(bool ex = true) {
cout << "Yes"
<< "\n";
if (ex) exit(0);
}
void no(bool ex = true) {
cout << "No"
<< "\n";
if (ex) exit(0);
}
void possible(bool ex = true) {
cout << "Possible"
<< "\n";
if (ex) exit(0);
}
void impossible(bool ex = true) {
cout << "Impossible"
<< "\n";
if (ex) exit(0);
}
constexpr ll ten(ll n) { return n == 0 ? 1 : ten(n - 1) * 10; }
const ll infLL = LLONG_MAX / 3;
const ll inf = infLL;
ll topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
ll topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
ll botbit(signed first) { return first == 0 ? 32 : __builtin_ctz(first); }
ll botbit(ll first) { return first == 0 ? 64 : __builtin_ctzll(first); }
ll popcount(signed t) { return __builtin_popcount(t); }
ll popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(ll i) { return i && (i & -i) == i; }
ll mask(ll i) { return (ll(1) << i) - 1; }
bool inc(ll first, ll second, ll c) { return first <= second && second <= c; }
template <class t>
void mkuni(vc<t>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
ll rand_int(ll l, ll r) {
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<ll>(l, r)(gen);
}
template <class t>
void myshuffle(vc<t>& first) {
for (ll i = ll(0); i < ll(ll(first.size())); i++)
swap(first[i], first[rand_int(0, i)]);
}
template <class t>
ll lwb(const vc<t>& v, const t& first) {
return lower_bound(v.begin(), v.end(), first) - v.begin();
}
using uint = unsigned;
using ull = unsigned long long;
struct modinfo {
uint mod, root;
};
template <modinfo const& ref>
struct modular {
static constexpr uint const& mod = ref.mod;
static modular root() { return modular(ref.root); }
uint v;
modular(ll vv = 0) { s(vv % mod + mod); }
modular& s(uint vv) {
v = vv < mod ? vv : vv - mod;
return *this;
}
modular operator-() const { return modular() - *this; }
modular& operator+=(const modular& rhs) { return s(v + rhs.v); }
modular& operator-=(const modular& rhs) { return s(v + mod - rhs.v); }
modular& operator*=(const modular& rhs) {
v = ull(v) * rhs.v % mod;
return *this;
}
modular& operator/=(const modular& rhs) { return *this *= rhs.inv(); }
modular operator+(const modular& rhs) const { return modular(*this) += rhs; }
modular operator-(const modular& rhs) const { return modular(*this) -= rhs; }
modular operator*(const modular& rhs) const { return modular(*this) *= rhs; }
modular operator/(const modular& rhs) const { return modular(*this) /= rhs; }
modular pow(ll n) const {
modular res(1), x(*this);
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
modular inv() const { return pow(mod - 2); }
friend modular operator+(ll x, const modular& y) { return modular(x) + y; }
friend modular operator-(ll x, const modular& y) { return modular(x) - y; }
friend modular operator*(ll x, const modular& y) { return modular(x) * y; }
friend modular operator/(ll x, const modular& y) { return modular(x) / y; }
friend ostream& operator<<(ostream& os, const modular& m) {
return os << m.v;
}
friend istream& operator>>(istream& is, modular& m) {
ll x;
is >> x;
m = modular(x);
return is;
}
bool operator<(const modular& r) const { return v < r.v; }
bool operator==(const modular& r) const { return v == r.v; }
bool operator!=(const modular& r) const { return v != r.v; }
explicit operator bool() const { return v; }
};
extern constexpr modinfo base{1000000007, 0};
using mint = modular<base>;
const ll vmax = (1 << 21) + 10;
mint fact[vmax], finv[vmax], invs[vmax];
void initfact() {
fact[0] = 1;
for (ll i = ll(1); i < ll(vmax); i++) {
fact[i] = fact[i - 1] * i;
}
finv[vmax - 1] = fact[vmax - 1].inv();
for (ll i = vmax - 2; i >= 0; i--) {
finv[i] = finv[i + 1] * (i + 1);
}
for (ll i = vmax - 1; i >= 1; i--) {
invs[i] = finv[i] * fact[i - 1];
}
}
mint choose(ll n, ll k) { return fact[n] * finv[n - k] * finv[k]; }
mint binom(ll first, ll second) {
return fact[first + second] * finv[first] * finv[second];
}
mint catalan(ll n) {
return binom(n, n) - (n - 1 >= 0 ? binom(n - 1, n + 1) : 0);
}
struct unionfind {
vi p, s;
ll c;
unionfind(ll n) : p(n, -1), s(n, 1), c(n) {}
ll find(ll first) {
return p[first] == -1 ? first : (p[first] = find(p[first]));
}
bool unite(ll first, ll second) {
first = find(first);
second = find(second);
if (first == second) return false;
p[second] = first;
s[first] += s[second];
c--;
return true;
}
bool same(ll first, ll second) { return find(first) == find(second); }
ll sz(ll first) { return s[find(first)]; }
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
ll n;
cin >> n;
vc<pi> xy;
vi xs, ys;
for (ll i = ll(0); i < ll(n); i++) {
ll x, y;
cin >> x >> y;
xs.push_back(x);
ys.push_back(y);
xy.emplace_back(x, y);
}
mkuni(xs);
mkuni(ys);
ll s = ll(xs.size()) + ll(ys.size());
unionfind uf(s);
for (auto e : xy) {
uf.unite(lwb(xs, e.first), ll(xs.size()) + lwb(ys, e.second));
}
vi cnt(s);
for (auto e : xy) cnt[uf.find(lwb(xs, e.first))]++;
mint ans = 1;
for (ll i = ll(0); i < ll(s); i++)
if (uf.find(i) == i) {
mint w = mint(2).pow(uf.sz(i));
if (cnt[i] + 1 == uf.sz(i)) w -= 1;
ans *= w;
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1100;
int n, a[N], tab[N][N];
vector<int> pos[N], tmp[N];
template <class T>
inline void read(T &x) {
x = 0;
char ch = getchar(), w = 0;
while (!isdigit(ch)) w = (ch == '-'), ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
x = w ? -x : x;
return;
}
int main() {
read(n);
for (register int i = 1; i <= n; ++i) read(a[i]);
printf("%d\n", n + 1);
for (register int i = 1; i <= n + 1; ++i) pos[1].push_back(i);
for (register int i = 1; i <= n; ++i) {
int num = 0, cnt = 0;
for (register int j = 1; j <= n + 1; ++j) {
tmp[j].clear();
num += pos[j].size() > 1;
}
if (a[i] <= num) {
for (register int j = 1; j <= n + 1; ++j) {
if (!pos[j].size()) continue;
if (pos[j].size() == 1 || !a[i])
tmp[++cnt] = pos[j];
else {
--a[i], tmp[++cnt].push_back(pos[j].back()),
tab[pos[j].back()][i] = 1;
pos[j].pop_back(), tmp[++cnt] = pos[j];
}
}
} else if (a[i] >= n + 1 - num) {
num = n + 1 - a[i];
for (register int j = 1; j <= n + 1; ++j) {
if (!pos[j].size()) continue;
if (pos[j].size() == 1 || !num) {
++cnt;
for (auto &k : pos[j]) tmp[cnt].push_back(k), tab[k][i] = 1;
} else {
--num, tmp[++cnt].push_back(pos[j].back());
pos[j].pop_back(), ++cnt;
for (auto &k : pos[j]) tmp[cnt].push_back(k), tab[k][i] = 1;
}
}
} else {
for (register int j = 1; j <= n + 1; ++j) {
if (!pos[j].size()) continue;
if (pos[j].size() == 1) {
if (a[i] > num) --a[i], tab[pos[j].back()][i] = 1;
tmp[++cnt].push_back(pos[j].back());
} else {
--num, ++cnt;
while (a[i] > num && pos[j].size() > 1)
--a[i], tab[pos[j].back()][i] = 1,
tmp[cnt].push_back(pos[j].back()), pos[j].pop_back();
++cnt;
while (pos[j].size())
tmp[cnt].push_back(pos[j].back()), pos[j].pop_back();
}
}
}
swap(pos, tmp);
}
for (register int i = 1; i <= n + 1; ++i) {
for (register int j = 1; j <= n; ++j) printf("%d", tab[i][j]);
putchar('\n');
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int Test;
cin >> Test;
for (int _t = 1; _t <= Test; _t++) {
scanf("%d", &n);
if (n == 2) {
printf("2\n1 2\n");
} else {
printf("2\n");
printf("%d %d\n", n, n - 2);
printf("%d %d\n", n - 1, n - 1);
int loop = n - 3;
int a = n - 1, b = a - 2;
while (loop--) {
printf("%d %d\n", a, b);
a--;
b = a - 2;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long s[1000007], res, n, k;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) scanf("%I64d", &s[i]);
res = 0;
for (int i = 1; i <= n - k; i++)
res = max(res, s[i] + s[(n - k) * 2 - i + 1]);
for (int i = 1; i <= n; ++i) res = max(res, s[i]);
cout << res;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int b, k, a[100005];
void solve() {
int cnt = 0;
for (int i = 0; i < k; i++) {
if (i == k - 1)
if (a[i] & 1) {
cnt++;
continue;
}
if ((a[i] & 1) && (b & 1)) cnt++;
}
if (cnt & 1)
printf("odd\n");
else
printf("even\n");
}
int main() {
scanf("%d%d", &b, &k);
for (int i = 0; i < k; i++) scanf("%d", &a[i]);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 10;
const long long mod = 1e9 + 7;
const long long INF = 1e18;
const long long inf = -1e18;
long long n, m, x, y, us[3010], ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
us[x] += y;
}
for (int i = 1; i <= 3005; i++) {
ans += min(us[i], m);
if (us[i] > m) {
us[i + 1] += min(m, (us[i] - m));
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
long long a[n + 5], d[n + 5], prefmn[n + 5], sufmn[n + 5];
long long suf[n + 5], pref[n + 5], mxsuf[n + 5];
long long ans = 0;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> d[i];
ans = max(ans, a[n - 1] - d[n - 1]);
prefmn[0] = d[0];
for (int i = 1; i < n; i++) prefmn[i] = min(prefmn[i - 1], d[i]);
long long sums = 0;
pref[0] = a[0];
for (int i = 1; i < n; i++) {
pref[i] = pref[i - 1] + a[i];
}
mxsuf[n] = 0;
sufmn[n] = 1e7;
for (int i = n - 1; i >= 0; i--) {
sums += a[i];
suf[i] = sums;
sufmn[i] = min(a[i], sufmn[i + 1]);
mxsuf[i] = max(mxsuf[i + 1], suf[i] - d[i]);
}
if (k == 0) {
long long cur, ans = 0;
ans = max(ans, suf[n - 1] - d[n - 1]);
for (int i = n - 2; i >= 0; i--) {
ans = max(ans, suf[i] - d[i]);
}
cout << ans << endl;
} else if (k > 1) {
long long mins = 1e7;
int idx = -1, prv = -1;
for (int i = 0; i < n; i++) {
if (mins > d[i]) {
prv = idx;
idx = i;
mins = d[i];
}
}
if (idx == n - 1) {
ans = max(suf[0] - prefmn[prv], ans);
} else {
ans = max(suf[0] - mins, ans);
}
cout << ans << "\n";
} else {
long long mins = 1e7;
for (int i = 0; i < n - 1; i++) {
ans = max(pref[i] - prefmn[i] + mxsuf[i + 1], ans);
}
for (int i = 0; i < n - 1; i++) {
ans = max(ans, suf[i] - d[i] - sufmn[i + 1]);
}
for (int i = 1; i < n; i++) {
ans = max(ans, suf[i] - d[i]);
}
cout << ans << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int N, Q, a[300010], d[300010];
namespace SegmentTree {
struct SegmentTreeNode {
int l, r, size;
long long sum, tag[2], D[2];
bool f;
} tree[300010 << 2];
inline void Update(int now, bool o) {
tree[now].D[0] = min(tree[now << 1].D[0], tree[now << 1 | 1].D[o]);
tree[now].D[1] = min(tree[now << 1].D[1], tree[now << 1 | 1].D[o ^ 1]);
}
inline void PushDown(int now, bool o) {
if (tree[now].l == tree[now].r) return;
if (tree[now].tag[0])
tree[now << 1].D[0] += tree[now].tag[0],
tree[now << 1].tag[0] += tree[now].tag[0],
tree[now << 1 | 1].D[o] += tree[now].tag[0],
tree[now << 1 | 1].tag[o] += tree[now].tag[0], tree[now].tag[0] = 0;
if (tree[now].tag[1])
tree[now << 1].D[1] += tree[now].tag[1],
tree[now << 1].tag[1] += tree[now].tag[1],
tree[now << 1 | 1].D[o ^ 1] += tree[now].tag[1],
tree[now << 1 | 1].tag[o ^ 1] += tree[now].tag[1], tree[now].tag[1] = 0;
}
inline void BuildTree(int now, int l, int r) {
tree[now].l = l;
tree[now].r = r;
tree[now].size = r - l + 1;
if (l == r) {
tree[now].D[0] = d[l];
tree[now].D[1] = 0x7fffffff;
return;
}
int mid = (l + r) >> 1;
BuildTree(now << 1, l, mid);
BuildTree(now << 1 | 1, mid + 1, r);
Update(now, tree[now << 1].size & 1);
}
inline void Modify(int now, int L, int R, long long x, bool o) {
if (L > R) return;
int l = tree[now].l, r = tree[now].r;
PushDown(now, tree[now << 1].size & 1);
if (L <= l && R >= r) {
tree[now].tag[o] += x;
tree[now].D[o] += x;
return;
}
int mid = (l + r) >> 1;
if (L <= mid) Modify(now << 1, L, R, x, o);
if (R > mid) Modify(now << 1 | 1, L, R, x, o ^ (tree[now << 1].size & 1));
Update(now, tree[now << 1].size & 1);
}
inline long long Query(int now, int L, int R, bool o) {
if (L > R) return 0x7fffffff;
int l = tree[now].l, r = tree[now].r;
PushDown(now, tree[now << 1].size & 1);
if (L <= l && R >= r) return tree[now].D[o];
int mid = (l + r) >> 1;
long long re = 0x7fffffff;
if (L <= mid) re = min(re, Query(now << 1, L, R, o));
if (R > mid)
re = min(re, Query(now << 1 | 1, L, R, o ^ (tree[now << 1].size & 1)));
return re;
}
} // namespace SegmentTree
using namespace SegmentTree;
int main() {
N = read();
for (int i = 0; i <= N - 1; i++) a[i] = read();
d[0] = a[0];
for (int i = 1; i <= N - 1; i++) d[i] = a[i] - a[i - 1], a[i] -= a[i - 1];
SegmentTree::BuildTree(1, 0, N - 1);
Q = read();
while (Q--) {
int opt = read(), L = read(), R = read(), K;
if (opt == 1) {
K = read();
SegmentTree::Modify(1, L, R, K, L & 1);
if ((R - L + 1) & 1)
SegmentTree::Modify(1, R + 1, N - 1, -K, (R + 1) & 1),
SegmentTree::Modify(1, R + 2, N - 1, K, (R + 2) & 1);
}
if (opt == 2) {
long long x = L > 0 ? SegmentTree::Query(1, L - 1, L - 1, (L - 1) & 1)
: 0,
y = SegmentTree::Query(1, R, R, R & 1);
if ((R - L + 1) & 1)
y += x;
else
y -= x;
if (y != ((R - L + 1) & 1) ||
SegmentTree::Query(1, L, R, L & 1) + x < 1 ||
SegmentTree::Query(1, L, R, (L & 1) ^ 1) - x < 0)
puts("0");
else
puts("1");
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
const long long int MOD = 1e9 + 7;
const long long int INF = 1011111111;
const long long int LLINF = 1000111000111000111LL;
const long double EPS = 1e-10;
const long double PI = 3.14159265358979323;
using namespace std;
long long int power(long long int x, long long int n) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return power((x * x), n / 2);
else
return x * power((x * x), (n - 1) / 2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m, i, j, k;
string s;
cin >> n;
cin >> s;
char ch[200505];
memset(ch, '.', sizeof ch);
long long int id = 0;
ch[0] = s[0];
long long int ans = 0;
for (i = 1; i < n; i++) {
if (id % 2 == 0 && s[i] == ch[id]) {
ans++;
} else {
ch[++id] = s[i];
}
}
if (id % 2 == 0) {
ch[id] = '.';
ans++;
}
cout << ans << '\n';
for (i = 0; i <= id + 10; i++) {
if (ch[i] != '.') cout << ch[i];
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200;
const long long MOD = 1e9 + 7;
int n, x;
char s[N];
long long dp[N][N][N], dp_l[N][N], dp_r[N][N], dp_s[N];
long long solve() {
for (int l = 1; l <= n; l++) {
int c = s[l] - '0';
dp[c][l][l] = 1;
}
for (int t = 2; t <= x; t++) {
for (int len = 1; len <= n; len++) {
for (int l = 1; l + len - 1 <= n; l++) {
int r = l + len - 1;
for (int mid = l; mid < r; mid++) {
dp[t][l][r] =
(dp[t][l][r] + dp[t - 1][l][mid] * dp[t - 2][mid + 1][r] % MOD) %
MOD;
}
dp[t][l][r] = (dp[t][l][r] + dp[t - 2][l][r] + dp[t - 1][l][r]) % MOD;
}
}
}
dp_l[0][0] = dp_l[1][0] = 1;
for (int t = 2; t <= x; t++) {
dp_l[t][0] =
((dp_l[t - 1][0] + 1) * (dp_l[t - 2][0] + 1) % MOD - 1 + MOD) % MOD;
}
for (int t = 2; t <= x; t++) {
for (int r = 1; r <= n; r++) {
for (int l = 1; l <= r; l++) {
dp_l[t][r] =
(dp_l[t][r] + dp_l[t - 1][l - 1] * dp[t - 2][l][r] % MOD) % MOD;
}
dp_l[t][r] = (dp_l[t][r] + dp_l[t - 1][r] +
(dp_l[t - 1][0] + 1) * dp_l[t - 2][r] % MOD) %
MOD;
}
}
dp_r[0][n + 1] = dp_r[1][n + 1] = 1;
for (int t = 2; t <= x; t++) {
dp_r[t][n + 1] =
((dp_r[t - 1][n + 1] + 1) * (dp_r[t - 2][n + 1] + 1) % MOD - 1 + MOD) %
MOD;
}
for (int t = 2; t <= x; t++) {
for (int l = 1; l <= n; l++) {
for (int r = l; r <= n; r++) {
dp_r[t][l] =
(dp_r[t][l] + dp[t - 1][l][r] * dp_r[t - 2][r + 1] % MOD) % MOD;
}
dp_r[t][l] =
(dp_r[t][l] + dp_r[t - 1][l] * (dp_r[t - 2][n + 1] + 1) % MOD +
dp_r[t - 2][l]) %
MOD;
}
}
for (int t = 2; t <= x; t++) {
for (int i = 0; i <= n; i++) {
dp_s[t] = (dp_s[t] + dp_l[t - 1][i] * dp_r[t - 2][i + 1] % MOD) % MOD;
}
dp_s[t] = (dp_s[t] + (dp_l[t - 1][0] + 1) * dp_s[t - 2] % MOD) % MOD;
dp_s[t] = (dp_s[t] + dp_s[t - 1] * (dp_r[t - 2][n + 1] + 1) % MOD) % MOD;
}
long long ans = (dp_s[x] + dp[x][1][n] + dp_l[x][n] + dp_r[x][1]) % MOD;
return ans;
}
int main() {
scanf("%d %d %s", &n, &x, s + 1);
printf("%lld\n", solve());
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5, mod = 998244353;
inline int mod1(int x) { return x < mod ? x : x - mod; }
inline int mod2(int x) { return x < 0 ? x + mod : x; }
inline void add(int &x, int y) { x = mod1(x + y); }
inline void sub(int &x, int y) { x = mod2(x - y); }
inline int pow_mod(int x, int i) {
int y = 1;
while (i) {
if (i & 1) y = (long long)y * x % mod;
x = (long long)x * x % mod;
i >>= 1;
}
return y;
}
int p[26], val[26], m, n, s[MAXN + 5], t[MAXN + 5], vs[MAXN + 5], vt[MAXN + 5],
res[MAXN + 5], f[MAXN * 4 + 5], g[MAXN * 4 + 5], rev[MAXN * 4 + 5];
char str[MAXN + 5];
void NTT(int *a, int n, int flag) {
for (int i = 0; i < n; ++i)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int i = 1; i < n; i <<= 1) {
int T = pow_mod(3, (mod - 1) / (i << 1));
if (flag == -1) T = pow_mod(T, mod - 2);
for (int j = 0; j < n; j += (i << 1)) {
for (int k = 0, t = 1; k < i; ++k, t = (long long)t * T % mod) {
int Nx = a[j + k], Ny = (long long)a[i + j + k] * t % mod;
a[j + k] = mod1(Nx + Ny);
a[i + j + k] = mod2(Nx - Ny);
}
}
}
if (flag == -1) {
int invn = pow_mod(n, mod - 2);
for (int i = 0; i < n; ++i) a[i] = (long long)a[i] * invn % mod;
}
}
bool ck(int i) {
for (int j = 0; j < i; ++j)
if (val[i] == val[j]) return 0;
return 1;
}
int main() {
for (int i = 0; i < 26; ++i) {
val[i] = rand() % mod;
while (!ck(i)) add(val[i], 1);
}
for (int i = 0; i < 26; ++i) cin >> p[i], p[i] = val[p[i] - 1];
cin >> str;
m = strlen(str);
reverse(str, str + m);
for (int i = 0; i < m; ++i) vs[i] = val[s[i] = str[i] - 'a'];
cin >> str;
n = strlen(str);
for (int i = 0; i < n; ++i) vt[i] = val[t[i] = str[i] - 'a'];
int tmp = 0, tmpp = 0;
for (int i = 0; i < m; ++i)
add(tmp, (long long)p[s[i]] * p[s[i]] % mod * vs[i] % mod * vs[i] % mod);
for (int i = 0; i < m; ++i) add(tmpp, (long long)pow_mod(vt[i], 4));
res[m - 1] = (tmpp + tmp) % mod;
for (int i = m; i < n; ++i)
res[i] =
((res[i - 1] + pow_mod(vt[i], 4) - pow_mod(vt[i - m], 4)) % mod + mod) %
mod;
for (int i = 0; i < m; ++i)
f[i] = (long long)p[s[i]] * vs[i] % mod * mod1(p[s[i]] + vs[i]) % mod;
for (int i = 0; i < n; ++i) g[i] = vt[i];
int len = 1, ct = 0;
while (len <= n + m) len <<= 1, ++ct;
for (int i = 0; i < len; ++i)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (ct - 1));
NTT(f, len, 1);
NTT(g, len, 1);
for (int i = 0; i < len; ++i) f[i] = (long long)f[i] * g[i] % mod;
NTT(f, len, -1);
for (int i = m - 1; i < n; ++i) sub(res[i], mod1(2 * f[i]));
for (int i = 0; i < m; ++i)
f[i] = ((long long)vs[i] * vs[i] % mod +
(long long)p[s[i]] * p[s[i]] % mod + 4LL * vs[i] * p[s[i]] % mod) %
mod;
for (int i = m; i < len; ++i) f[i] = 0;
for (int i = 0; i < n; ++i) g[i] = (long long)vt[i] * vt[i] % mod;
for (int i = n; i < len; ++i) g[i] = 0;
NTT(f, len, 1);
NTT(g, len, 1);
for (int i = 0; i < len; ++i) f[i] = (long long)f[i] * g[i] % mod;
NTT(f, len, -1);
for (int i = m - 1; i < n; ++i) add(res[i], f[i]);
for (int i = 0; i < m; ++i) f[i] = mod1(vs[i] + p[s[i]]);
for (int i = m; i < len; ++i) f[i] = 0;
for (int i = 0; i < n; ++i)
g[i] = (long long)vt[i] * vt[i] % mod * vt[i] % mod;
for (int i = n; i < len; ++i) g[i] = 0;
NTT(f, len, 1);
NTT(g, len, 1);
for (int i = 0; i < len; ++i) f[i] = (long long)f[i] * g[i] % mod;
NTT(f, len, -1);
for (int i = m - 1; i < n; ++i) sub(res[i], mod1(2 * f[i]));
for (int i = m - 1; i < n; ++i)
if (!res[i])
cout << '1';
else
cout << '0';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
long long a[MAXN], dp[MAXN][2];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
memset(dp, 0xc0, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j < 2; j++) {
dp[i][j] = max(dp[i][j], dp[i - 1][j]);
dp[i][j] = max(dp[i][j], dp[i - 1][j ^ (a[i] & 1)] + a[i]);
}
return 0 * printf("%lld\n", dp[n][1]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[1005], b;
int main() {
scanf("%d", &a[0]);
for (int i = 1; i <= a[0]; i++) {
scanf("%d", &a[i]);
b += a[i] * i;
}
printf("%d", b);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[550];
int main() {
int i, k, n, extra;
int totalsum = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
if (i != 0) {
extra = arr[i - 1] + arr[i];
if (extra < k) {
arr[i] = arr[i] + k - (extra);
totalsum += (k - extra);
}
}
}
cout << totalsum << endl;
for (int j = 0; j < n; j++) {
cout << arr[j] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 9;
const int MX = 1e5 + 9;
char org[MX], s[MX * 2];
set<int> pos[256];
void inline jeden() {
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", org);
for (int i = 0, _ = (k); i < _; ++i) {
pos[org[i]].insert(i);
}
for (int i = 0, _ = (n); i < _; ++i) {
scanf("%s", s);
int len = strlen(s);
long long wynik = 0;
for (int j = 0, _ = (len); j < _; ++j) {
char c = s[j];
if (pos[c].size() == 0) {
wynik += len;
} else {
set<int>::iterator it;
it = pos[c].lower_bound(j);
int a = INF, b = INF;
if (it != pos[c].end()) b = abs(*it - j);
if (it != pos[c].begin()) {
--it;
a = abs(*it - j);
}
wynik += min(a, b);
}
}
printf("%I64d\n", wynik);
}
}
int main() { jeden(); }
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[1000001], vis[1000001];
vector<int> v[1000001], ans;
int main() {
cin >> n >> m;
for (int i = 0, x; i < n; ++i) {
scanf("%d", &x);
if (x <= m) {
v[x].push_back(i + 1);
}
}
int idx = -1, mx = 0;
for (int i = 1; i <= m; ++i) {
if (v[i].size()) {
++vis[i];
for (int j = 1; j * i <= m; ++j) {
a[j * i] += v[i].size();
++vis[j * i];
}
}
if (mx < a[i] && vis[i] > 1) {
mx = a[i];
idx = i;
}
}
if (idx != -1) {
printf("%d %d\n", idx, a[idx]);
for (int j = 1; j * j <= idx; ++j) {
if (idx % j == 0) {
for (int k = 0; k < v[j].size(); ++k) {
ans.push_back(v[j][k]);
}
for (int k = 0; k < v[idx / j].size() && idx / j != j; ++k) {
ans.push_back(v[idx / j][k]);
}
}
}
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); ++i) {
printf("%d ", ans[i]);
}
} else {
printf("1 0\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, i, j, k, m, x, y, flag = 0;
cin >> n;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
flag += a[i];
}
if (flag % n != 0) {
cout << -1 << endl;
continue;
}
a[0] = flag;
flag = n - 1;
vector<vector<long long int>> ans;
for (i = 1; i < n; i++) {
if (a[i] % (i + 1) == 0) {
flag++;
ans.push_back({i + 1, 1, a[i] / (i + 1)});
} else {
flag += 2;
ans.push_back({1, i + 1, i + 1 - a[i] % (i + 1)});
a[i] += (i + 1 - a[i] % (i + 1));
ans.push_back({i + 1, 1, a[i] / (i + 1)});
}
}
for (i = 2; i <= n; i++) {
ans.push_back({1, i, a[0] / n});
}
cout << flag << endl;
for (i = 0; i < flag; i++) {
cout << ans[i][0] << " " << ans[i][1] << " " << ans[i][2] << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-5;
int powmod(int x, int n, int d) {
if (n == 0) return 1;
int s = x % d, t = x % d, u = n - 1;
while (u) {
if (u % 2) s = (s * t) % d;
t = (t * t) % d;
u /= 2;
}
return s;
}
long long getl() {
long long ret;
scanf("%I64d", &ret);
return ret;
}
long long mod = 1000000007;
long long truemod(long long n, long long m) { return (n % m + m) % m; }
long long memo[1050][1050];
long long func(int n, int k) {
if (n <= 0) return 0;
assert(0 <= n && n < 1050 && 0 <= k && k < 1050);
if (memo[n][k] != -1) {
return memo[n][k];
}
long long &ret = memo[n][k];
if (k == 0) return ret = 1;
return ret = truemod(func(n - 2, k - 1) + 2 * func(n - 1, k) - func(n - 2, k),
mod);
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long ret = 0;
memset((memo), -1, sizeof(memo));
ret = func(n, k) * func(m, k) % mod;
cout << ret << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5;
const int inf = (int)1e9;
const double eps = 1e-8;
const double pi = 3.141592653589793238462643;
int nod(int a, int b) {
while (a > 0 && b > 0) {
if (a > b)
a %= b;
else
b %= a;
}
if (a > 0)
return a;
else if (b > 0)
return b;
else
return 1;
}
int main() {
int n, m, a, b, x, y;
cin >> n >> m >> x >> y >> a >> b;
int nodd = nod(a, b);
a /= nodd;
b /= nodd;
int xx = min(n / a, m / b);
int a1 = xx * a;
int b1 = xx * b;
int x1 = max(0, x - a1 / 2 - a1 % 2);
int y1 = max(0, y - b1 / 2 - b1 % 2);
int x2 = min(x1 + a1, n);
int y2 = min(y1 + b1, m);
x1 = x2 - a1;
y1 = y2 - b1;
cout << x1 << " " << y1 << " " << x2 << " " << y2 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int R = 0;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
if (l > R) {
cout << "NO";
return 0;
}
R = max(r, R);
}
if (R == m) {
cout << "YES";
} else {
cout << "NO";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long num[100010];
int main() {
scanf("%lld%lld%lld", &n, &m, &k);
for (int i = 1; i <= m; i++) scanf("%lld", &num[i]);
int ans = 0, count = 0;
long long r = 0;
int add = 0;
for (int i = 1; i <= m; i++) {
if (num[i] > r && add > 0)
r += add, add = 0, ans++;
else if (num[i] > r && add == 0)
r += ((num[i] - r) / k + (bool)((num[i] - r) % k)) * k;
if (num[i] <= r)
add++;
else
i--;
}
if (add > 0) ans++;
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, i;
int main() {
cin >> n;
for (i = 2; i * i <= n; i++) {
if (n % (i * i) == 0) {
n /= i;
i = 1;
}
}
cout << n << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 9;
int main() {
int n, m;
scanf("%d %d", &n, &m);
long long pw = 1LL, res = 1LL;
for (int i = 1; i <= m; i++) pw = (pw * 2) % mod;
for (int i = 1; i <= n; i++) res = (res * (pw - i + mod) % mod) % mod;
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout.fixed;
cout << setprecision(15);
int n;
double a, d, x, y, q;
cin >> n >> a >> d;
x = sqrt(2 * a * d);
y = sqrt((2 * d) / a);
double v, t;
cin >> t >> v;
if (v < x) {
double f;
f = (v * v) / (2 * a);
t += v / a;
t += (d - f) / v;
} else {
t += y;
}
cout << t << endl;
q = t;
n--;
while (n--) {
double v, t;
cin >> t >> v;
if (v < x) {
double f;
f = (v * v) / (2 * a);
t += v / a;
t += (d - f) / v;
} else {
t += y;
}
if (t < q) t = q;
cout << t << endl;
q = t;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double p[300];
double dp[300];
double tmp[300];
int main() {
int n, x;
scanf("%d%d", &n, &x);
for (int i = 0; i <= x; i++) scanf("%lf", &p[i]);
for (int i = 0; i <= x; i++) dp[i] = p[i];
n--;
while (n) {
if (n & 1) {
memset(tmp, 0, sizeof(tmp));
for (int i = 0; i <= 200; i++)
for (int j = 0; j <= 200; j++) tmp[i ^ j] += dp[i] * p[j];
for (int i = 0; i < 200; i++) dp[i] = tmp[i];
}
memset(tmp, 0, sizeof(tmp));
for (int i = 0; i <= 200; i++)
for (int j = 0; j <= 200; j++) tmp[i ^ j] += p[i] * p[j];
for (int i = 0; i < 200; i++) p[i] = tmp[i];
n = n >> 1;
}
printf("%.8lf\n", 1 - dp[0]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long long N = 500005;
const long long mod = 1e9 + 7;
using namespace std;
void solve() {
long long n, l, x, y;
cin >> n >> l >> x >> y;
long long arr[n];
set<long long> finds;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
finds.insert(arr[i]);
}
bool gf = 0, bf = 0;
for (long long i = 0; i < n; i++) {
if (x + arr[i] <= l and finds.find(x + arr[i]) != finds.end()) {
gf = 1;
break;
}
if (arr[i] - x >= 0 and finds.find(arr[i] - x) != finds.end()) {
gf = 1;
break;
}
}
for (long long i = 0; i < n; i++) {
if (y + arr[i] <= l and finds.find(y + arr[i]) != finds.end()) {
bf = 1;
break;
}
if (arr[i] - y >= 0 and finds.find(arr[i] - y) != finds.end()) {
bf = 1;
break;
}
}
if (gf and bf) {
cout << "0\n";
return;
}
if (gf) {
cout << "1\n" << y << endl;
return;
}
if (bf) {
cout << "1\n" << x << endl;
return;
}
for (long long i = 0; i < n; i++) {
long long ele = arr[i] + x;
if ((ele >= 0 and ele <= l) and (finds.find(ele - y) != finds.end() or
finds.find(ele + y) != finds.end())) {
cout << "1\n" << ele << endl;
return;
}
ele = arr[i] - x;
if ((ele >= 0 and ele <= l) and (finds.find(ele - y) != finds.end() or
finds.find(ele + y) != finds.end())) {
cout << "1\n" << ele << endl;
return;
}
}
cout << "2\n" << x << " " << y << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long T = 1;
while (T--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<long long, long long> > v1, v2;
vector<long long> mx1, mn1;
long long mx2[100005], mn2[100005];
long long totmx[2], totmn[2];
void init() {
bool flg = true;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
pair<long long, long long> tp;
scanf("%I64d%I64d", &tp.first, &tp.second);
if (flg) {
totmx[0] = totmn[0] = tp.first;
totmx[1] = totmn[1] = tp.second;
flg = false;
}
totmx[0] = max(totmx[0], tp.first);
totmn[0] = min(totmn[0], tp.first);
totmx[1] = max(totmx[1], tp.second);
totmn[1] = min(totmn[1], tp.second);
if (tp.first < 0)
v1.push_back(tp);
else
v2.push_back(tp);
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
if (v1.size())
mx1.push_back(max(0LL, v1.begin()->second));
else
mx1.push_back(0);
if (v1.size())
mn1.push_back(min(0LL, v1.begin()->second));
else
mn1.push_back(0);
for (int i = 1; i < (int)v1.size(); i++) {
mx1.push_back(max(mx1.back(), v1[i].second));
mn1.push_back(min(mn1.back(), v1[i].second));
}
mx2[(int)v2.size()] = mn2[(int)v2.size()] = 0;
for (int i = (int)v2.size() - 1; i >= 0; i--) {
mx2[i] = max(mx2[i + 1], v2[i].second);
mn2[i] = min(mn2[i + 1], v2[i].second);
}
}
const long long INF = 1000000000000000000LL;
bool ok(long long th) {
for (int i = (int)v2.size() - 1; i >= 0; i--) {
if (v2[i].first * v2[i].first > th) continue;
long long bb = max(-v2[i].first, (long long)ceil((double)v2[i].first -
sqrt((long double)th)));
int idx = lower_bound(v1.begin(), v1.end(),
pair<long long, long long>(bb, -INF)) -
v1.begin();
long long left = (idx == (int)v1.size()) ? 0 : v1[idx].first;
long long ymx, ymn;
if (idx == 0)
ymx = ymn = 0;
else
ymx = mx1[idx - 1], ymn = mn1[idx - 1];
ymx = max(ymx, mx2[i + 1]);
ymn = min(ymn, mn2[i + 1]);
long long maxnow = 0;
maxnow = max(maxnow, (ymx - ymn) * (ymx - ymn));
maxnow = max(maxnow, max(ymx, -ymn) * max(ymx, -ymn) +
max(-left, v2[i].first) * max(-left, v2[i].first));
if (maxnow <= th) return true;
}
for (int i = 0; i < (int)v1.size(); i++) {
if (v1[i].first * v1[i].first > th) continue;
long long bb = min(-v1[i].first, (long long)floor((double)v1[i].first +
sqrt((long double)th)));
int idx =
upper_bound(v2.begin(), v2.end(), pair<long long, long long>(bb, INF)) -
v2.begin() - 1;
long long left = (idx == -1) ? 0 : v2[idx].first;
long long ymx, ymn;
ymx = mx2[idx + 1], ymn = mn2[idx + 1];
if (i) ymx = max(ymx, mx1[i - 1]);
if (i) ymn = min(ymn, mn1[i - 1]);
long long maxnow = 0;
maxnow = max(maxnow, (ymx - ymn) * (ymx - ymn));
maxnow = max(maxnow, max(ymx, -ymn) * max(ymx, -ymn) +
max(left, -v1[i].first) * max(left, -v1[i].first));
if (maxnow <= th) return true;
}
for (int i = (int)v2.size() - 1; i >= 0; i--) {
if (v2[i].first * v2[i].first > th) continue;
long long bb = (long long)ceil((double)v2[i].first - sqrt((long double)th));
int idx = lower_bound(v1.begin(), v1.end(),
pair<long long, long long>(bb, -INF)) -
v1.begin();
long long left = (idx == (int)v1.size()) ? 0 : v1[idx].first;
long long ymx, ymn;
if (idx == 0)
ymx = ymn = 0;
else
ymx = mx1[idx - 1], ymn = mn1[idx - 1];
ymx = max(ymx, mx2[i + 1]);
ymn = min(ymn, mn2[i + 1]);
long long maxnow = 0;
maxnow = max(maxnow, (ymx - ymn) * (ymx - ymn));
maxnow = max(maxnow, max(ymx, -ymn) * max(ymx, -ymn) +
max(-left, v2[i].first) * max(-left, v2[i].first));
if (maxnow <= th) return true;
}
for (int i = 0; i < (int)v1.size(); i++) {
if (v1[i].first * v1[i].first > th) continue;
long long bb =
(long long)floor((double)v1[i].first + sqrt((long double)th));
int idx =
upper_bound(v2.begin(), v2.end(), pair<long long, long long>(bb, INF)) -
v2.begin() - 1;
long long left = (idx == -1) ? 0 : v2[idx].first;
long long ymx, ymn;
ymx = mx2[idx + 1], ymn = mn2[idx + 1];
if (i) ymx = max(ymx, mx1[i - 1]);
if (i) ymn = min(ymn, mn1[i - 1]);
long long maxnow = 0;
maxnow = max(maxnow, (ymx - ymn) * (ymx - ymn));
maxnow = max(maxnow, max(ymx, -ymn) * max(ymx, -ymn) +
max(left, -v1[i].first) * max(left, -v1[i].first));
if (maxnow <= th) return true;
}
return false;
}
void process() {
long long low = 0, high = 1000000000000000000LL;
high = min(high, (totmx[0] - totmn[0]) * (totmx[0] - totmn[0]));
high = min(high, (totmx[1] - totmn[1]) * (totmx[1] - totmn[1]));
while (low < high) {
long long mid = (low + high) / 2;
if (ok(mid))
high = mid;
else
low = mid + 1;
}
cout << low << endl;
}
int main() {
init();
process();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const int mod = 1000000007;
const int inf = 0x3f3f3f3f;
const int maxn = 2000100;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> a(n);
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
cout << max(*max_element((a).begin(), (a).end()), (sum - 1) / (n - 1) + 1)
<< "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long inv(long long i) {
if (i == 1) return 1;
return (mod - ((mod / i) * inv(mod % i)) % mod) % mod;
}
long long mod_mul(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long ceil_div(long long a, long long b) {
return a % b == 0 ? a / b : a / b + 1;
}
long long pwr(long long a, long long b) {
a %= mod;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t, n, i, j, ans, temp, sum, a, curr;
string sans;
t = 1;
while (t--) {
sans = "NO";
ans = temp = sum = 0;
cin >> a >> n;
vector<bool> perfectsq(10000001, false);
for (i = 1; i <= 4000; i++) {
if (i * i <= 10000000) {
perfectsq[i * i] = 1;
}
}
vector<long long> fac(10000000, 1);
for (i = 1; i <= 10000000; i++) {
if (perfectsq[i]) {
for (j = i; j <= 10000000; j += i) {
fac[j] = i;
}
}
}
for (i = 0; i <= n - 1; i++) {
ans += (a + i) / (fac[a + i]);
}
cout << ans;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long modl = 998244353;
const double pie = 3.1415926535;
unsigned long long power(unsigned long long x, unsigned long long y) {
if (y == 0)
return 1;
else {
if (y % 2 == 0)
return power(x * x, y / 2);
else
return x * power(x * x, (y - 1) / 2);
}
}
long long mod_power(long long x, long long y, long long m) {
long long r = 1;
x = x % m;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) r = (r * x) % m;
y = y / 2;
x = (x * x) % m;
}
return r;
}
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int TESTS = 1;
while (TESTS--) {
int n;
cin >> n;
long long arr[n + 1][n + 1];
memset(arr, 0, sizeof(arr));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i % 2 == 0) {
long long a = ((1LL) << (i + j - 3));
arr[i][j] = a;
} else
arr[i][j] = 0;
cout << arr[i][j] << " ";
}
cout << endl;
}
int q;
cin >> q;
long long x = 1, y = 1;
while (q--) {
long long z;
cin >> z;
while (x != n || y != n) {
cout << x << " " << y << endl;
if (x == n) {
y++;
continue;
}
if (y == n) {
x++;
continue;
}
if (x & (1LL)) {
long long kk = arr[x + 1][y] & z;
if (kk)
x++;
else
y++;
} else {
long long kk = arr[x][y + 1] & z;
if (kk)
y++;
else
x++;
}
}
cout << x << " " << y << endl;
x = 1, y = 1;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b, c;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
if (a[i] == 1) {
b = i;
} else if (a[i] == n)
c = i;
}
cout << max(max(b, c), max(n - b - 1, n - c - 1));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long n = s.size();
long long sum1 = 0, sum2 = 0, sum3 = 0, z = 0;
for (long long i = 0; i < n - 2; i++) {
if (((s[i] - '0' + s[i + 1] - '0' + s[i + 2] - '0') == 54) &&
(s[i] != s[i + 1] && s[i] != s[i + 2])) {
z = 1;
break;
}
}
if (z == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool isprime(int n) {
for (int i = 2; i <= sqrt(n); i++)
if (n % i == 0) return 0;
return 1;
}
void standardio() {
freopen("palindrome.in", "r", stdin);
freopen("palindrome.out", "w", stdout);
}
void weza() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
}
int arr[1000000];
int main() {
weza();
int n, m, x = 0;
char c;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> c;
if (c == 'Y' || c == 'M' || c == 'C') x++;
}
}
if (x == 0)
cout << "#Black&White" << endl;
else
cout << "#Color" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long w, h;
cin >> w >> h;
cout << (w + w % 2) * (w / 2) * (h + h % 2) * (h / 2) / 4;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100005], b[100005], ans, v1[100005], v2[100005], val[100005],
st[100005], hd, c1[100005], c2[100005];
inline int cal(int x) {
int i, j, res = 0, ret = 0;
for (i = 1; i <= n; ++i) v1[a[i]] = 0;
for (i = 1; i <= m; ++i) v2[b[i]] = 0;
for (i = 1; i <= n; ++i) ++v1[a[i]];
for (i = 1; i <= m; ++i) ++v2[b[i]];
for (i = 1; i <= n; ++i)
for (j = 1; j <= m; ++j)
if (a[i] + b[j] == x) ret += v1[a[i]] + v2[b[j]], v1[a[i]] = v2[b[j]] = 0;
hd = 0;
for (i = 1; i <= n; ++i) {
if (a[i] != a[i + 1])
for (j = 1; j <= m; ++j) {
if (b[j] != b[j + 1])
val[st[++hd] = a[i] + b[j]] += v1[a[i]] + v2[b[j]];
}
}
for (i = 1; i <= hd; ++i) {
res = max(res, val[st[i]]), val[st[i]] = 0;
}
return ret + res;
}
int i;
int main() {
cin >> n >> m;
for (i = 1; i <= n; ++i) cin >> a[i], a[i] += 10000;
for (i = 1; i <= m; ++i) cin >> b[i], b[i] += 10000;
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
a[n + 1] = -1;
b[m + 1] = -1;
for (i = 0; i <= 40000; ++i) {
ans = max(ans, cal(i));
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
if (i % 4 < 2)
cout << "a";
else
cout << "b";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int _ = 1e2;
const int maxn = 5e5 + _;
inline int read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x;
}
struct edge {
int x, y, l, r;
edge() {}
edge(int X, int Y, int L, int R) { x = X, y = Y, l = L, r = R; }
};
struct cmp {
bool operator()(edge x, edge y) { return x.l > y.l; }
};
priority_queue<edge, vector<edge>, cmp> q;
struct node {
int y, r, next;
} a[4 * maxn];
int len, last[2][maxn];
void ins(int op, int x, int y, int r) {
a[++len].y = y;
a[len].r = r;
a[len].next = last[op][x];
last[op][x] = len;
}
int f[2][maxn];
int main() {
int n, m, x, y, l, r;
edge p;
n = read(), m = read();
if (n == 1) {
puts("0");
return 0;
}
for (int i = 1; i <= m; i++) {
x = read(), y = read(), l = read(), r = read() - 1;
if (l == r)
q.push(edge(x, y, l, r)), q.push(edge(y, x, l, r));
else {
p = edge(x, y, l, r - (r - l) % 2);
q.push(p);
p = edge(y, x, l, r - (r - l) % 2);
q.push(p);
p = edge(x, y, l + 1, r - (r - l - 1) % 2);
q.push(p);
p = edge(y, x, l + 1, r - (r - l - 1) % 2);
q.push(p);
}
}
memset(f, -63, sizeof(f));
f[0][1] = 0;
while (!q.empty()) {
p = q.top();
q.pop();
int x = p.x, y = p.y, op = p.l & 1;
if (f[op][x] >= p.l) {
if (y == n) {
printf("%d\n", p.l + 1);
return 0;
}
f[op ^ 1][y] = max(f[op ^ 1][y], p.r + 1);
for (int k = last[op ^ 1][y]; k; k = a[k].next)
if (p.l + 1 <= a[k].r) q.push(edge(y, a[k].y, p.l + 1, a[k].r));
last[op ^ 1][y] = 0;
} else
ins(op, x, y, p.r);
}
puts("-1");
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[105][3];
long long int first(long long int second, long long int k, long long int d,
long long int ch) {
if (second == 0 and ch) return 1;
if (dp[second][ch] != -1) return dp[second][ch];
long long int ans = 0;
for (long long int i = 1; i <= k; i++) {
if (second >= i) {
if (i >= d)
ans += first(second - i, k, d, 1);
else
ans += first(second - i, k, d, ch);
}
ans %= 1000000007;
}
return dp[second][ch] = ans;
}
void solve() {
long long int n, k, d;
cin >> n >> k >> d;
memset(dp, -1, sizeof(dp));
cout << first(n, k, d, 0) << "\n";
}
int32_t main() {
long long int T = 1;
for (long long int t = 1; t <= T; t++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(int a) {
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(int a) {
if (a < 0) {
a = -a;
putchar('-');
}
write(a);
puts("");
}
int sg[65];
int n, ans;
int main() {
for (int i = 0; i <= 10; i++) sg[i * (i + 1) / 2] = i;
for (int i = 1; i <= 60; i++) {
if (!sg[i]) sg[i] = sg[i - 1];
}
n = read();
for (int i = 1; i <= n; i++) {
ans ^= sg[read()];
}
puts(ans ? "NO" : "YES");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[110];
int tp[26];
while (1 == scanf("%s", s)) {
memset(tp, -1, sizeof(tp));
int l = strlen(s);
int c = 0;
for (int i = 0; i < l; i++) {
if (tp[s[i] - 97] == -1) {
tp[s[i] - 97] = 1;
c++;
}
}
if (c % 2 == 1)
printf("IGNORE HIM!\n");
else
printf("CHAT WITH HER!\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using pii = std::pair<long long, long long>;
using namespace std;
const long long maxn = 3e5 + 5;
long long n, p, k, a[maxn];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> p >> k;
map<long long, long long> cnt;
for (long long i = 0; i < n; i++) {
cin >> a[i];
long long cursum = a[i];
cursum *= cursum;
cursum %= p;
cursum *= cursum;
cursum %= p;
cursum -= (k * a[i]);
cursum %= p;
cursum += p;
cursum %= p;
cnt[cursum]++;
}
long long ans = 0;
for (auto x : cnt) ans += (x.second * (x.second - 1)) / 2;
cout << ans << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, c, d;
cin >> a >> b >> c >> d;
double k;
k = (a / b) / (1 - (1 - (c / d)) * (1 - (a / b)));
cout << k;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> s;
int n = ((int)(s).size());
int q = 0;
for (int i = 0; i < (n); i++) q += s[i] == 'Q';
int r = 0;
while (r * r < q) r++;
if (r * r != q) return cout << "No" << endl, 0;
if (r == 0) return cout << "Yes" << endl, 0;
int cur = 0;
while (s[cur] != 'Q') cur++;
if (cur % 2) return cout << "No" << endl, 0;
string t = s.substr(cur / 2, r + (n - q) / (r + 1));
string res;
for (int i = 0; i < (((int)(t).size())); i++) {
if (t[i] == 'H')
res += 'H';
else
res += t;
}
cout << (res == s ? "Yes" : "No") << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int dx[4] = {-1, 1, 0, 0};
long long int dy[4] = {0, 0, -1, 1};
int32_t main(void) {
long long int t;
cin >> t;
while (t--) {
string s;
cin >> s;
map<pair<pair<long long int, long long int>,
pair<long long int, long long int> >,
long long int>
mp;
long long int ans = 0;
long long int x1 = 0, y1 = 0;
long long int x2 = 0, y2 = 0;
for (long long int i = 0; i < s.size(); i++) {
if (s[i] == 'N') y2++;
if (s[i] == 'S') y2--;
if (s[i] == 'E') x2++;
if (s[i] == 'W') x2--;
if (mp[{{x1, y1}, {x2, y2}}] || mp[{{x2, y2}, {x1, y1}}])
ans += 1;
else {
ans += 5;
mp[{{x1, y1}, {x2, y2}}] = 1;
mp[{{x2, y2}, {x1, y1}}] = 1;
}
x1 = x2, y1 = y2;
}
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void dbg() { cerr << endl; }
template <typename A, typename... B>
void dbg(A x, B... y) {
cerr << x << " ";
dbg(y...);
}
template <typename A, char ch = ' ', int width = 2>
void dbg_a(A x, size_t _length) {
if (ch == ' ') {
cerr << "i:";
for (int i = 0; i < _length; i++) cerr << setw(width) << i << ch;
cerr << endl;
}
cerr << "v:";
for (int i = 0; i < _length; i++) cerr << setw(width) << x[i] << ch;
cerr << endl;
}
template <typename T>
inline T str2int(string x) {
return stoi(x);
}
template <typename T>
string toString(T x) {
ostringstream stream;
stream << x;
return stream.str();
}
inline int getMid(int _a, int _b) { return _a + ((_b - _a) >> 1); }
int read() {
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch - '0');
ch = getchar();
}
return x * w;
}
const int maxn = 3e5 + 10;
int v[maxn];
int ans[maxn];
int dis[maxn];
int en[maxn];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
int __;
cin >> __;
while (__--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> v[i];
en[i] = 0;
dis[i] = 0;
ans[i] = -1;
}
for (int i = 1; i <= n; i++) {
int x = v[i];
dis[x] = max(dis[x], i - en[x]);
en[x] = i;
}
for (int i = 1; i <= n; i++) {
dis[i] = max(dis[i], n - en[i] + 1);
for (int j = dis[i]; j <= n && ans[j] == -1; j++) {
ans[j] = i;
}
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << (i == n ? "\n" : " ");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 400003;
long long nxt[MAX][20], sum[MAX][20], maxs[MAX][20], pa2[MAX][20], wei[MAX];
int q, cnt;
int qnt = 0;
void insert(int a, int w) {
int nn = ++cnt;
wei[nn] = w;
for (int i = (0); i <= (19); ++i) {
if (i == 0)
pa2[nn][i] = a;
else
pa2[nn][i] = pa2[pa2[nn][i - 1]][i - 1];
}
for (int i = (0); i <= (19); ++i) {
if (i == 0)
maxs[nn][i] = wei[nn];
else
maxs[nn][i] = std::max(maxs[nn][i - 1], maxs[pa2[nn][i - 1]][i - 1]);
}
int u = pa2[nn][0];
for (int i = (19); i >= (0); --i) {
if (u == 0) break;
if (maxs[u][i] < w) u = pa2[u][i];
}
nxt[nn][0] = u, sum[nn][0] = wei[nn];
for (int i = (1); i <= (19); ++i) {
nxt[nn][i] = nxt[nxt[nn][i - 1]][i - 1];
sum[nn][i] = sum[nn][i - 1] + sum[nxt[nn][i - 1]][i - 1];
}
}
long long pp[30];
long long query(long long a, long long x) {
long long ans = 0;
if (sum[a][19] <= x) {
ans = 1;
int i = 19;
for (; i >= 0; i--) {
if (nxt[a][i] != 0) ans += 1 << i, a = nxt[a][i];
}
} else {
for (int i = (19); i >= (0); --i) {
if (sum[a][i] <= x) {
x -= sum[a][i];
a = nxt[a][i];
ans += 1 << i;
}
}
}
return ans;
}
void print() {
for (int v = (1); v <= (5); ++v) {
for (int j = (0); j <= (19); ++j) {
printf(
"pa2[%d][%d] = %lld, maxs[%d][%d] = %lld, nxt[%d][%d] = %lld, "
"sum[%d][%d] = %lld\n",
v, j, pa2[v][j], v, j, maxs[v][j], v, j, nxt[v][j], v, j, sum[v][j]);
}
}
}
int main() {
scanf("%d", &q);
long long a, b, c, w, x;
long long last = 0;
cnt = 1;
while (q--) {
scanf("%lld%lld%lld", &a, &b, &c);
if (a == 1) {
w = last ^ c;
b = b ^ last;
insert(b, w);
} else {
x = last ^ c;
b = b ^ last;
long long ans = query(b, x);
printf("%lld\n", ans);
last = ans;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
long long pow_mod(long long p, long long k, long long mod) {
long long ans = 1;
while (k) {
if (k & 1) ans = ans * p;
if (ans > mod) ans = mod + ans % mod;
p = p * p;
if (p > mod) p = mod + p % mod;
k >>= 1;
}
return ans;
}
long long a[maxn], m[maxn];
int cnt = 0;
long long n, mm;
long long get_phi(long long x) {
long long ans = 1;
for (int i = 2; i * i <= x; i++) {
if (x % i) continue;
long long t = 1;
while (x % i == 0) x /= i, t *= i;
ans = ans * t / i * (i - 1);
}
if (x != 1) ans = ans * (x - 1);
return ans;
}
void init() {
m[0] = mm;
long long tmp = mm;
while (tmp > 1) {
m[++cnt] = get_phi(tmp);
tmp = m[cnt];
}
}
long long dfs(int l, int r, int now) {
if (m[now] == 1 || l == r) {
long long ans = a[l] < m[now] ? a[l] : (m[now] + a[l] % m[now]);
return a[l] < m[now] ? a[l] : (m[now] + a[l] % m[now]);
}
return pow_mod(a[l], dfs(l + 1, r, now + 1), m[now]);
}
int main() {
scanf("%lld%lld", &n, &mm);
init();
for (int i = 1; i <= n; i++) scanf("%lld", a + i);
int k;
scanf("%d", &k);
while (k--) {
int l, r;
scanf("%d%d", &l, &r);
printf("%lld\n", dfs(l, r, 0) % mm);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2005;
int n;
string s;
string answer = "";
int dp[MAXN][MAXN][2];
bool forbidden[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> s;
n = s.size();
if (n == 1) {
cout << "0" << '\n';
return 0;
}
for (int i = 0; i < n; i++) {
dp[i][i][s[i] - '0'] = 1;
for (int j = i + 1; j < n; j++) {
if (s[j] == '0') {
dp[i][j][0] = dp[i][j - 1][0] + 1;
dp[i][j][1] = dp[i][j - 1][1];
} else {
dp[i][j][0] = dp[i][j - 1][0];
dp[i][j][1] = max(dp[i][j - 1][0], dp[i][j - 1][1]) + 1;
}
}
}
answer = "0";
for (int i = 1; i < n; i++) {
answer += "0";
bool fail = false;
int zeroCnt = 0;
for (int j = i; j >= 0; j--) {
if (answer[j] == '0') zeroCnt++;
if (zeroCnt > max(dp[j][i][0], dp[j][i][1])) {
fail = true;
break;
}
}
if (fail == true) {
forbidden[i] = true;
for (int j = i - 1; j >= 0; j--) {
if (answer[j] == '0' && forbidden[j] == false) {
answer[j] = '1';
break;
}
}
}
}
cout << answer << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010, MOD = 1e9 + 7;
long long c[maxn][maxn], f[maxn], n, m;
long long b[maxn];
map<long long, long long> mp;
int main() {
scanf("%lld%lld", &m, &n);
for (int i = 0; i < n; i++) {
for (int j = 1; j <= m; j++) {
int x;
scanf("%1d", &x);
b[j] += (1ll * x) << i;
}
}
for (int i = 1; i <= m; i++) mp[b[i]]++;
for (int i = 0; i <= m; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % MOD;
}
f[0] = 1;
for (int i = 1; i <= m; i++) {
for (int j = 0; j < i; j++)
f[i] = (f[i] + 1ll * c[i - 1][j] * f[j] % MOD) % MOD;
}
long long ans = 1;
for (map<long long, long long>::iterator it = mp.begin(); it != mp.end();
it++)
ans = 1ll * ans * f[it->second] % MOD;
printf("%lld", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e6 + 3;
long long int POW(long long int base, long long int exp) {
long long int ans = 1;
while (exp) {
while (exp % 2 == 0) {
base = (base * base) % mod;
exp /= 2;
}
exp--;
ans = (ans * base) % mod;
}
return ans;
}
int main() {
long long int n, c;
cin >> n >> c;
long long int sum = c;
long long int k = c;
for (long long int i = 2; i <= n; i++) {
k = (k * ((i + c - 1) * POW(i, mod - 2)) % mod) % mod;
sum = (sum + k) % mod;
}
cout << sum << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<long long int, long long int> getans(string s) {
long long int a1 = 0, a2 = 0;
long long int n = s.length();
long long int c1 = 0, c2 = 1;
for (long long int i = 0; i < n; i++) {
long long int x = s[i] - 'A';
a1 += abs(c1 - x);
c1 = (c1 + 1) % 2;
a2 += abs(c2 - x);
c2 = (c2 + 1) % 2;
}
if (a1 <= a2)
return {a1, 0};
else
return {a2, 1};
}
char notthese(char c1, char c2) {
for (char i = 'A'; i <= 'Z'; i++) {
if (i != c1 && i != c2) return i;
}
return 'X';
}
void solve(long long int T) {
long long int n, k;
cin >> n >> k;
string s, p;
cin >> s;
p = s;
if (s.length() == 1) {
cout << 0 << endl;
cout << s << endl;
return;
}
if (k == 2) {
pair<long long int, long long int> p = getans(s);
cout << p.first << endl;
long long int x = p.second;
long long int ch = 'A';
for (long long int i = 0; i < n; i++) {
cout << char(ch + x);
x = (x + 1) % 2;
}
return;
}
for (long long int i = 1; i < n - 1; i++) {
if (s[i] == s[i - 1] && s[i] == s[i + 1]) {
if (s[i] == 'A')
s[i] = 'B';
else
s[i] = 'A';
}
}
for (long long int i = 1; i < n; i++) {
if (s[i] == s[i - 1]) {
if (i + 1 < n)
s[i] = notthese(s[i], s[i + 1]);
else {
if (s[i] == 'A')
s[i] = 'B';
else
s[i] = 'A';
}
}
}
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
if (s[i] != p[i]) {
ans++;
}
}
cout << ans << endl;
cout << s << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int T = 1;
for (long long int t = 1; t <= T; t++) {
solve(t);
}
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2005;
const int dx[10] = {0, 0, 0, 1, -1, 1, 1, -1, -1};
const int dy[10] = {0, 1, -1, 0, 0, -1, 1, -1, 1};
int n, area, sx, sy;
bool p[maxN][maxN], vis[maxN][maxN];
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) scanf("%d", &p[i][j]);
}
void fixNoise() {
int cnt;
for (int tme = 1; tme <= 5; ++tme)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
cnt = 0;
for (int k = 0; k <= 8; ++k) cnt += p[i + dx[k]][j + dy[k]];
if (cnt < 5)
p[i][j] = 0;
else
p[i][j] = 1;
}
}
void dfs(int x, int y) {
int xx, yy;
vis[x][y] = 1;
++area;
sx += x;
sy += y;
for (int i = 1; i <= 4; ++i) {
xx = x + dx[i];
yy = y + dy[i];
if (xx < 1 || yy < 1 || xx > n || yy > n || !p[xx][yy] || vis[xx][yy])
continue;
dfs(xx, yy);
}
}
void work() {
double ox, oy, r;
int circle = 0, rectangle = 0;
fixNoise();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (p[i][j] && !vis[i][j]) {
area = 0;
sx = 0;
sy = 0;
dfs(i, j);
if (area >= 158) {
ox = double(sx) / area;
oy = double(sy) / area;
r = ((i - ox) * (i - ox)) + ((j - oy) * (j - oy));
if (area / r > 2.9)
++circle;
else
++rectangle;
}
}
printf("%d %d\n", circle, rectangle);
}
int main() {
init();
work();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
int x = 0, y = 0;
for (int i = 0; i < n; i++) {
int v;
cin >> v;
if (v % 2 == 0) {
x++;
} else {
y++;
}
}
cout << min(x, y) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int cont = 0;
int n = 0;
string s;
cin >> n;
cin >> s;
for (int i = 1; i < n; i++) {
if (s[i] == s[i - 1]) {
cont++;
}
}
cout << cont << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long y, k, n;
cin >> y >> k >> n;
long long next = k * ((y / k) + 1);
bool ok = false;
while (next <= n) {
ok = true;
cout << next - y << " ";
next = next + k;
}
if (!ok) cout << -1;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long T;
T = 1;
while (T--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<string> v(4);
for (int i = 0; i < 4; ++i) cin >> v[i];
vector<bool> flag(4, false);
for (int i = 0; i < 4; ++i) {
bool temp1 = true, temp2 = true;
for (int j = 0; j < 4; ++j) {
if (i != j) {
if (!(v[i].size() - 2 >= 2 * (v[j].size() - 2))) temp1 = false;
if (!(2 * (v[i].size() - 2) <= v[j].size() - 2)) temp2 = false;
}
}
flag[i] = temp1 | temp2;
}
int count = 0;
for (int i = 0; i < 4; ++i) count += flag[i];
if (count != 1)
cout << "C";
else
for (int i = 0; i < 4; ++i)
if (flag[i]) cout << (char)('A' + i);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> nums(2 * n + 1);
for (int i = 0; i < 2 * n + 1; ++i) cin >> nums[i];
for (int i = 1; k > 0 && i < 2 * n; i += 2) {
if ((nums[i] - nums[i - 1]) > 1 && (nums[i] - nums[i + 1]) > 1) {
--k;
nums[i] -= 1;
}
}
for (auto& num : nums) cout << num << ' ';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500050;
const int inf = 0x3f3f3f3f;
const long long mod = 998244353LL;
clock_t TIME_START, TIME_END;
void program_end() {}
int a, b;
void solve() {
scanf("%d%d", &a, &b);
if (a < b)
puts("-1");
else if (a == b)
printf("%d\n", a);
else {
double down = floor((a + b) / 2.0 / b);
double up = floor((a - b) / 2.0 / b);
double ans = min((a + b) / down / 2.0, (a - b) / up / 2.0);
printf("%.12lf\n", ans);
}
}
int main() {
TIME_START = clock();
int Test = 1;
while (Test--) solve();
TIME_END = clock();
program_end();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first != b.first)
return a.first > b.first;
else
return a.second > b.second;
}
long long pow(long long base, long long x) {
long long ans = 1;
for (long long i = 1; i <= x; i++) ans *= base;
return ans;
}
int main() {
long long n, m;
cin >> n >> m;
long long x = (m + 1) / 2;
long long m1 = m;
vector<long long> v;
v.push_back(x);
m1--;
long long k = x - 1, j = x + 1;
if (m & 1) {
for (long long i = 1; i <= m1; i++) {
if (i & 1 && k != 0) {
v.push_back(k);
k--;
} else {
v.push_back(j);
j++;
}
}
} else {
for (long long i = 1; i <= m1; i++) {
if (i & 1 && j != m + 1) {
v.push_back(j);
j++;
} else {
v.push_back(k);
k--;
}
}
}
for (long long i = 0; i < n; i++) {
cout << v[i % m] << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define MAXN 200005
#define MAXK 17
int maxLen[MAXN][MAXK];
int nxt[MAXN][MAXK];
int start[MAXK];
int dp[MAXN];
void init(string s, int k){
vector <int> cur(k);
for(int i = 0; i < s.size(); i++){
if(s[i] == '?')
for(int j = 0; j < k; j++)
cur[j] += 1;
else{
int ch = s[i] - 'a';
for(int j = 0; j < k; j++)
if(j != ch)
cur[j] = 0;
else cur[j] += 1;
}
for(int j = 0; j < k; j++)
maxLen[i][j] = cur[j];
}
}
void prepare(int len, int k, string s){
for(int i = 0; i <= s.size(); i++)
for(int j = 0; j < k; j++)
nxt[i][j] = INT_MAX;
for(int j = 0; j < k; j++)
start[j] = INT_MAX;
for(int i = s.size()-1; i >= 0; i--){
for(int j = 0; j < k; j++){
nxt[i][j] = min(nxt[i][j], nxt[i+1][j]);
if(maxLen[i][j] >= len){
if(i >= len)
nxt[i - len][j] = min(nxt[i - len][j], i);
start[j] = min(start[j], i);
}
}
}
}
int get_bit(int val, int id){
return (val >> id)&1;
}
bool check(int n, int k, string s, int len){
prepare(len, k, s);
int maxState = (1<<k);
for(int state = 0; state < maxState; state++)
dp[state] = INT_MAX;
dp[0] = -1;
for(int state = 1; state < maxState; state++){
for(int i = 0; i < k; i++){
if(get_bit(state, i)){
int prestate = state - (1<<i);
int next_pos = INT_MAX;
if(prestate == 0)
next_pos = start[i];
else if(dp[prestate] < INT_MAX)
next_pos = nxt[dp[prestate]][i];
dp[state] = min(dp[state], next_pos);
}
}
}
return (dp[maxState-1] != INT_MAX);
}
int main(){
int n, k;
cin >> n >> k;
string s; cin >> s;
init(s, k);
int l = 0, r = n/k;
while(l <= r){
int mid = (l+r) >> 1;
if(check(n, k, s, mid))
l = mid + 1;
else
r = mid - 1;
}
cout << l - 1 << '\n';
} | 8 |
#include <bits/stdc++.h>
using namespace std;
const int SZ = 1e6 + 10;
const int INF = 1e9 + 10;
const int mod = 998244353;
const long double eps = 1e-8;
long long read() {
long long n = 0;
char a = getchar();
bool flag = 0;
while (a > '9' || a < '0') {
if (a == '-') flag = 1;
a = getchar();
}
while (a <= '9' && a >= '0') {
n = n * 10 + a - '0', a = getchar();
}
if (flag) n = -n;
return n;
}
struct haha {
int p, l, r;
};
bool cmpp(haha a, haha b) { return a.p < b.p; }
bool cmpl(haha a, haha b) { return a.l < b.l; }
bool cmpr(haha a, haha b) { return a.r < b.r; }
vector<haha> V, H;
int tree[SZ];
void add(int x, int d) {
x += 5001;
for (int i = x; i <= 10001; i += i & -i) tree[i] += d;
}
int ask(int x) {
x += 5001;
int ans = 0;
for (int i = x; i > 0; i -= i & -i) ans += tree[i];
return ans;
}
int ask(int l, int r) { return ask(r) - ask(l - 1); }
int main() {
int n = read();
for (int i = 1; i <= n; i++) {
int x1 = read(), y1 = read(), x2 = read(), y2 = read();
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
if (x1 == x2)
V.push_back((haha){x1, y1, y2});
else
H.push_back((haha){y1, x1, x2});
}
sort(H.begin(), H.end(), cmpp);
sort(V.begin(), V.end(), cmpr);
long long ans = 0;
for (int i = 0; i < H.size(); i++) {
for (int j = 0; j < V.size(); j++)
if (V[j].l <= H[i].p) add(V[j].p, 1);
int k = 0;
for (int j = i + 1; j < H.size(); j++) {
while (k < V.size()) {
if (V[k].l > H[i].p)
k++;
else {
if (V[k].r < H[j].p)
add(V[k].p, -1), k++;
else
break;
}
}
int l = max(H[i].l, H[j].l);
int r = min(H[i].r, H[j].r);
if (l > r) continue;
long long tmp = ask(l, r);
ans += tmp * (tmp - 1) / 2;
}
while (k < V.size()) {
if (V[k].l > H[i].p)
k++;
else {
add(V[k].p, -1), k++;
}
}
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct nod {
int dis;
int sum;
int s;
};
nod trees[300009];
vector<int> adj[300009];
int tree[300009];
int pa[300009];
int idx, mxlev, seltree, s;
int root(int a) {
while (a != tree[a]) {
tree[a] = tree[tree[a]];
a = tree[a];
}
return a;
}
void dfs(int x, int p, int lev) {
++s;
pa[x] = seltree;
if (lev > mxlev) idx = x, mxlev = lev;
for (int i = 0; i < adj[x].size(); ++i) {
if (adj[x][i] != p) dfs(adj[x][i], x, lev + 1);
}
}
int main() {
int n, m, q, a, b, c;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &a, &b);
--a, --b;
adj[b].push_back(a);
adj[a].push_back(b);
}
seltree = 1;
for (int i = 0; i < n; ++i) {
if (pa[i] == 0) {
tree[seltree] = seltree;
s = 0;
mxlev = -1;
dfs(i, i, 0);
trees[seltree].s = s;
mxlev = -1;
dfs(idx, idx, 0);
trees[seltree].sum = mxlev;
trees[seltree].dis = mxlev / 2 + mxlev % 2;
seltree++;
}
}
for (int i = 0; i < q; ++i) {
scanf("%d%d", &c, &a);
a = pa[a - 1];
if (c == 1)
printf("%d\n", trees[root(a)].sum);
else {
scanf("%d", &b);
b = pa[b - 1];
a = root(a), b = root(b);
if (a == b) continue;
if (trees[a].s > trees[b].s) swap(a, b);
trees[b].s += trees[a].s;
trees[b].sum = max(trees[a].sum, trees[b].sum);
trees[b].sum = max(trees[b].sum, trees[b].dis + trees[a].dis + 1);
trees[b].dis = min(max(1 + trees[a].dis, trees[b].dis),
max(trees[a].dis, 1 + trees[b].dis));
tree[a] = tree[b];
}
}
}
| 6 |
#include <bits/stdc++.h>
struct tpl {
int r, a, b;
};
std::string s[501];
std::pair<int, int> rx[501];
int memo[502][27][27];
tpl par[502][27][27];
int n, m;
int main(void) {
std::cin >> n >> m;
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= 26; j++) {
for (int k = 0; k <= 26; k++) {
memo[i][j][k] = 100000000;
par[i][j][k] = {i, j, k};
}
}
}
for (int i = 1; i <= n; i++) std::cin >> s[i];
for (int i = 0; i <= 26; i++) {
for (int j = 0; j <= 26; j++) memo[n + 1][i][j] = 0;
}
for (int i = n; i >= 1; i--) {
for (int j = 1; j <= 26; j++) {
for (int k = 1; k <= 26; k++) {
if (j != k) {
int d = 0;
for (int t = 0; t < m; t++) {
if (t & 1) {
if ((s[i][t] - 'a') != k - 1) d++;
} else {
if ((s[i][t] - 'a') != j - 1) d++;
}
}
if (m == 1) {
for (int a = 1; a <= 26; a++) {
if (j != a) {
if (d + memo[i + 1][a][0] < memo[i][j][0]) {
memo[i][j][0] =
std::min(memo[i][j][0], d + memo[i + 1][a][0]);
par[i][j][0] = {i + 1, a, 0};
}
}
}
} else {
for (int a = 1; a <= 26; a++) {
for (int b = 1; b <= 26; b++) {
if (a != b && j != a && k != b) {
if (d + memo[i + 1][a][b] < memo[i][j][k]) {
memo[i][j][k] =
std::min(memo[i][j][k], d + memo[i + 1][a][b]);
par[i][j][k] = {i + 1, a, b};
}
}
}
}
}
}
}
}
}
for (int j = 0; j <= 26; j++) {
for (int k = 0; k <= 26; k++) {
if (j != k) {
if (m == 1) {
if (memo[1][j][0] < memo[0][0][0]) {
memo[0][0][0] = memo[1][j][0];
par[0][0][0] = {1, j, 0};
}
} else {
if (memo[1][j][k] < memo[0][0][0]) {
memo[0][0][0] = memo[1][j][k];
par[0][0][0] = {1, j, k};
}
}
}
}
}
std::cout << memo[0][0][0] << "\n";
int r = 0, a = 0, b = 0;
while (par[r][a][b].r != n + 1) {
tpl x = par[r][a][b];
rx[x.r] = std::make_pair(x.a, x.b);
r = x.r;
a = x.a;
b = x.b;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (j & 1)
std::cout << (char)(rx[i].first - 1 + 'a');
else
std::cout << (char)(rx[i].second - 1 + 'a');
}
std::cout << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200 + 10;
const int MOD = 1E9 + 7;
const int INF = 0x3f3f3f3f;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int q;
cin >> q;
while (q--) {
long long int k, n, a, b;
cin >> k >> n >> a >> b;
cout << (k > b * n ? min((k - b * n - 1) / (a - b), n) : -1) << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105, MAXK = 25, MOD = 1000000007;
int N, K;
long long f[MAXN][MAXK << 1], zeros[MAXK << 1];
vector<int> eList[MAXN];
void DFS(int x, int father, long long fSib[]) {
int s = eList[x].size();
long long *p = zeros;
for (int i = 0; i < s; ++i) {
int y = eList[x][i];
if (y == father) continue;
DFS(y, x, p);
p = f[y];
}
for (int k = (K << 1); k >= 0; --k) f[x][k] = 0;
for (int i = (K << 1); i >= 0; --i) {
for (int j = (K << 1); j >= 0; --j) {
f[x][i + j + 2 <= (K << 1) ? min(i, j + 1) : max(i, j + 1)] +=
(fSib[i] * p[j]) % MOD;
f[x][i + 1 <= (K << 1) ? 0 : i] += (fSib[i] * p[j]) % MOD;
}
}
for (int k = (K << 1); k >= 0; --k) f[x][k] %= MOD;
}
int main() {
int x, y;
scanf("%d%d", &N, &K);
zeros[K] = 1;
for (int i = 1; i < N; ++i)
scanf("%d%d", &x, &y), eList[x].push_back(y), eList[y].push_back(x);
DFS(1, 0, zeros);
long long ans = 0;
for (int k = 0; k <= K; ++k) ans += f[1][k];
printf("%d\n", (int)(ans % MOD));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
double dp[500010][41];
int n, T, fa[500010];
void dfs(int x, int i, double tmp) {
if (i == 41) return;
if (x == 0) return;
double t = dp[x][i];
dp[x][i] *= tmp;
dfs(fa[x], i + 1, (dp[x][i] + 1) / (t + 1));
}
int main() {
scanf("%d", &T);
n = 1;
for (int i = 0; i <= 40; i++) dp[1][i] = 1;
while (T--) {
int op, v;
scanf("%d%d", &op, &v);
if (op == 1) {
n++;
fa[n] = v;
for (int i = 0; i <= 40; i++) dp[n][i] = 1;
double t = dp[v][0];
dp[v][0] *= 0.5;
dfs(fa[v], 1, (dp[v][0] + 1) / (t + 1));
} else {
double ans = 0;
for (int i = 1; i <= 40; i++)
ans += (double)i * (dp[v][i] - dp[v][i - 1]);
printf("%.10lf\n", ans);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bitset<100014> ck[45];
vector<int> v;
string name[50];
int n, m, cnt, bcnt, bf, best, p[54];
bool c[50][50];
vector<pair<int, int> > sorted;
void bfs(int h) {
bool nt = 0;
if (h > cnt) {
best = max(best, (int)v.size());
return;
}
for (int i = 0; i < v.size(); i++)
if (!c[v[i]][sorted[h - 1].second]) nt = 1;
if (!nt) {
v.push_back(sorted[h - 1].second);
bfs(h + 1);
v.pop_back();
}
if (v.size() + cnt - h > best) bfs(h + 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a == 1) {
if (bf == 2) bcnt++;
bf = 1;
} else {
string b;
cin >> b;
int fd = 0;
for (int i = 0; i <= cnt; i++)
if (name[i] == b) fd = i;
if (!fd) cnt++, name[cnt] = b, fd = cnt;
ck[fd][bcnt] = 1;
bf = 2;
}
}
for (int i = 1; i <= cnt; i++) sorted.push_back({ck[i].count(), i});
sort(sorted.begin(), sorted.end());
reverse(sorted.begin(), sorted.end());
for (int i = 1; i <= cnt; i++)
for (int j = i; j <= cnt; j++)
if ((ck[i] & ck[j]).count() == 0) c[i][j] = c[j][i] = 1;
bfs(1);
cout << best;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
pair<double, int> result[MAXN];
int main(void) {
int n, t1, t2, k;
cin >> n >> t1 >> t2 >> k;
for (int i = 0; i < n; i++) {
int speeda = 0, speedb = 0;
cin >> speeda >> speedb;
result[i].first =
max((speeda * t1) - (speeda * t1) * k / 100. + t2 * speedb,
(speedb * t1) - (speedb * t1) * k / 100. + t2 * speeda);
result[i].second = -i;
}
sort(result, result + n);
reverse(result, result + n);
for (int i = 0; i < n; i++) {
printf("%d %.2lf\n", -result[i].second + 1, result[i].first);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
;
int n, ct = 0;
string s;
cin >> n >> s;
for (char c : s) {
if (c == '(') {
cout << (ct & 1);
ct++;
} else {
ct--;
cout << (ct & 1);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& a) {
in >> a.first >> a.second;
return in;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2> a) {
out << a.first << " " << a.second;
return out;
}
template <typename T, typename T1>
T amax(T& a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T& a, T1 b) {
if (b < a) a = b;
return a;
}
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
const int32_t MM = 998244353;
void solve() {
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);
sort((a).begin(), (a).end(), greater<long long>());
if (n % 2 == 1) {
long long j = 0, i = 0;
for (; i < (n + 1) / 2; i++) {
b[j] = a[i];
j += 2;
}
j = 1;
for (; i < n; i++) {
b[j] = a[i];
j += 2;
}
} else if (n % 2 == 0) {
long long j = 0, i = 0;
for (; i < (n + 1) / 2; i++) {
b[j] = a[i];
j += 2;
}
j--;
b[j] = a[i];
i++;
j = 1;
for (; i < n; i++) {
b[j] = a[i];
j += 2;
}
}
long long ans = 0;
for (long long i = 1; i < n - 1; i++) {
if (b[i] < b[i - 1] && b[i] < b[i + 1]) ans++;
}
cout << ans << "\n";
for (long long i = 0; i < n; i++) {
cout << b[i] << " ";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int Mod = (int)1e9 + 7;
const int MX = 1073741822;
const long long MXLL = 9223372036854775807;
const int Sz = 1110111;
using namespace std;
inline void Read_rap() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
struct trie {
int e[2];
int cnt;
trie() {
memset(e, 0, sizeof e);
cnt = 0;
}
} t[Sz];
int N = 1;
const int L = 27;
int q;
inline void add(int x) {
int v = 1;
for (int i = L - 1; i >= 0; i--) {
int bit = (x & (1 << i)) > 0;
if (!t[v].e[bit]) t[v].e[bit] = ++N;
v = t[v].e[bit];
t[v].cnt++;
}
}
inline void del(int x) {
int v = 1;
for (int i = L - 1; i >= 0; i--) {
int bit = (x & (1 << i)) > 0;
v = t[v].e[bit];
t[v].cnt--;
}
}
inline int get(int p, int l) {
int res = 0;
int v = 1;
for (int i = L - 1; v && i >= 0; i--) {
int b1 = (p & (1 << i)) > 0, b2 = (l & (1 << i)) > 0;
if (b2) {
res += t[t[v].e[b1]].cnt;
v = t[v].e[b1 ^ 1];
} else {
v = t[v].e[b1];
}
}
return res;
}
int main() {
Read_rap();
cin >> q;
while (q--) {
int tp, p;
cin >> tp >> p;
if (tp == 1) add(p);
if (tp == 2) del(p);
if (tp == 3) {
int l;
cin >> l;
cout << get(p, l) << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename TP>
inline bool rd(TP& r) {
r = 0;
char tmp = getchar();
while (tmp < '0' || tmp > '9') {
if (tmp == EOF) return 0;
tmp = getchar();
}
while ('0' <= tmp && tmp <= '9') {
r = (r << 3) + (r << 1) + tmp - '0';
tmp = getchar();
}
return 1;
}
int n;
bool vis[1100];
int out[1100], tot;
long long ans[1100];
bool ask1() {
int lst = 0;
tot = 0;
bool done = 1;
for (int i = 1; i <= n; i++)
if (!vis[i]) done = 0;
if (done) return 0;
for (int i = 1; i <= n; i++)
if (vis[i]) {
for (int j = lst + 1; j <= ((lst + i) >> 1); j++) {
out[++tot] = j;
}
vis[(lst + i) >> 1] = 1;
lst = i;
}
printf("%d\n", tot);
for (int i = 1; i <= tot; i++) printf("%d ", out[i]);
printf("\n");
fflush(stdout);
int j = 1;
long long mn;
for (int i = 1; i <= n; i++) {
rd(mn);
if (i == out[j])
j++;
else
ans[i] = min(ans[i], mn);
}
return 1;
}
bool ask2() {
int lst = n + 1;
tot = 0;
bool done = 1;
for (int i = 1; i <= n; i++)
if (!vis[i]) done = 0;
if (done) return 0;
for (int i = n; i; i--)
if (vis[i]) {
for (int j = lst - 1; j >= ((lst + i) >> 1); j--) {
out[++tot] = j;
}
vis[(lst + i) >> 1] = 1;
lst = i;
}
printf("%d\n", tot);
for (int i = 1; i <= tot; i++) printf("%d ", out[i]);
printf("\n");
fflush(stdout);
int j = tot;
long long mn;
sort(out + 1, out + tot + 1);
for (int i = 1; i <= n; i++) {
rd(mn);
if (i == out[lower_bound(out + 1, out + tot + 1, i) - out])
j--;
else
ans[i] = min(ans[i], mn);
}
return 1;
}
int main() {
rd(n);
memset(ans, 0x3f, sizeof(ans));
memset(vis, 0, sizeof(vis));
vis[0] = 1;
vis[n] = 1;
while (1)
if (!ask1()) break;
memset(vis, 0, sizeof(vis));
vis[n + 1] = 1;
vis[1] = 1;
while (1)
if (!ask2()) break;
printf("-1\n");
for (int i = 1; i <= n; i++) printf("%I64d\n", ans[i]);
fflush(stdout);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
#pragma warning(disable : 4996)
#pragma hdrstop
template <typename T, size_t N>
struct MakeVector {};
template <typename T>
struct MakeVector<T, 1> {
template <typename R = std::vector<T>>
static R make_vector(std::size_t size, const T& value) {
return R(size, value);
}
};
using namespace std;
void solve(std::istream& in, std::ostream& out) {
int n;
long long k;
in >> n >> k;
long long cnt = (1LL << n) - 1;
int step = n;
while (k >= 1) {
long long half_cnt = cnt / 2;
if (k == half_cnt + 1) {
out << step << endl;
return;
}
if (k > half_cnt) {
k -= half_cnt + 1;
}
cnt /= 2;
--step;
}
}
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(0);
cin.tie(0);
istream& in = cin;
ostream& out = cout;
out << fixed << setprecision(16);
solve(in, out);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int p[N], en[N], n, m;
bool res[N];
stack<pair<int *, int>> cache;
struct Edge {
int u, v, w;
} e[N];
struct Query {
int id;
vector<Edge> v;
} que[N];
bool cmp(Edge x, Edge y) { return x.w < y.w; }
bool cmp2(const Query &x, const Query &y) { return x.v[0].w < y.v[0].w; }
void change(int &x, int y) {
cache.push(make_pair(&x, x));
x = y;
}
void roolback() {
while (!cache.empty()) {
auto u = cache.top();
(*u.first) = u.second;
cache.pop();
}
}
int find(int x) {
if (p[x] == x) return x;
int u = find(p[x]);
change(p[x], u);
return p[x];
}
void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
change(p[y], x);
}
int find1(int x) {
if (p[x] == x) return x;
int u = find1(p[x]);
p[x] = u;
return p[x];
}
void merge1(int x, int y) {
x = find1(x);
y = find1(y);
if (x == y) return;
p[y] = x;
}
bool calc(vector<Edge> &v) {
bool res = true;
for (auto u : v) {
if (find(u.u) == find(u.v))
res = false;
else
merge(u.u, u.v);
}
roolback();
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= m; i++) {
cin >> e[i].u >> e[i].v >> e[i].w;
}
int id = 0;
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
en[i - 1] = id;
int k;
cin >> k;
vector<Edge> v;
for (int i = 1; i <= k; i++) {
int u;
cin >> u;
v.push_back(e[u]);
}
sort(v.begin(), v.end(), cmp);
id++;
que[id].v.push_back(v[0]);
que[id].id = id;
for (int i = 1; i < v.size(); i++) {
if (v[i].w != v[i - 1].w) {
id++;
que[id].v.push_back(v[i]);
que[id].id = id;
} else {
que[id].v.push_back(v[i]);
}
}
}
en[q] = id;
sort(que + 1, que + id + 1, cmp2);
sort(e + 1, e + m + 1, cmp);
int cur = 1;
for (int i = 1; i <= id; i++) {
while (e[cur].w < que[i].v[0].w) {
merge1(e[cur].u, e[cur].v);
cur++;
}
bool u = calc(que[i].v);
res[que[i].id] = u;
}
for (int i = 1; i <= q; i++) {
int ans = 1;
for (int j = en[i - 1] + 1; j <= en[i]; j++) {
ans = ans & res[j];
}
if (ans)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[10000], d[10000];
int main() {
int n, ans = 0;
cin >> n;
for (register int i = 1; i <= n; i++) cin >> a[i] >> d[i];
for (register int i = 1; i <= n; i++) {
if (ans <= a[i])
ans += a[i] - ans + 1;
else if ((ans - a[i]) % d[i] == 0)
ans++;
else
ans += a[i] + ((ans - a[i]) / d[i] + 1) * d[i] - ans + 1;
}
cout << ans - 1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long x, n, c, i, sum;
int main() {
string one[] = {"one ", "two ", "three ", "four ",
"five ", "six ", "seven ", "eight ",
"nine ", "ten ", "eleven ", "twelve ",
"thirteen ", "fourteen ", "fifteen ", "sixteen ",
"seventeen ", "eighteen ", "nineteen "};
string ten[] = {"twenty", "thirty", "forty", "fifty",
"sixty", "seventy", "eighty", "ninety"};
cin >> n;
if (n == 0)
cout << "zero";
else {
if (n <= 19)
cout << one[n - 1];
else {
x = n / 10;
c = n % 10;
cout << ten[x - 2];
if (c != 0) {
cout << "-" << one[c - 1];
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
int cnt, k;
char l;
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie();
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'a' || s[i] == 'u' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'e') {
cnt = 0;
t += s[i];
l = 0;
k = 0;
} else {
cnt++;
if (l) {
if (l != s[i]) k = 1;
if (cnt >= 3 && k) {
t += ' ';
t += s[i];
cnt = 1;
l = s[i];
k = 0;
} else
t += s[i];
} else
l = s[i], t += s[i];
}
}
cout << t;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
namespace zzc {
const int maxn = 1e5 + 5;
int t, n;
int num[maxn], mx, cnt;
void work() {
scanf("%d", &t);
while (t--) {
mx = 0;
memset(num, 0, sizeof(num));
scanf("%d", &n);
for (int i = 1, x; i <= n; i++) {
scanf("%d", &x);
num[x]++;
}
for (int i = 1; i <= n; i++) {
if (num[i] > mx) {
mx = num[i];
cnt = 0;
} else if (num[i] == mx)
cnt++;
}
for (int i = 0; i <= n; i++) {
if ((i + 1) * mx - i + cnt > n) {
printf("%d\n", i - 1);
break;
}
}
}
}
} // namespace zzc
int main() {
zzc::work();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int a[101][101];
long long int res[101][101], tmp2[101][101];
const int mod = 1e9 + 7;
long long int mypow(long long int x, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res = res * x % mod;
x = x * x % mod;
b >>= 1;
}
return res;
}
void ex(int n, long long int b) {
for (int i = 0; i < n; i++) res[i][i] = 1;
while (b) {
if (b & 1) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) tmp2[i][j] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
tmp2[i][j] = (tmp2[i][j] + res[i][k] * a[k][j]) % mod;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) res[i][j] = tmp2[i][j];
}
b >>= 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) tmp2[i][j] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
tmp2[i][j] = (tmp2[i][j] + a[i][k] * a[k][j]) % mod;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) a[i][j] = tmp2[i][j];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) a[i][j] = res[i][j];
}
int v[101];
int c[101];
long long int cnt;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int N, k;
cin >> N >> k;
long long int tmp = N * (N - 1) / 2;
for (int i = 0; i < N; i++) cin >> v[i];
for (int i = 0; i < N; i++)
if (v[i] == 0) cnt++;
int tttmp = 0;
for (int i = cnt; i < N; i++)
if (v[i] == 1) tttmp++;
for (int j = 0; j <= N; j++) {
if (j > N - cnt || N - j - cnt > cnt) continue;
long long int now = tmp;
for (int i = 0; i <= N; i++) {
if (i == j - 1) {
now = ((now - (2 * cnt + j - N) * j) % mod + mod) % mod;
a[i][j] = ((2 * cnt + j - N) * j) % mod * mypow(tmp, mod - 2) % mod;
} else if (i == j + 1) {
now = ((now - (N - cnt - j) * (N - cnt - j)) % mod + mod) % mod;
a[i][j] =
((N - cnt - j) * (N - cnt - j) % mod * mypow(tmp, mod - 2)) % mod;
}
}
a[j][j] = now * mypow(tmp, mod - 2) % mod;
}
ex(N + 1, k);
cout << a[N - cnt][tttmp] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
inline int advPow(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = (long long)ret * a % MOD;
a = (long long)a * a % MOD;
b >>= 1;
}
return ret;
}
const int MAXK = 1000010;
int fac[MAXK];
inline int inverse(int a) { return advPow(a, MOD - 2); }
inline int C(int N, int M) {
if (M > N) return 0;
if (M < 0) return 0;
return (long long)fac[N] * inverse((long long)fac[M] * fac[N - M] % MOD) %
MOD;
}
int K, W;
inline long long calc() {
long long ans = 0;
for (int len = W; len <= W + K * 2; len++) {
if (len <= W * 2) {
long long t = (long long)C(K, len - W) * fac[len - W] % MOD;
ans += t * t % MOD * advPow(K, W * 2 - len) % MOD;
} else {
long long t = (long long)C(K - (len - W * 2), W) * fac[W] % MOD;
ans += t * t % MOD * C(K, len - W * 2) % MOD * fac[len - W * 2] % MOD;
}
int w = W - 1;
if (len <= w * 2) {
long long t = (long long)C(K, len - w) * fac[len - w] % MOD;
ans -= t * t % MOD * advPow(K, w * 2 - len) % MOD;
} else {
long long t = (long long)C(K - (len - w * 2), w) * fac[w] % MOD;
ans -= t * t % MOD * C(K, len - w * 2) % MOD * fac[len - w * 2] % MOD;
}
}
return (ans % MOD + MOD) % MOD;
}
int main() {
scanf("%d%d", &K, &W);
fac[0] = 1;
for (int i = 1; i < MAXK; i++) fac[i] = (long long)fac[i - 1] * i % MOD;
cout << calc() << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s, x;
int c = 0, a = 0;
cin >> s;
int n = s.size();
if (n == 1)
cout << "0" << endl;
else {
map<string, int> mp;
for (int i = 0; i < n; i++) {
x = s[i];
mp[x]++;
}
for (auto u : mp) {
if (u.second >= 2)
c++;
else if (u.second == 1)
a++;
}
c += (a / 2);
cout << c << endl;
c = 0, a = 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
const int N = 1e5 + 5;
bool ok = false;
int mid, lx, ly, first, second, n, down, up, level[N];
vector<pair<int, int>> g[N];
int dfs(int v, int size, int ¢er, int pr = 0) {
int sum = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i].first;
if (to != pr && level[to] == -1) {
sum += dfs(to, size, center, v);
}
}
if (center == -1 && sum >= size / 2) {
center = v;
}
return sum;
}
void dfscalc(int v, int sum, int len, vector<pair<int, int>> &cur,
int pr = -1) {
if (len > cur.size()) {
cur.push_back(make_pair(sum, v));
} else {
if (sum > cur[len - 1].first) {
cur[len - 1] = make_pair(sum, v);
}
}
if (len < up) {
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i].first;
int val = (g[v][i].second >= mid ? 1 : -1);
if (to != pr && level[to] == -1) {
dfscalc(to, sum + val, len + 1, cur, v);
}
}
}
}
bool cmp(vector<pair<int, int>> &a, vector<pair<int, int>> &b) {
return (a.size() < b.size());
}
void upd(pair<int, int> tree[], int first, pair<int, int> second) {
if (second.first > tree[first].first) {
tree[first] = second;
}
while (first > 1) {
first >>= 1;
if (tree[first + first].first > tree[first + first + 1].first) {
tree[first] = tree[first + first];
} else {
tree[first] = tree[first + first + 1];
}
}
}
pair<int, int> getmax(pair<int, int> tree[], int v, int lv, int rv, int l,
int r) {
if (lv > r || rv < l) {
return {-inf, -1};
}
if (lv >= l && rv <= r) {
return tree[v];
}
int mid = (lv + rv) / 2;
pair<int, int> q = getmax(tree, v + v, lv, mid, l, r);
pair<int, int> w = getmax(tree, v + v + 1, mid + 1, rv, l, r);
if (q.first > w.first) {
return q;
} else {
return w;
}
}
void calc(int v, int size) {
vector<vector<pair<int, int>>> a;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i].first;
int val = g[v][i].second >= mid ? 1 : -1;
if (level[to] == -1) {
vector<pair<int, int>> cur;
dfscalc(to, val, 1, cur, v);
a.push_back(cur);
}
}
if (a.size() == 0) {
return;
}
int treesize = size;
int sz = 1;
while (sz < treesize) {
sz <<= 1;
}
pair<int, int> tree[2 * sz];
for (int i = 1; i < 2 * sz; i++) {
tree[i] = {-inf, -1};
}
for (int i = 0; i < a.size(); i++) {
for (int j = 0; j < a[i].size(); j++) {
int len = j + 1;
if (a[i][j].first >= 0) {
if (len >= down && len <= up) {
ok = true;
first = v;
second = a[i][j].second;
return;
}
}
if (len < up && a.size() > 1) {
pair<int, int> tmp =
getmax(tree, 1, 1, sz, max(1, down - len), up - len);
if (a[i][j].first + tmp.first >= 0) {
ok = true;
first = tmp.second;
second = a[i][j].second;
return;
}
}
}
if (a.size() > 1) {
for (int j = 0; j < a[i].size(); j++) {
int len = j + 1;
upd(tree, len + sz - 1, {a[i][j].first, a[i][j].second});
}
}
}
}
void build(int v, int depth = 1) {
int tmp = 0, center = -1;
int size = dfs(v, 0, tmp);
dfs(v, size, center);
if (size < down) {
return;
}
level[center] = depth;
calc(center, size / 2 + 1);
for (int i = 0; i < g[center].size() && !ok; i++) {
int to = g[center][i].first;
if (level[to] == -1) {
build(to, depth + 1);
}
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> down >> up;
int mx = 0;
for (int i = 1; i < n; i++) {
int q, w, c;
cin >> q >> w >> c;
g[q].push_back(make_pair(w, c));
g[w].push_back(make_pair(q, c));
mx = max(mx, c);
}
int l = 0;
int r = mx;
int lx, ly;
while (l <= r) {
memset(level, -1, sizeof(level));
mid = (l + r) / 2;
ok = false;
build(1);
if (ok) {
l = mid + 1;
lx = first;
ly = second;
} else {
r = mid - 1;
}
}
cout << lx << " " << ly << "\n";
}
| 11 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.