solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167772160000")
using namespace std;
vector<pair<long long, long long> > tables;
long long oneSum = 0;
long long zeroSum = 0;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < 4; i++) {
char tmp;
int missO = 0, missZ = 0;
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
cin >> tmp;
int sum = j + k;
if (sum % 2 == 0) {
missO += (tmp == '0');
missZ += (tmp == '1');
} else {
missO += (tmp == '1');
missZ += (tmp == '0');
}
}
}
oneSum += missO;
zeroSum += missZ;
tables.push_back(make_pair(missO, missZ));
}
long long ans = 999999999999;
for (int i = 0; i < 4; i++) {
for (int j = i + 1; j < 4; j++) {
int miss = tables[i].first + tables[j].first;
int left = zeroSum - (tables[i].second + tables[j].second);
ans = min(ans, (long long)miss + (long long)left);
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int offset = 1 << 17;
const int LOG = 17;
class TwoSat {
int n;
vector<int> sol;
vector<bool> bio;
vector<int> comp;
vector<vector<int>> adj, rev;
stack<int> order;
public:
void add_variables(int vars) {
n += vars;
for (int i = 0; i < 2 * vars; i++) {
sol.push_back(0);
bio.push_back(false);
comp.push_back(0);
adj.push_back(vector<int>());
rev.push_back(vector<int>());
}
}
TwoSat(int _n) {
n = 0;
add_variables(_n);
}
TwoSat() {}
void add_edge(int u, int v) {
adj[u].push_back(v);
rev[v].push_back(u);
}
void add_implication(int u1, int neg1, int u2, int neg2) {
add_edge(2 * u1 + neg1, 2 * u2 + neg2);
add_edge(2 * u2 + !neg2, 2 * u1 + !neg1);
}
void set_variable(int u, bool val) { add_implication(u, val, u, !val); }
int at_most_one(const vector<pair<int, int>> &v) {
int sz = v.size();
add_variables(sz);
for (int i = 0; i < sz; i++) {
add_implication(v[i].first, v[i].second, n - i - 1, 0);
if (i) {
add_implication(n - i, 0, n - i - 1, 0);
add_implication(n - i, 0, v[i].first, !v[i].second);
}
}
return n - sz;
}
void dfs_forward(int x) {
bio[x] = true;
for (auto it : adj[x])
if (!bio[it]) dfs_forward(it);
order.push(x);
}
void dfs_backward(int x, int c) {
comp[x] = c;
for (auto it : rev[x])
if (!comp[it]) dfs_backward(it, c);
}
bool solve() {
for (int i = 0; i < 2 * n; i++)
if (!bio[i]) dfs_forward(i);
int ptr = 0;
for (; !order.empty(); order.pop())
if (!comp[order.top()]) dfs_backward(order.top(), ++ptr);
for (int i = 0; i < 2 * n; i++) {
if (comp[i] == comp[i ^ 1]) return false;
sol[i] = comp[i] > comp[i ^ 1];
}
return true;
}
int get(int u, int neg) { return sol[2 * u + neg]; }
};
int N, M;
TwoSat Edges;
int anc[MAXN][LOG];
int dep[MAXN], subtree[MAXN];
vector<int> adj[MAXN], ch[MAXN];
int head[MAXN], idx[MAXN], pos[MAXN];
vector<pair<int, int>> toDo[2 * offset];
vector<pair<int, int>> toRoot;
int chain, ptr;
void load() {
scanf("%d", &N);
for (int i = 1; i < N; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
}
int dfs_prep(int x, int p) {
anc[x][0] = p;
for (int i = 1; i < LOG; i++) anc[x][i] = anc[anc[x][i - 1]][i - 1];
subtree[x] = 1;
for (auto it : adj[x])
if (it != p) {
dep[it] = dep[x] + 1;
subtree[x] += dfs_prep(it, x);
ch[x].push_back(it);
}
return subtree[x];
}
void dfs_hld(int x) {
if (!head[chain]) head[chain] = x;
idx[x] = chain;
pos[x] = ptr++;
int heavy = 0;
for (auto it : ch[x])
if (subtree[it] > subtree[heavy]) heavy = it;
if (heavy) dfs_hld(heavy);
for (auto it : ch[x])
if (it != heavy) {
chain++;
dfs_hld(it);
}
}
void update(int x, int lo, int hi, int from, int to, pair<int, int> var) {
if (lo >= to || hi <= from) return;
if (lo >= from && hi <= to) {
toDo[x].push_back(var);
return;
}
int mid = (lo + hi) / 2;
update(2 * x, lo, mid, from, to, var);
update(2 * x + 1, mid, hi, from, to, var);
}
void update(int from, int to, pair<int, int> var) {
update(1, 0, offset, from, to, var);
}
void dfs_tour(int x) {
if (!toDo[x].empty()) toRoot.push_back({Edges.at_most_one(toDo[x]), 0});
if (x >= offset)
Edges.at_most_one(toRoot);
else {
dfs_tour(2 * x);
dfs_tour(2 * x + 1);
}
if (!toDo[x].empty()) toRoot.pop_back();
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int diff = dep[x] - dep[y];
for (int i = 0; i < LOG; i++)
if (diff >> i & 1) x = anc[x][i];
if (x == y) return x;
for (int i = LOG - 1; i >= 0; i--)
if (anc[x][i] != anc[y][i]) {
x = anc[x][i];
y = anc[y][i];
}
return anc[x][0];
}
void go_up(int x, int y, pair<int, int> var) {
while (1) {
if (idx[x] == idx[y]) {
update(pos[y] + 1, pos[x] + 1, var);
break;
}
update(pos[head[idx[x]]], pos[x] + 1, var);
x = anc[head[idx[x]]][0];
}
}
void add_path(int p, int q, pair<int, int> var) {
int l = lca(p, q);
go_up(p, l, var);
go_up(q, l, var);
}
void solve() {
dfs_prep(1, 0);
dfs_hld(1);
scanf("%d", &M);
Edges = TwoSat(M);
for (int i = 0; i < M; i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
add_path(a, b, {i, 0});
add_path(c, d, {i, 1});
}
dfs_tour(1);
if (!Edges.solve()) {
puts("NO");
return;
}
puts("YES");
for (int i = 0; i < M; i++) printf("%d\n", Edges.get(i, 1) + 1);
}
int main() {
load();
solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1000000007;
long long int inf = 1e15;
long long int powermod(long long int _a, long long int _b, long long int _m) {
long long int _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a) % _m;
_b /= 2;
_a = (_a * _a) % _m;
}
return _r;
}
long long int string_to_number(string s) {
long long int x = 0;
stringstream convert(s);
convert >> x;
return x;
}
long long int add(long long int a, long long int b) {
long long int x = (a + b) % MOD;
return x;
}
long long int mul(long long int a, long long int b) {
long long int x = (a * b) % MOD;
return x;
}
long long int sub(long long int a, long long int b) {
long long int x = (a - b + MOD) % MOD;
return x;
}
long long int divi(long long int a, long long int b) {
long long int x = a;
long long int y = powermod(b, MOD - 2, MOD);
long long int res = (x * y) % MOD;
return res;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
vector<long long int> arr(n);
for (int i = 0; i < k; i++) scanf("%lli", &arr[i]);
list<int> s;
for (int i = 1; i <= n; i++) s.push_back(i);
int pointer = 0;
list<int>::iterator it;
for (int i = 0; i < k; i++) {
int rem = (arr[i]) % n;
pointer = (pointer + rem) % n;
it = s.begin();
advance(it, pointer);
cout << (*it) << " ";
s.erase(it);
n--;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > forw(200001);
vector<vector<int> > backw(200001);
int a[200001];
long long ansb[200001], ansf[200001];
bool flagb[200001], flagf[200001];
void dfs(int pos, long long val, bool f) {
if (!f) {
if (flagb[pos]) {
ansb[pos] = -pos;
} else {
ansb[pos] = val + a[pos];
flagb[pos] = true;
for (int i = 0; i < backw[pos].size(); i++)
dfs(backw[pos][i], val + a[pos], !f);
}
} else {
if (flagf[pos]) {
ansf[pos] = -pos;
} else {
flagf[pos] = true;
ansf[pos] = val + a[pos];
for (int i = 0; i < forw[pos].size(); i++)
dfs(forw[pos][i], val + a[pos], !f);
}
}
}
int main(int argc, char* argv[]) {
memset(flagf, 0, sizeof(flagf));
memset(flagb, 0, sizeof(flagb));
memset(ansb, 0, sizeof(ansb));
memset(ansf, 0, sizeof(ansf));
int n;
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 2; i <= n; i++) {
if (i - a[i] > 0) forw[i - a[i]].push_back(i);
if (i + a[i] <= n) backw[i + a[i]].push_back(i);
}
for (int i = 2; i <= n; i++) {
if (i - a[i] <= 0) {
dfs(i, 0, 0);
}
if (i + a[i] > n) dfs(i, 0, 1);
}
for (int i = 2; i <= n; i++) {
if (ansb[i] == 0)
cout << -1 << endl;
else
cout << ansb[i] + i - 1 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> fav(1e5 + 5, 0), cnt(1e5 + 5, 0), incr(k + 3, 0);
for (int i = 1; i <= k * n; i++) {
int x;
cin >> x;
cnt[x]++;
}
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
fav[x]++;
}
incr[0] = 0;
for (int i = 1; i <= k; i++) {
cin >> incr[i];
}
int ans = 0;
for (int i = 1; i <= 100000; i++) {
int dp[fav[i] + 3][cnt[i] + 3];
for (int p = 0; p <= fav[i]; p++) {
for (int q = 0; q <= cnt[i]; q++) {
dp[p][q] = 0;
}
}
for (int p = 1; p <= fav[i]; p++) {
for (int q = 0; q <= cnt[i]; q++) {
for (int r = 0; r <= k; r++) {
if (q - r < 0) {
continue;
}
dp[p][q] = max(dp[p][q], dp[p - 1][q - r] + incr[r]);
}
}
}
ans += dp[fav[i]][cnt[i]];
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int M = 800000 + 10;
const double pi = acos(-1);
struct vir {
double r, i;
vir(double r = 0.0, double i = 0.0) : r(r), i(i) {}
void print() { printf("%f %f\n", r, i); }
vir operator+(const vir &c) { return vir(r + c.r, i + c.i); }
vir operator-(const vir &c) { return vir(r - c.r, i - c.i); }
vir operator*(const vir &c) {
return vir(r * c.r - i * c.i, r * c.i + i * c.r);
}
} a[M], b[M], w[2][M];
struct FFT {
int N, na, nb, rev[M];
void fft(vir *a, int f) {
vir x, y;
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)
for (int j = 0, t = N / (i << 1); j < N; j += i << 1)
for (int k = 0, l = 0; k < i; k++, l += t)
x = w[f][l] * a[j + k + i], y = a[j + k], a[j + k] = y + x,
a[j + k + i] = y - x;
if (f)
for (int i = (0); i < (N); i++) a[i].r /= N;
}
void work() {
int d = __builtin_ctz(N);
for (int i = (0); i < (N); i++) {
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (d - 1));
w[1][i] = w[0][i] = vir(cos(2 * pi * i / N), sin(2 * pi * i / N));
w[1][i].i = -w[1][i].i;
}
}
void doit(vir *a, vir *b, int na, int nb) {
for (N = 1; N < na + nb - 1; N <<= 1)
;
for (int i = (na); i < (N); i++) a[i] = vir(0, 0);
for (int i = (nb); i < (N); i++) b[i] = vir(0, 0);
work(), fft(a, 0), fft(b, 0);
for (int i = (0); i < (N); i++) a[i] = a[i] * b[i];
fft(a, 1);
}
} fft;
int id(char a) {
if (a == 'A')
return 0;
else if (a == 'T')
return 1;
else if (a == 'C')
return 2;
else
return 3;
}
int ans[M];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
string s, t;
cin >> s >> t;
reverse(t.begin(), t.end());
for (int q = (0); q < (4); q++) {
for (int i = (0); i < (m); i++) {
if (id(t[i]) == q)
b[i] = vir(1, 0);
else
b[i] = vir(0, 0);
}
int last = -1e9;
for (int i = (0); i < (k); i++)
if (id(s[i]) == q) last = i;
for (int i = (0); i < (n); i++) {
if (i + k < n && id(s[i + k]) == q) last = i + k;
if (abs(last - i) <= k) {
a[i] = vir(1, 0);
} else {
a[i] = vir(0, 0);
}
}
fft.doit(a, b, n, m);
for (int i = (0); i < (fft.N); i++) ans[i] += (int)((a[i].r) + 0.5);
}
int res = 0;
for (int i = (m - 1); i < (n + 1); i++)
if (ans[i] == m) res++;
cout << res << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, g, ans;
long long a[105];
long long Map[102][300005];
long long goes(long long n, long long k) {
if (k == 0) return n;
if (n > 300000) return goes(n, k - 1) - goes(n / a[k - 1], k - 1);
if (Map[k][n] == -1) Map[k][n] = goes(n, k - 1) - goes(n / a[k - 1], k - 1);
return Map[k][n];
}
int main() {
cin >> n >> k;
for (int i = 0; i < k; ++i) cin >> a[i];
sort(a, a + k);
memset(Map, -1, sizeof(Map));
cout << goes(n, k) << endl;
}
| 9 |
#include <bits/stdc++.h>
long long a, b, c, d;
long long r[100];
long long p[100];
void s1() {
int i = 1;
r[i++] = a * b * c + d;
r[i++] = (a * b + c) * d;
r[i++] = (a + b) * c * d;
r[i++] = a * b * d + c;
r[i++] = (a * b + d) * c;
r[i++] = (a + b) * d * c;
r[i++] = a * c * b + d;
r[i++] = (a * c + b) * d;
r[i++] = (a + c) * b * d;
r[i++] = a * c * d + b;
r[i++] = (a * c + d) * b;
r[i++] = (a + c) * d * b;
r[i++] = a * d * b + c;
r[i++] = (a * d + b) * c;
r[i++] = (a + d) * b * c;
r[i++] = a * d * c + b;
r[i++] = (a * d + c) * b;
r[i++] = (a + d) * c * b;
r[i++] = b * a * c + d;
r[i++] = (b * a + c) * d;
r[i++] = (b + a) * c * d;
r[i++] = b * a * d + c;
r[i++] = (b * a + d) * c;
r[i++] = (b + a) * d * c;
r[i++] = b * c * a + d;
r[i++] = (b * c + a) * d;
r[i++] = (b + c) * a * d;
r[i++] = b * c * d + a;
r[i++] = (b * c + d) * a;
r[i++] = (b + c) * d * a;
r[i++] = b * d * a + c;
r[i++] = (b * d + a) * c;
r[i++] = (b + d) * a * c;
r[i++] = b * d * c + a;
r[i++] = (b * d + c) * a;
r[i++] = (b + d) * c * a;
r[i++] = c * a * b + d;
r[i++] = (c * a + b) * d;
r[i++] = (c + a) * b * d;
r[i++] = c * a * d + b;
r[i++] = (c * a + d) * b;
r[i++] = (c + a) * d * b;
r[i++] = c * b * a + d;
r[i++] = (c * b + a) * d;
r[i++] = (c + b) * a * d;
r[i++] = c * b * d + a;
r[i++] = (c * b + d) * a;
r[i++] = (c + b) * d * a;
r[i++] = c * d * a + b;
r[i++] = (c * d + a) * b;
r[i++] = (c + d) * a * b;
r[i++] = c * d * b + a;
r[i++] = (c * d + b) * a;
r[i++] = (c + d) * b * a;
r[i++] = d * a * b + c;
r[i++] = (d * a + b) * c;
r[i++] = (d + a) * b * c;
r[i++] = d * a * c + b;
r[i++] = (d * a + c) * b;
r[i++] = (d + a) * c * b;
r[i++] = d * b * a + c;
r[i++] = (d * b + a) * c;
r[i++] = (d + b) * a * c;
r[i++] = d * b * c + a;
r[i++] = (d * b + c) * a;
r[i++] = (d + b) * c * a;
r[i++] = d * c * a + b;
r[i++] = (d * c + a) * b;
r[i++] = (d + c) * a * b;
r[i++] = d * c * b + a;
r[i++] = (d * c + b) * a;
r[i++] = (d + c) * b * a;
}
void s2() {
int k = 1;
p[k++] = a * b + c + d;
p[k++] = (a + b) * c + d;
p[k++] = (a + b + c) * d;
p[k++] = a * b + d + c;
p[k++] = (a + b) * d + c;
p[k++] = (a + b + d) * c;
p[k++] = a * c + b + d;
p[k++] = (a + c) * b + d;
p[k++] = (a + c + b) * d;
p[k++] = a * c + d + b;
p[k++] = (a + c) * d + b;
p[k++] = (a + c + d) * b;
p[k++] = a * d + b + c;
p[k++] = (a + d) * b + c;
p[k++] = (a + d + b) * c;
p[k++] = a * d + c + b;
p[k++] = (a + d) * c + b;
p[k++] = (a + d + c) * b;
p[k++] = b * a + c + d;
p[k++] = (b + a) * c + d;
p[k++] = (b + a + c) * d;
p[k++] = b * a + d + c;
p[k++] = (b + a) * d + c;
p[k++] = (b + a + d) * c;
p[k++] = b * c + d + a;
p[k++] = (b + c) * d + a;
p[k++] = (b + c + d) * a;
p[k++] = b * c + a + d;
p[k++] = (b + c) * a + d;
p[k++] = (b + c + a) * d;
p[k++] = b * d + a + c;
p[k++] = (b + d) * a + c;
p[k++] = (b + d + a) * c;
p[k++] = b * d + c + a;
p[k++] = (b + d) * c + a;
p[k++] = (b + d + c) * a;
p[k++] = c * a + b + d;
p[k++] = (c + a) * b + d;
p[k++] = (c + a + b) * d;
p[k++] = c * a + d + b;
p[k++] = (c + a) * d + b;
p[k++] = (c + a + d) * b;
p[k++] = c * b + d + a;
p[k++] = (c + b) * d + a;
p[k++] = (c + b + d) * a;
p[k++] = c * b + a + d;
p[k++] = (c + b) * a + d;
p[k++] = (c + b + a) * d;
p[k++] = c * d + a + b;
p[k++] = (c + d) * a + b;
p[k++] = (c + d + a) * b;
p[k++] = c * d + b + a;
p[k++] = (c + d) * b + a;
p[k++] = (c + d + b) * a;
p[k++] = d * a + b + c;
p[k++] = (d + a) * b + c;
p[k++] = (d + a + b) * c;
p[k++] = d * a + c + b;
p[k++] = (d + a) * c + b;
p[k++] = (d + a + c) * b;
p[k++] = d * b + a + c;
p[k++] = (d + b) * a + c;
p[k++] = (d + b + a) * c;
p[k++] = d * b + c + a;
p[k++] = (d + b) * c + a;
p[k++] = (d + b + c) * a;
p[k++] = d * c + b + a;
p[k++] = (d + c) * b + a;
p[k++] = (d + c + b) * a;
p[k++] = d * c + a + b;
p[k++] = (d + c) * a + b;
p[k++] = (d + c + a) * b;
}
int main() {
while (~scanf("%lld%lld%lld%lld", &a, &b, &c, &d)) {
char x, y, z;
int w = 0;
scanf(" %c %c %c", &x, &y, &z);
if (x == '*') w++;
if (y == '*') w++;
if (z == '*') w++;
if (w == 3) printf("%lld\n", a * b * c * d);
if (w == 0) printf("%lld\n", a + b + c + d);
if (w == 1) {
s2();
if (x == '*' && y == '+' && z == '+') {
long long h = p[1];
for (int i = 1; i <= 72; i++) {
if (i % 3 == 1) {
if (h > p[i]) h = p[i];
}
}
r[73] = a * b + c + d;
r[74] = a * c + b + d;
r[75] = a * d + c + b;
r[76] = b * c + a + d;
r[77] = d * b + c + a;
r[78] = c * d + a + b;
for (int i = 73; i <= 78; i++) {
if (h > r[i]) h = r[i];
}
printf("%lld\n", h);
}
if (x == '+' && y == '*' && z == '+') {
long long h = p[2];
for (int i = 1; i <= 72; i++) {
if (i % 3 == 2) {
if (h > p[i]) h = p[i];
}
}
r[73] = a + b + c * d;
r[74] = a + c + b * d;
r[75] = a + d + c * b;
r[76] = c + b + a * d;
r[77] = d + b + c * a;
r[78] = c + d + a * b;
for (int i = 73; i <= 78; i++) {
if (h > r[i]) h = r[i];
}
printf("%lld\n", h);
}
if (x == '+' && y == '+' && z == '*') {
long long h = p[3];
for (int i = 1; i <= 72; i++) {
if (i % 3 == 0) {
if (h > p[i]) h = p[i];
}
}
r[73] = (a + b) * (c + d);
r[74] = (a + c) * (b + d);
r[75] = (a + d) * (c + b);
r[76] = (b + c) * (a + d);
r[77] = (d + b) * (c + a);
r[78] = (c + d) * (a + b);
for (int i = 73; i <= 78; i++) {
if (h > r[i]) h = r[i];
}
printf("%lld\n", h);
}
}
if (w == 2) {
s1();
if (x == '*' && y == '*' && z == '+') {
long long h = r[1];
for (int i = 1; i <= 72; i++) {
if (i % 3 == 1) {
if (h > r[i]) h = r[i];
}
}
r[73] = a * b + c * d;
r[74] = a * c + b * d;
r[75] = a * d + b * c;
for (int i = 73; i <= 75; i++) {
if (h > r[i]) h = r[i];
}
printf("%lld\n", h);
}
if (x == '*' && y == '+' && z == '*') {
long long h = r[2];
for (int i = 1; i <= 72; i++) {
if (i % 3 == 2) {
if (h > r[i]) h = r[i];
}
}
r[73] = a * b * (c + d);
r[74] = a * c * (b + d);
r[75] = a * d * (b + c);
r[76] = b * c * (a + d);
r[77] = b * d * (a + c);
r[78] = c * d * (a + b);
for (int i = 73; i <= 78; i++) {
if (h > r[i]) h = r[i];
}
printf("%lld\n", h);
}
if (x == '+' && y == '*' && z == '*') {
long long h = r[3];
for (int i = 1; i <= 72; i++) {
if (i % 3 == 0) {
if (h > r[i]) h = r[i];
}
}
r[73] = (a + b) * (c * d);
r[74] = (a + c) * (b * d);
r[75] = (a + d) * (c * b);
r[76] = (c + b) * (a * d);
r[77] = (d + b) * (c * a);
r[78] = (c + d) * (a * b);
for (int i = 73; i <= 78; i++) {
if (h > r[i]) h = r[i];
}
printf("%lld\n", h);
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, 1, -1, 0, 0, -1, 1};
int dx4[] = {0, 0, 1, -1};
int dy4[] = {1, -1, 0, 0};
const long long MOD = 1000000007;
template <typename T>
inline T Bigmod(T base, T power, T MOD) {
T ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % MOD;
base = (base * base) % MOD;
power >>= 1;
}
return ret;
}
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
const int maxn = 10000007;
int prime[100005];
int nprime;
int mark[(maxn / 32) + 2];
bool check(int n, int pos) { return (bool)(n & (1 << pos)); }
int sett(int n, int pos) { return n = n | (1 << pos); }
void seive() {
int limit = sqrt(maxn) + 3;
nprime = 1;
prime[nprime] = 2;
for (int i = 3; i <= limit; i += 2) {
if (check(mark[i >> 5], i & 31) == 0) {
for (int j = i * i; j <= maxn; j += 2 * i) {
mark[j >> 5] = sett(mark[j >> 5], j & 31);
}
}
}
for (int i = 3; i < maxn && nprime <= 100000; i += 2) {
if (check(mark[i >> 5], i & 31) == 0) {
prime[++nprime] = i;
}
}
}
int main() {
ios::sync_with_stdio(false);
int n;
seive();
while (cin >> n) {
for (int i = 1; i <= n; i++) {
cout << prime[i] << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[2002], s[2002];
int find_answer() {
int res = 0, cur = 0, k = -1;
for (int i = 0; i < n; ++i) {
cur += a[i];
if (cur < 0) cur = 0, k = i;
res = max(res, (i - k) * cur);
}
return res;
}
int find_my_answer() {
s[0] = a[0];
for (int i = 1; i < n; ++i) s[i] = s[i - 1] + a[i];
int res = s[n - 1] * n;
for (int i = 1; i < n; ++i) res = max(res, (s[n - 1] - s[i - 1]) * (n - i));
return res;
}
int main() {
int k;
scanf("%d", &k);
if (k + 2 <= 1000000) {
printf("2\n-1 %d", k + 2);
return 0;
}
for (n = 3; n <= 2000; ++n) {
int x = k, y = 0;
while (x % (n - 1)) x += n, ++y;
if (x / (n - 1) > 1000000) continue;
a[n - 1] = x / (n - 1);
for (int i = n - 2, j = 0; i >= 0; --i, ++j) {
if (y % (n - 1) == 0)
a[i] = -y / (n - 1);
else if (j < y % (n - 1))
a[i] = -(y / (n - 1) + 1);
else
a[i] = -(y / (n - 1));
}
if (find_answer() + k == find_my_answer()) {
printf("%d\n", n);
for (int i = 0; i < n; ++i) printf("%d%c", a[i], " \n"[i == n - 1]);
return 0;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define forn(i,n) rep(i,0,n)
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define mp make_pair
#define sz(x) (int)(x).size()
#define fi first
#define se second
#define endl "\n"
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define memf(a) memset(a,false,sizeof(a))
#define memt(a) memset(a,true,sizeof(a))
//#define int long long
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<pii> vpi;
typedef vector<vi> vvi;
typedef long long ll;
const int mod = 1000000007;
void solve(){
int n,k;
cin >> n >> k;
vi v(n);
forn(i,n) cin >> v[i];
if(k == 0){
cout << n << endl;
return;
}
sort(all(v));
bool flag = true;
int num = -1;
forn(i,n){
if(v[i] != i){
flag = false;
num = i;
break;
}
}
if(!flag){
int temp = ceil((double)(num + v[n-1]) / 2);
auto it = find(all(v),temp);
if(it == v.end()){
cout << n+1 << endl;
}
else{
cout << n << endl;
}
}
else{
cout << n+k << endl;
}
}
signed main(){
IOS;
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
int tt = 1;
cin >> tt;
while(tt--)
solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 29;
int a[200010];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
long long sum = 0;
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (sum - (long long)a[i] * (n - i) * cnt >= k) {
cnt++;
sum += (long long)a[i] * (cnt - 1);
} else
printf("%d\n", i);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, t, arr[209][209], brr[209][209], crr[209];
vector<long long int> v;
int main() {
scanf("%lld", &t);
while (t--) {
long long int m;
scanf("%lld %lld", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) scanf("%lld", &arr[i][j]), brr[i][j] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i % 2 == j % 2) {
if (arr[i][j] % 2 == 0) arr[i][j]++;
} else {
if (arr[i][j] % 2) arr[i][j]++;
}
printf("%lld ", arr[i][j]);
}
printf("\n");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t > 0) {
int a, b, c, d, k, x, y;
cin >> a >> b >> c >> d >> k;
if (a % c == 0)
x = a / c;
else
x = (a / c) + 1;
if (b % d == 0)
y = b / d;
else
y = (b / d) + 1;
if (x + y <= k) {
cout << x << " " << y << endl;
} else {
cout << "-1" << endl;
}
t--;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int q, n;
unsigned long long int sp;
int main() {
cin >> q;
while (q--) {
cin >> n;
vector<int> s;
bool f = false;
for (int i = 0; i < n; ++i) {
cin >> sp;
if (sp < 2048)
s.push_back(log2(sp));
else if (sp == 2048)
f = true;
}
if (f) {
cout << "YES"
<< "\n";
continue;
}
bool v[11] = {false};
for (int i = 0; i < s.size(); ++i) {
if (v[s[i]]) {
for (int j = s[i]; j < 11; ++j) {
if (v[j]) {
v[j] = false;
if (j == 10) {
f = true;
break;
}
} else {
v[j] = true;
break;
}
}
} else
v[s[i]] = true;
if (f) break;
}
if (f)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, x, y;
set<int> st;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x;
for (int j = 0; j < x; j++) {
cin >> y;
st.insert(y);
}
}
cout << (st.size() == m ? "YES" : "NO");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool visited[100000];
bool player[100000];
vector<vector<int> > graph;
bool valid = true;
int vcount = 0;
void visit(int pos) {
if (player[pos]) vcount++;
for (auto s : graph[pos]) {
if (valid && visited[s])
valid = player[s] != player[pos];
else if (valid) {
visited[s] = true;
player[s] = !player[pos];
visit(s);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cout << setprecision(12) << fixed;
int N, M;
cin >> N >> M;
graph.resize(N);
for (int i = (0); i < (M); ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
graph[a].push_back(b);
graph[b].push_back(a);
}
fill_n(visited, N, false);
for (int pos = (0); pos < (N); ++pos) {
if (!visited[pos]) {
visited[pos] = true;
player[pos] = true;
visit(pos);
}
}
if (valid) {
cout << vcount << endl;
bool space = false;
for (int i = (0); i < (N); ++i)
if (player[i]) {
if (space) {
cout << " ";
} else {
space = true;
}
cout << i + 1;
}
cout << endl;
cout << N - vcount << endl;
space = false;
for (int i = (0); i < (N); ++i)
if (!player[i]) {
if (space) {
cout << " ";
} else {
space = true;
}
cout << i + 1;
}
cout << endl;
} else {
cout << "-1" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double maxy, y, d[3000];
int a[3000];
void tao() {
freopen("input.inp", "w", stdout);
cout << "1000 1000" << endl;
for (int i = 1; i <= 1000; i++) cout << 1000 << " ";
}
int main() {
int n, r;
cin >> n >> r;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
maxy = 1.0 * r;
for (int j = a[i] - 2 * r; j <= a[i] + 2 * r; j++)
if (j > 0 && d[j] > 0.0) {
y = d[j] + sqrt((2 * r) * (2 * r) - (a[i] - j) * (a[i] - j));
maxy = max(y, maxy);
}
d[a[i]] = max(d[a[i]], maxy);
printf("%.9lf ", maxy);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[100000 + 10];
char a[] = {"abcdefghijklmnopqrstuvwxyz"};
int main() {
scanf("%s", s);
int n = strlen(s);
int A = 0;
for (int i = 0; i < 26; i++) {
int flag = 1;
for (int j = A; j < n; j++) {
if (a[i] >= s[j]) {
s[j] = a[i];
A = j + 1;
flag = 0;
break;
}
}
if (flag != 0) {
printf("-1\n");
return 0;
}
}
printf("%s\n", s);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 2000001;
long long int arr[MAXM];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
arr[1] = 0;
arr[2] = 0;
arr[3] = 1;
for (int i = 4; i < MAXM; i++) {
arr[i] = ((arr[i - 1] + 2 * arr[i - 2]) % 1000000007);
if (i % 3 == 0) arr[i] = (arr[i] + 1) % 1000000007;
}
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << (arr[n] * 4) % 1000000007 << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 2e3 + 1;
long long int dp[maxn][maxn];
long long int solve(long long int s, long long int n, long long int hrs,
long long int h, long long int l, long long int r,
vector<long long int>& v) {
if (s >= n) {
return 0;
}
if (dp[s][hrs] != -1) {
return dp[s][hrs];
}
long long int f1 = ((hrs + v[s] - 1) % h + h) % h;
long long int f2 = ((hrs + v[s]) % h + h) % h;
long long int add1 = (l <= f1 && f1 <= r) ? 1 : 0;
long long int add2 = (l <= f2 && f2 <= r) ? 1 : 0;
long long int ans1 = add1 + solve(s + 1, n, f1, h, l, r, v);
long long int ans2 = add2 + solve(s + 1, n, f2, h, l, r, v);
return dp[s][hrs] = max(ans1, ans2);
}
void runcases(long long int T) {
long long int n, h, l, r;
cin >> n >> h >> l >> r;
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) {
cin >> v[i];
}
memset(dp, -1, sizeof(dp));
long long int f = solve(0, n, 0, h, l, r, v);
cout << f << "\n";
}
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++) {
runcases(t);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-8;
const double PI = acos(-1);
template <class T, class S>
inline void add(T& a, S b) {
a += b;
if (a >= mod) a -= mod;
}
template <class T, class S>
inline void sub(T& a, S b) {
a -= b;
if (a < 0) a += mod;
}
template <class T, class S>
inline bool chkmax(T& a, S b) {
return a < b ? a = b, true : false;
}
template <class T, class S>
inline bool chkmin(T& a, S b) {
return a > b ? a = b, true : false;
}
int n, m, mask[N], c[N], cnt[N];
char s[N], t[N], ans[N];
bool check() {
int sum = 0, ret = inf;
for (int i = 0; i < 6; i++) sum += c[i];
for (int s1 = 0; s1 < 64; s1++) {
int tmp = 0;
for (int i = 0; i < 6; i++)
if (s1 >> i & 1) tmp += c[i];
for (int s2 = 0; s2 < 64; s2++)
if ((s2 | s1) != s1) tmp += cnt[s2];
chkmin(ret, tmp);
}
return sum == ret;
}
inline int getId(char c) { return c - 'a'; }
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) c[getId(s[i])]++;
scanf("%d", &m);
while (m--) {
int p;
scanf("%d%s", &p, t + 1);
for (int i = 1; t[i]; i++) mask[p] |= 1 << getId(t[i]);
}
for (int i = 1; i <= n; i++) {
if (!mask[i]) mask[i] = 63;
cnt[mask[i]]++;
}
for (int i = 1; i <= n; i++) {
bool flag = false;
for (int j = 0; j < 6; j++) {
if (c[j] && mask[i] >> j & 1) {
c[j]--;
cnt[mask[i]]--;
flag = check();
if (flag) {
ans[i] = 'a' + j;
break;
}
c[j]++;
cnt[mask[i]]++;
}
}
if (!flag) return puts("Impossible"), 0;
}
ans[n + 1] = '\0';
puts(ans + 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct FT {
vector<long long> s;
FT(int n) : s(n) {}
void update(int pos, long long dif) {
for (; pos < (int)(s).size(); pos |= pos + 1) s[pos] += dif;
}
long long query(int pos) {
long long res = 0;
for (; pos > 0; pos &= pos - 1) res += s[pos - 1];
return res;
}
long long query(int l, int r) { return query(r) - query(l); }
int lower_bound(long long sum) {
if (sum <= 0) return -1;
int pos = 0;
for (int pw = 1 << 25; pw; pw >>= 1) {
if (pos + pw <= (int)(s).size() && s[pos + pw - 1] < sum)
pos += pw, sum -= s[pos - 1];
}
return pos;
}
};
int main() {
int n;
scanf("%d", &n);
int winner = -1;
FT ft1(n), ft2(n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
if (i == n - 1) {
winner = x;
}
if (x == 1) {
ft1.update(i, 1);
} else {
ft2.update(i, 1);
}
}
int cnt = -1;
if (winner == 1) {
cnt = ft1.query(0, n);
} else {
cnt = ft2.query(0, n);
}
vector<pair<int, int>> ans;
for (int t = 1; t <= cnt; t++) {
int one = 0, two = 0;
int win1 = 0, win2 = 0;
bool ok = true;
while (true) {
int idx1 = ft1.lower_bound(one + t), idx2 = ft2.lower_bound(two + t);
if (idx1 == n) {
if (idx2 <= n - 1) {
win2++;
if (idx2 == n - 1) {
break;
}
two += t;
one = ft1.query(0, idx2 + 1);
continue;
} else {
ok = false;
break;
}
}
if (idx2 == n) {
if (idx1 <= n - 1) {
win1++;
if (idx1 == n - 1) {
break;
}
one += t;
two = ft2.query(0, idx1 + 1);
continue;
} else {
ok = false;
break;
}
}
if (idx1 < idx2) {
one += t;
two = ft2.query(0, idx1 + 1);
win1++;
} else {
two += t;
one = ft1.query(0, idx2 + 1);
win2++;
}
}
if (!ok) {
continue;
}
if (winner == 1 && win1 > win2) {
ans.push_back({win1, t});
} else if (winner == 2 && win2 > win1) {
ans.push_back({win2, t});
}
}
printf("%d\n", (int)ans.size());
sort(ans.begin(), ans.end());
for (auto i : ans) {
printf("%d %d\n", i.first, i.second);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int ans[MAXN];
vector<int> G[MAXN];
int dp[MAXN], num[MAXN], sum, root;
bool vis[MAXN];
void RiKa(int u, int fa) {
dp[u] = 0;
num[u] = 1;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (vis[v] || v == fa) continue;
RiKa(v, u);
num[u] += num[v];
dp[u] = max(num[v], dp[u]);
}
dp[u] = max(dp[u], sum - num[u]);
if (dp[u] < dp[root]) root = u;
}
void Rika(int u, int fa, int dep) {
root = 0;
sum = num[u];
RiKa(u, fa);
ans[root] = dep + 'A';
vis[root] = 1;
for (auto v : G[root]) {
if (vis[v]) continue;
Rika(v, u, dep + 1);
}
}
int main() {
int m, n, i, j, k;
ios::sync_with_stdio(false);
;
cin >> m;
for (i = 1; i <= m - 1; i++) {
int first, second;
cin >> first >> second;
G[first].push_back(second);
G[second].push_back(first);
}
dp[0] = num[1] = m;
Rika(1, -1, 0);
for (i = 1; i <= m; i++) cout << char(ans[i]) << ' ';
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[15], t[15];
char m[10][15] = {"monday", "tuesday", "wednesday", "thursday",
"friday", "saturday", "sunday"};
int x, y, cnt;
int main() {
scanf("%s %s", s, t);
for (int i = 0; i < 7; i++) {
if (strcmp(s, m[i]) == 0) x = i + 1;
}
for (int i = 0; i < 7; i++) {
if (strcmp(t, m[i]) == 0) y = i + 1;
}
while (x != y) {
x++;
if (x == 8) x = 1;
cnt++;
}
if (cnt == 3 || cnt == 0 || cnt == 2)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int module = 1e9 + 7;
const int inf = (1 << 31) - 1;
const int _inf = 1 << 31;
int main(void) {
int n;
double l, v1, v2;
int p;
while (scanf("%d", &n) == 1) {
scanf("%lf%lf%lf%d", &l, &v1, &v2, &p);
int tang = (n + p - 1) / p;
double x = l * 2.0 * v1 / ((2.0 * tang - 1) * v1 + v2);
x += x * (v2 - v1) / (2.0 * v1);
double ans = x / v2 + (l - x) / v1;
printf("%.10f\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int const MaxSize = 1e5 + 10;
int n, maxV, minV;
map<int, int> cnt;
void p(int minC, int midC, int maxC) {
for (int i = int(0); i < int(minC); i++) {
printf("%d ", minV);
}
for (int i = int(0); i < int(midC); i++) {
printf("%d ", minV + 1);
}
for (int i = int(0); i < int(maxC); i++) {
printf("%d ", maxV);
}
}
int main() {
ios_base::sync_with_stdio(false);
maxV = -1e9;
minV = 1e9;
scanf("%d", &n);
for (int i = int(0); i < int(n); i++) {
int a;
scanf("%d", &a);
cnt[a]++;
maxV = max(maxV, a);
minV = min(minV, a);
}
if (maxV == minV) {
printf("%d\n", n);
p(cnt[minV], 0, 0);
} else if (maxV - minV < 2) {
printf("%d\n", n);
p(cnt[minV], 0, cnt[maxV]);
} else {
int numPair = min(cnt[maxV], cnt[minV]);
int num0Pair = cnt[minV + 1] / 2;
if (numPair > num0Pair) {
printf("%d\n", n - numPair * 2);
p(cnt[minV] - numPair, cnt[minV + 1] + numPair * 2, cnt[maxV] - numPair);
} else {
printf("%d\n", n - num0Pair * 2);
p(cnt[minV] + num0Pair, cnt[minV + 1] - num0Pair * 2,
cnt[maxV] + num0Pair);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
const int INF = 1e9 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-7;
int n, m;
vector<int> g[maxn], id[maxn];
vector<int> ans;
int mark[maxn];
bool vis[maxn];
bool judge(int x, int y) {
if ((int)g[x].size() == 0) {
if (y == 1)
return true;
else
return false;
}
long long sum = 0;
for (int i = 0; i < y; i++) vis[i] = false;
for (int i = 0; i < (int)g[x].size(); i++) {
int v = g[x][i];
if (!vis[mark[v]]) {
vis[mark[v]] = true;
sum += 1LL * mark[v];
}
}
if (sum == 1LL * y * (y - 1) / 2)
return true;
else
return false;
}
int main() {
int T;
T = 1;
while (T--) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
int mx = -1;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
id[x].push_back(i);
mx = max(mx, x);
}
bool ok = true;
for (int i = 1; i <= mx; i++) {
if ((int)id[i].size() == 0) {
ok = false;
break;
}
for (int j = 0; j < (int)id[i].size(); j++) {
int v = id[i][j];
if (judge(v, i)) {
mark[v] = i;
ans.push_back(v);
} else {
ok = false;
break;
}
}
}
if (ok == false)
printf("-1\n");
else {
for (int i = 0; i < (int)ans.size(); i++) {
printf("%d", ans[i]);
if (i != (int)ans.size() - 1) printf(" ");
}
printf("\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int a[n + 1][4];
long long int x = 1, y = 0;
for (int i = 2; i < n + 1; i++) {
long long int temp = (y + 2 * x) % 1000000007;
y = 3 * x;
y %= 1000000007;
x = temp;
}
cout << y << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m, a, b;
cin >> n >> m >> a >> b;
if (n == m) {
cout << 0 << endl;
return 0;
}
long long int k = n / m;
long long int k1 = (k + 1) * m;
long long int k2 = (k)*m;
cout << min((k1 - n) * a, (n - k2) * b) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string s;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> s;
if (!k) {
cout << s;
return 0;
}
if (int(s.size()) == 1) {
cout << 0;
return 0;
}
if (s[0] != '1') {
s[0] = '1';
--k;
}
for (int i = 1; i < int(s.size()) && k; ++i) {
if (s[i] == '0') continue;
s[i] = '0';
--k;
}
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int busy[101], busy2[101];
int main() {
int n, q, t, k, d, sum;
scanf("%d%d", &n, &q);
for (int i = 0; i < q; i++) {
scanf("%d%d%d", &t, &k, &d);
sum = 0;
int cnt = k;
for (int j = 1; j <= n; j++) {
busy2[j] = busy[j];
}
for (int j = 1; j <= n; j++) {
if (cnt == 0) break;
if (t > busy[j]) {
cnt--;
sum += j;
busy[j] = t + d - 1;
}
}
if (cnt > 0) {
for (int j = 1; j <= n; j++) {
busy[j] = busy2[j];
}
printf("-1\n");
} else
printf("%d\n", sum);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1 << 62;
const long long MOD = 1e9 + 7;
const int iINF = 1 << 30;
const double PI = 3.14159265359;
void solve() {
long long d, m;
cin >> d >> m;
long long curr = 1;
for (; curr * 2 <= d; curr *= 2)
;
long long nxt = d;
long long s = 0;
while (nxt >= 1) {
long long term = (s + 1) % m;
s = (s + (nxt - curr + 1) * term % m) % m;
nxt = curr - 1;
curr /= 2;
}
cout << s << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int num, arr[10], cu[10];
int main() {
cin >> num;
for (int i = 1; i <= 7; ++i) cin >> arr[i];
int ind;
while (num > 0) {
bool b = true;
for (int i = 1; i <= 7; ++i) {
if (num - arr[i] > 0)
num -= arr[i];
else {
ind = i;
b = 0;
break;
}
}
if (!b) break;
}
cout << ind << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = (int)1e6 + 3;
long long fact[maxn], facrev[maxn];
long long power(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a;
long long c = power(a, b / 2);
c = (c * c) % mod;
if (b % 2) c = (c * a) % mod;
return c;
}
long long inv(long long p) { return power(p, mod - 2); }
long long C(long long n, long long k) {
if (n + k == 0) return 1;
if (n < k) return 0;
long long ans = fact[n];
ans = (ans * facrev[k]) % mod;
ans = (ans * facrev[n - k]) % mod;
return ans;
}
long long n, m, a, b;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fact[0] = 1;
cin >> n >> m >> a >> b;
for (int i = 1; i < maxn; i++) fact[i] = (fact[i - 1] * i) % mod;
facrev[maxn - 1] = inv(fact[maxn - 1]);
for (int i = maxn - 1; i > 0; i--) facrev[i - 1] = (facrev[i] * i) % mod;
long long ans = 0;
for (int i = 0; i <= n - 2; i++) {
if (i == n - 2)
ans += power(m, n - 1 - i - 1) * C(m - 1, i) % mod * fact[n - 2] % mod;
else
ans += power(m, n - 1 - i - 1) * C(m - 1, i) % mod * (i + 2) % mod *
power(n, n - 3 - i) % mod * C(n - 2, i) % mod * fact[i] % mod;
ans %= mod;
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 20, inf = 1e6;
int a[N][N];
int m, n, b, c;
int ans = 0;
int mn = inf, mn1 = inf;
int main() {
std::ios::sync_with_stdio(false);
cin >> m >> n;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
cin >> b >> c;
for (int i = 0; i <= (m - b); i++) {
for (int j = 0; j <= (n - c); j++) {
ans = 0;
for (int t = i; t <= ((i + b) - 1); t++) {
for (int q = j; q <= ((j + c) - 1); q++) {
if (a[t][q] == 1) {
ans++;
}
}
}
mn = min(mn, ans);
}
}
ans = 0;
for (int i = 0; i <= (m - c); i++) {
for (int j = 0; j <= (n - b); j++) {
ans = 0;
for (int t = i; t <= ((i + c) - 1); t++) {
for (int q = j; q <= ((j + b) - 1); q++) {
if (a[t][q] == 1) {
ans++;
}
}
}
mn1 = min(mn1, ans);
}
}
mn = min(mn, mn1);
cout << mn << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void archit_was_here() {}
void legend_was_here() {}
int main() {
int x[100000];
string s;
cin >> s;
int k = 0;
cin >> k;
int ff = 0, sn = 0, len = s.size();
for (int i = 0; i < len; i++) {
if (s[i] == '?')
ff++;
else if (s[i] == '*')
sn++;
}
len -= ff + sn;
if (len < k && sn == 0) {
printf("Impossible\n");
return 0;
}
if (len - (ff + sn) > k) {
printf("Impossible\n");
return 0;
}
if (len > k) {
int rem = len - k;
for (int i = 0; i < (int)s.size(); i++) {
if (s[i] == '?' || s[i] == '*') {
s[i - 1] = '*';
rem--;
if (rem == 0) break;
}
}
} else if (len < k) {
string what = "";
int t = k - len;
for (int i = 0; i < (int)s.size(); i++) {
if (s[i] == '*') {
char c = s[i - 1];
if (t > 0)
while (t--) what += c;
} else
what += s[i];
}
s = what;
}
for (int i = 0; i < (int)s.size(); i++) {
if (s[i] != '?' && s[i] != '*') printf("%c", s[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = 0;
int x = 0, flag = 1;
while (!isdigit(ch)) {
ch = getchar();
if (ch == '-') flag = -1;
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - '0';
ch = getchar();
}
return x * flag;
}
struct link {
int x, y, z;
};
bool operator<(link a, link b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
map<link, int> S;
map<link, int>::iterator it;
int n, m, qnum, now, cnt, tot, ans[440000];
struct ques {
int x, y, id;
} q[440000];
struct node {
link s;
int l, r;
} p[440000 * 2];
int top, f[440000], v[440000], sz[440000], sk[6600000];
int find(int x) {
if (x != f[x])
return find(f[x]);
else
return f[x];
}
int value(int x) {
if (x != f[x])
return value(f[x]) ^ v[x];
else
return 0;
}
bool merge(link s) {
int a = s.x, b = s.y, x = find(a), y = find(b), z = s.z;
if (x == y) return false;
if (sz[x] > sz[y]) swap(x, y), swap(a, b);
v[x] = value(a) ^ value(b) ^ z;
f[x] = y;
sz[y] += sz[x];
sk[++top] = x;
return true;
}
void erase() {
int x = sk[top--];
sz[f[x]] -= sz[x];
f[x] = x;
v[x] = 0;
}
struct pot {
int s[33];
void insert(int x) {
for (int i = 31; i >= 0; i--)
if (1 << i & x) {
if (!s[i]) {
s[i] = x;
break;
} else
x ^= s[i];
}
}
int query(int x) {
for (int i = 31; i >= 0; i--)
if (1 << i & x) x ^= s[i];
return x;
}
} sp[200];
vector<link> V[440000 * 4];
void optset(int o, int l, int r, int ql, int qr, link s) {
if (ql <= l && r <= qr) {
V[o].push_back(s);
return;
}
if (ql <= ((l + r) >> 1)) optset(o << 1, l, ((l + r) >> 1), ql, qr, s);
if (qr > ((l + r) >> 1)) optset(o << 1 | 1, ((l + r) >> 1) + 1, r, ql, qr, s);
}
void solve(int o, int l, int r, int t) {
if (l > r) return;
int times = 0, len = V[o].size();
for (int i = 0; i < len; i++)
if (merge(V[o][i]))
times++;
else
sp[t].insert(value(V[o][i].x) ^ value(V[o][i].y) ^ V[o][i].z);
if (l == r) {
while (now < tot && q[now + 1].id == l) {
now++;
ans[q[now].id] = sp[t].query(value(q[now].x) ^ value(q[now].y));
}
} else {
for (int i = 31; i >= 0; i--) sp[t + 1].s[i] = sp[t].s[i];
solve(o << 1, l, ((l + r) >> 1), t + 1);
for (int i = 31; i >= 0; i--) sp[t + 1].s[i] = sp[t].s[i];
solve(o << 1 | 1, ((l + r) >> 1) + 1, r, t + 1);
}
for (int i = 0; i < times; i++) erase();
}
int main() {
n = read();
m = read();
for (int i = 1; i <= m; i++) {
link o;
o.x = read();
o.y = read();
o.z = read();
if (o.x > o.y) swap(o.x, o.y);
S.insert(pair<link, int>(o, 0));
}
qnum = read();
for (int i = 1; i <= qnum; i++) {
int flag = read();
if (flag == 1) {
link o;
o.x = read();
o.y = read();
o.z = read();
if (o.x > o.y) swap(o.x, o.y);
S.insert(pair<link, int>(o, i));
}
if (flag == 2) {
link o;
o.x = read();
o.y = read();
it = S.find(o);
p[++cnt] = (node){it->first, it->second, i};
S.erase(it);
}
if (flag == 3) {
q[++tot].id = i;
q[tot].x = read();
q[tot].y = read();
if (q[tot].x > q[tot].y) swap(q[tot].x, q[tot].y);
}
}
for (it = S.begin(); it != S.end(); it++)
p[++cnt] = (node){it->first, it->second, m};
for (int i = 1; i <= cnt; i++) optset(1, 0, qnum, p[i].l, p[i].r, p[i].s);
for (int i = 1; i <= n; i++) f[i] = i, v[i] = 0, sz[i] = 1;
solve(1, 0, m, 1);
for (int i = 1; i <= tot; i++) printf("%d\n", ans[q[i].id]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long readi() {
long long input = 0;
char c = ' ';
while (c < '-') {
c = getchar();
}
bool negative = false;
if (c == '-') {
negative = true;
c = getchar();
}
while (c >= '0') {
input = 10 * input + (c - '0');
c = getchar();
}
if (negative) {
input = -input;
}
return input;
}
string reads() {
string input = "";
char c = ' ';
while (c <= ' ') {
c = getchar();
}
while (c > ' ') {
input += c;
c = getchar();
}
return input;
}
void printi(long long output) {
if (output == 0) {
putchar('0');
return;
}
if (output < 0) {
putchar('-');
output = -output;
}
vector<char> vout;
while (output) {
vout.push_back((output % 10) + '0');
output /= 10;
}
for (int i = vout.size() - 1; i >= 0; i--) {
putchar(vout[i]);
}
return;
}
void prints(string output) {
for (int i = 0; i < output.length(); i++) {
putchar(output[i]);
}
return;
}
int N, K;
int arr[35010];
int dp[53][35010];
int nxt[35010];
int late[35010];
void solve(int i, int L, int R, int optl, int optr) {
if (L > R) {
return;
}
int mid = (L + R) / 2;
int opt = -1;
int cost = 0;
for (int k = min(optr, mid - 1) + 2; k <= mid; k++) {
if (nxt[k] > mid) {
cost++;
}
}
for (int k = min(optr, mid - 1); k >= optl; k--) {
if (nxt[k + 1] > mid) {
cost++;
}
if (dp[i - 1][k] + cost > dp[i][mid]) {
dp[i][mid] = dp[i - 1][k] + cost;
opt = k;
}
}
solve(i, L, mid - 1, optl, opt);
solve(i, mid + 1, R, opt, optr);
}
int32_t main() {
cout << fixed << setprecision(10);
ios_base::sync_with_stdio(false);
if (fopen("cf834d.in", "r")) {
freopen("cf834d.in", "r", stdin);
freopen("cf834d.out", "w", stdout);
}
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> arr[i];
arr[i]--;
}
for (int i = 0; i <= N; i++) {
late[i] = 1000000861;
}
for (int i = N; i >= 1; i--) {
nxt[i] = late[arr[i]];
late[arr[i]] = i;
}
for (int i = 1; i <= K; i++) {
solve(i, 0, N, 0, N);
}
cout << dp[K][N] << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int x, y, a, b;
long resa[10000] = {0}, resb[10000] = {0};
cin >> x >> y >> a >> b;
long res = 0;
for (int i = a; i <= x; i++) {
for (int l = b; l <= y; l++) {
if (l < i) {
resa[res] = i;
resb[res] = l;
res++;
}
}
}
cout << res << endl;
for (int i = 0; i < res; i++) {
cout << resa[i] << " " << resb[i] << endl;
}
return EXIT_SUCCESS;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int gi() {
int x = 0, w = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') w = 0, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return w ? x : -x;
}
const int N = 100000;
const unsigned long long mod = (1ll << 58) - 1;
struct num {
unsigned long long s[5];
num() { s[0] = s[1] = s[2] = s[3] = s[4] = 0; }
num operator+(const num &b) const {
num c;
for (int i = 0; i < 5; ++i) c.s[i] = s[i] + b.s[i];
return c;
}
num operator-(const num &b) const {
num c;
for (int i = 0; i < 5; ++i) c.s[i] = s[i] - b.s[i];
return c;
}
num operator*(const num &b) const {
num c;
for (int i = 0; i < 5; ++i)
for (int j = 0; j < 5; ++j)
i + j < 5 ? c.s[i + j] += s[i] * b.s[j]
: c.s[i + j - 5] -= s[i] * b.s[j];
return c;
}
void kill() {
unsigned long long v = s[4];
s[4] -= v;
s[3] += v;
s[2] -= v;
s[1] += v;
s[0] -= v;
}
} a[N], w[10];
unsigned long long fastpow(unsigned long long a, unsigned long long b) {
unsigned long long res = 1;
while (b) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
num fastpow(num a, int b) {
num res;
res.s[0] = 1;
while (b) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
void dft(num *P, int op) {
for (int i = 1; i < N; i *= 10)
for (int p = i * 10, j = 0; j < N; j += p)
for (int k = 0; k < i; ++k) {
num tmp[10];
for (int x = 0; x < 10; ++x)
for (int y = 0; y < 10; ++y)
tmp[x] = tmp[x] + P[j + k + y * i] * w[x * y * op % 10];
for (int x = 0; x < 10; ++x) P[j + k + x * i] = tmp[x];
}
}
int main() {
int n = gi();
for (int i = 1; i <= n; ++i) ++a[gi()].s[0];
w[0].s[0] = 1;
w[1].s[1] = 1;
for (int i = 2; i < 10; ++i) w[i] = w[i - 1] * w[1];
dft(a, 1);
for (int i = 0; i < N; ++i) a[i] = fastpow(a[i], n);
dft(a, 9);
for (int i = 0; i < N; ++i) a[i].kill();
unsigned long long inv = fastpow(5, (1ull << 63) - 5);
for (int i = 0; i < n; ++i) printf("%I64d\n", (a[i].s[0] >> 5) * inv & mod);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000;
const long long LINF = INF * (long long)INF;
const int MAX = 100007;
const int MOD = 1000000007;
vector<int> G[MAX];
int up[MAX][20];
int tin[MAX];
int tout[MAX];
int d[MAX];
int timer = 0;
void dfs(int v, int p) {
tin[v] = timer++;
up[v][0] = p;
for (int i = (1); i < (20); i++) up[v][i] = up[up[v][i - 1]][i - 1];
for (int to : G[v]) {
if (to == p) continue;
d[to] = d[v] + 1;
dfs(to, v);
}
tout[v] = timer++;
}
bool upper(int a, int b) { return (tin[a] <= tin[b] && tout[a] >= tout[b]); }
int lca(int a, int b) {
if (upper(a, b)) return a;
if (upper(b, a)) return b;
for (int i = (20) - 1; i >= (0); i--) {
if (!upper(up[a][i], b)) a = up[a][i];
}
return up[a][0];
}
int dist(int a, int b) {
int c = lca(a, b);
return d[a] + d[b] - 2 * d[c];
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n;
for (int i = (0); i < (n - 1); i++) {
int a, b;
cin >> a >> b;
--a;
--b;
G[a].push_back(b);
G[b].push_back(a);
}
dfs(0, 0);
int q;
cin >> q;
for (int i = (0); i < (q); i++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
--x;
--y;
--a;
--b;
bool res = false;
int l = dist(a, b);
if (l <= k && l % 2 == k % 2) res = true;
l = dist(a, x) + 1 + dist(b, y);
if (l <= k && l % 2 == k % 2) res = true;
l = dist(a, y) + 1 + dist(b, x);
if (l <= k && l % 2 == k % 2) res = true;
if (res)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int ara[300007], divisor[4 * 300007], tree[4 * 300007],
mxTree[4 * 300007];
void InitiaLization() {
for (long long int i = 1; i <= 1000000; i++)
for (long long int j = i; j <= 1000000; j += i) divisor[j]++;
}
void build(long long int node, long long int b, long long int e) {
if (b == e) {
tree[node] = ara[b];
mxTree[node] = ara[b];
return;
}
long long int mid = (b + e) / 2, lson = 2 * node, rson = lson + 1;
build(lson, b, mid);
build(rson, mid + 1, e);
tree[node] = tree[lson] + tree[rson];
mxTree[node] = max(mxTree[lson], mxTree[rson]);
}
void update(long long int node, long long int b, long long int e,
long long int x, long long int y) {
if (b > y || e < x) return;
if (mxTree[node] <= 2) return;
if (b == e) {
tree[node] = divisor[tree[node]];
mxTree[node] = tree[node];
return;
}
long long int mid = (b + e) / 2, lson = 2 * node, rson = lson + 1;
update(lson, b, mid, x, y);
update(rson, mid + 1, e, x, y);
tree[node] = tree[lson] + tree[rson];
mxTree[node] = max(mxTree[lson], mxTree[rson]);
}
long long int query(long long int node, long long int b, long long int e,
long long int x, long long int y) {
if (b > y || e < x) return 0;
if (b >= x && e <= y) return tree[node];
long long int mid = (b + e) / 2, lson = 2 * node, rson = lson + 1;
return query(lson, b, mid, x, y) + query(rson, mid + 1, e, x, y);
}
int main(int argc, char const *argv[]) {
InitiaLization();
long long int n, m;
scanf("%lld %lld", &n, &m);
for (long long int i = 1; i <= n; i++) scanf("%d", ara + i);
build(1, 1, n);
while (m--) {
long long int t, l, r;
scanf("%lld %lld %lld", &t, &l, &r);
if (t == 1) {
update(1, 1, n, l, r);
} else {
printf("%lld\n", query(1, 1, n, l, r));
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int len, base;
vector<long long> fmtOr(vector<long long> A, int nrev = 1) {
for (int i = 0; i < base; ++i)
for (int S = 0; S < len; ++S)
if (~S >> i & 1) A[S | (1 << i)] += nrev * A[S];
return A;
}
int n, ppc[1 << 18], full;
long long f[1 << 18][18], ppcPow[1 << 18][19], save[20][1 << 18];
vector<long long> dp[20], ans;
vector<int> z;
map<deque<int>, vector<int> > mp;
char s[20][20];
deque<int> copt;
void dfs(int left, int smallest, int depth) {
auto& cur = save[depth];
for (int i = 0; i < left; ++i) copt.push_front(1);
static long long cu = 0;
cu = 0;
for (int S = 0; S < full; ++S)
cu += ((ppc[S ^ (full - 1)] & 1) ? -1 : 1) * (cur[S] * ppcPow[S][left]);
z = mp[copt];
for (auto g : z) ans[g] = cu;
for (int i = 0; i < left; ++i) copt.pop_front();
for (int cho = smallest; cho <= left; ++cho) {
copt.push_back(cho);
for (int i = 0; i < full; ++i)
save[depth + 1][i] = save[depth][i] * dp[cho][i];
dfs(left - cho, cho, depth + 1);
copt.pop_back();
}
}
int main() {
for (int i = 1; i < 1 << 18; ++i) {
ppc[i] = ppc[i >> 1] + (i & 1);
ppcPow[i][0] = 1;
for (int j = 1; j <= 18; ++j) ppcPow[i][j] = ppcPow[i][j - 1] * ppc[i];
}
scanf("%d", &n);
len = 1 << n, base = n;
full = 1 << n;
for (int i = 0; i < 1 << (n - 1); ++i) {
deque<int> mult;
int ones = 0, sz = n;
for (int j = 0; j < n - 1; ++j)
if (i >> j & 1) {
ones++;
} else
mult.push_back(ones + 1), sz -= ones + 1, ones = 0;
mult.push_back(ones + 1);
assert(sz == ones + 1);
sort(mult.begin(), mult.end());
mp[mult].push_back(i);
}
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
dp[i].assign(full, 0);
}
dp[n].assign(full, 0);
ans.assign(full / 2, 0);
for (int i = 0; i < n; ++i) f[1 << i][i] = 1;
for (int used = 0; used < full; ++used) {
for (int las = 0; las < n; ++las)
if (f[used][las]) {
for (int nxt = 0; nxt < n; ++nxt)
if ((~used >> nxt & 1) && s[las][nxt] == '1')
f[used | (1 << nxt)][nxt] += f[used][las];
}
}
for (int used = 0; used < full; ++used)
for (int las = 0; las < n; ++las) dp[ppc[used]][used] += f[used][las];
for (int i = 1; i <= n; ++i) dp[i] = fmtOr(dp[i], 1);
for (int i = 0; i < full; ++i) save[0][i] = 1;
dfs(n, 2, 0);
for (int i = 0; i < n - 1; ++i)
for (int S = 0; S < 1 << (n - 1); ++S)
if (~S >> i & 1) ans[S] -= ans[S | (1 << i)];
for (auto g : ans) printf("%lld ", g);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const long long Mod = 1e9 + 7;
long long a[105];
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
;
long long sum;
int t, n;
cin >> t;
while (t--) {
long long sum = 0;
long long s = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 0) {
a[i] = 1;
sum++;
}
s += a[i];
}
if (s == 0) sum++;
cout << sum << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, MOD = 998244353, inv = 499122177;
int n, m;
vector<int> a[N], pref[N], flag[N], aux[N];
bool check(int x) {
for (int i = 0; i <= n + 1; i++)
for (int j = 1; j <= m; j++) flag[i][j] = aux[i][j] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (j <= m - x + 1 && i <= n - x + 1) {
int curr = pref[i + x - 1][j + x - 1] - pref[i - 1][j + x - 1] -
pref[i + x - 1][j - 1] + pref[i - 1][j - 1];
if (curr == x * x) flag[i][j] = 1;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
aux[i][j] =
flag[i][j] + aux[i][j - 1] + aux[i - 1][j] - aux[i - 1][j - 1];
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (a[i][j]) {
int curr = aux[i][j];
if (j > x) curr -= aux[i][j - x];
if (i > x) curr -= aux[i - x][j];
if (i > x && j > x) curr += aux[i - x][j - x];
if (!curr) return false;
}
return true;
}
void Task() {
cin >> n >> m;
for (int i = 0; i <= n + 1; i++)
a[i].resize(m + 2), flag[i].resize(m + 2), aux[i].resize(m + 2),
pref[i].resize(m + 2);
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
s = '*' + s;
for (int j = 1; j <= m; j++) {
if (s[j] == 'X') a[i][j] = 1;
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
pref[i][j] =
pref[i - 1][j] + pref[i][j - 1] - pref[i - 1][j - 1] + a[i][j];
int l = 0, r = (min(n, m) - 1) / 2, ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid * 2 + 1)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
cout << ans << endl;
check(ans * 2 + 1);
char out[n + 2][m + 2];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) out[i][j] = '.';
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (flag[i][j]) {
out[i + ans][j + ans] = 'X';
}
cout << out[i][j];
}
cout << "\n";
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
while (T--) {
Task();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[800010], nxt[800010], p[800010], cap, ans;
bool vis[800010];
set<int> S;
set<int>::iterator it;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
p[i] = n + i;
a[n + i] = i;
}
for (int i = n; i >= 1; i--) {
nxt[i] = p[a[i]];
p[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
if (!vis[a[i]]) {
cap++;
ans++;
if (cap > k) {
it = S.end();
it--;
S.erase(it);
vis[a[*it]] = 0;
cap--;
}
S.insert(nxt[i]);
} else {
S.erase(i);
S.insert(nxt[i]);
}
vis[a[i]] = 1;
}
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[1000], h[1000];
int main() {
int y[10];
int g = 0;
char s[1000];
int a, b;
cin >> s;
int l = strlen(s);
a = l % 20 == 0 ? l / 20 : l / 20 + 1;
b = l % a == 0 ? l / a : l / a + 1;
int c = a * b - l;
cout << a << " " << b << "\n";
for (int i = 0; i < a; ++i) {
for (int j = 0; j < b; ++j) {
if (j == b - 1 && c > 0) {
cout << "*";
--c;
} else {
cout << s[g];
++g;
}
}
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2002;
int n, m;
char a[N][N];
int s[N];
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == '1') s[j]++;
}
}
for (int i = 0; i < n; ++i) {
bool z = false;
for (int j = 0; j < m; ++j) {
if (a[i][j] == '1' && s[j] == 1) {
z = true;
break;
}
}
if (!z) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
struct node {
int u, l, r, s;
} a[110000];
int cmp(node a, node b) { return a.u < b.u; }
int yl, yr, v, dp[110000];
int h, w, n;
stack<int> b[410000];
void update(int k, int l, int r) {
if (yl <= l && yr >= r)
b[k].push(v);
else {
int m = l + r >> 1;
if (yl <= m) update(k << 1, l, m);
if (yr > m) update(k << 1 | 1, m + 1, r);
}
}
void query(int k, int l, int r) {
while (!b[k].empty()) {
int x = b[k].top();
if (a[x].u + a[x].s >= yr) break;
b[k].pop();
}
if (!b[k].empty() && (v == -1 || a[b[k].top()].u > a[v].u)) v = b[k].top();
if (l < r) {
int m = l + r >> 1;
if (yl <= m)
query(k << 1, l, m);
else
query(k << 1 | 1, m + 1, r);
}
}
int query(int h, int p) {
yl = p;
yr = h;
v = -1;
query(1, 1, w);
return v != -1 ? dp[v] : 1;
}
int main() {
scanf("%d %d %d", &h, &w, &n);
for (int i = 0; i < n; i++)
scanf("%d %d %d %d", &a[i].u, &a[i].l, &a[i].r, &a[i].s);
sort(a, a + n, cmp);
for (int i = 0; i < n; i++) {
if (a[i].l == 1)
dp[i] = query(a[i].u, a[i].r + 1) * 2 % mod;
else if (a[i].r == w)
dp[i] = query(a[i].u, a[i].l - 1) * 2 % mod;
else
dp[i] = (query(a[i].u, a[i].l - 1) + query(a[i].u, a[i].r + 1)) % mod;
yl = a[i].l;
yr = a[i].r;
v = i;
update(1, 1, w);
}
int ans = 0;
for (int i = 1; i <= w; i++) ans = (ans + query(h + 1, i)) % mod;
printf("%d", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const int inf = 0x3f3f3f3f;
const int maxn = 1e2 + 10;
const double eps = 1e-6;
int di[8][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1},
{-1, -1}, {-1, 1}, {1, -1}, {1, 1}};
inline long long rd() {
long long 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 << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int n;
int x[maxn];
int c[maxn];
int l[maxn];
int r[maxn];
int find1(int p) {
int ans = 1000;
for (int i = 1; i < p; i++) {
if (x[i] > x[p] && x[i] < ans) ans = x[i];
}
if (ans == 1000) ans = 0;
return ans;
}
int find2(int p) {
int ans = 0;
for (int i = p + 1; i <= n; i++) {
if (x[i] < x[p] && x[i] > ans) ans = x[i];
}
return ans;
}
bool check() {
for (int i = 1; i <= n; i++) x[i] = c[i];
for (int i = 1; i <= n; i++) {
l[i] = find1(i);
r[i] = find2(i);
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (l[i] == 0 || r[j] == 0) continue;
if (l[i] < r[j]) return 1;
}
}
for (int i = 1; i <= n; i++) x[i] = c[n - i + 1];
for (int i = 1; i <= n; i++) {
l[i] = find1(i);
r[i] = find2(i);
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (l[i] == 0 || r[j] == 0) continue;
if (l[i] < r[j]) return 1;
}
}
return 0;
}
long long fac[maxn] = {1};
unordered_map<long long, long long> mp;
signed main() {
long long t = rd();
while (t--) {
mp.clear();
long long n = rd(), s = rd(), k = rd();
while (k--) {
mp[rd()] = 1;
}
long long ans = INF;
for (long long i = s; i >= max(s - 1100, 1ll); i--) {
if (!mp.count(i)) {
ans = min(ans, abs(s - i));
}
}
for (long long i = s; i <= min(s + 1100, n); i++) {
if (!mp.count(i)) {
ans = min(ans, abs(s - i));
}
}
printf("%lld\n", ans);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2008, mod = 1 << 30;
unordered_map<long long, int> M[308];
int A, B, C, p[maxn], tot;
long long ans;
bool isp[maxn];
void GetPrime() {
fill(isp + 2, isp + 2001, true);
for (int i = 2; i <= 2000; i++) {
if (isp[i]) p[tot++] = i;
for (int j = 0; j < tot && p[j] * i <= 2000; j++) {
isp[p[j] * i] = false;
if (i % p[j] == 0) break;
}
}
}
long long Calc(int a, int b, int c, int np) {
if (np == -1) return 1;
int r = p[np];
long long rep = 0;
long long hh = 2003ll * 2003ll * a + 2003ll * b + c;
if (rep = M[np][hh]) return rep;
for (int i = 1, x = 0; i <= a; i *= r, x++)
for (int j = 1, y = 0; j <= b; j *= r, y++)
for (int k = 1, z = 0; k <= c; k *= r, z++)
rep += Calc(a / i, b / j, c / k, np - 1) * (x + y + z + 1);
return M[np][hh] = rep;
}
int main() {
scanf("%d%d%d", &A, &B, &C);
GetPrime();
printf("%d", (Calc(A, B, C, tot - 1) % mod + mod) % (1 << 30));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
double a[300005], b[300005], v[300005];
struct node {
int l, r;
double lm, rm, m, sum;
} t[300005 * 5];
void bd(int pos, int l, int r) {
node s, ls, rs;
s.l = l, s.r = r;
if (l == r) {
s.sum = v[l];
s.lm = s.rm = s.m = max(0.0, v[l]);
t[pos] = s;
return;
}
int mid = (l + r) / 2;
bd(pos * 2, l, mid);
bd(pos * 2 + 1, mid + 1, r);
ls = t[pos * 2];
rs = t[pos * 2 + 1];
s.sum = ls.sum + rs.sum;
s.lm = max(ls.lm, ls.sum + rs.lm);
s.rm = max(rs.rm, rs.sum + ls.rm);
s.m = max(max(ls.m, rs.m), ls.rm + rs.lm);
t[pos] = s;
}
node f(int pos, int l, int r) {
node s = t[pos];
if (s.l >= l && s.r <= r) {
return s;
}
int mid = (s.l + s.r) / 2;
if (r <= mid) {
return f(pos * 2, l, r);
} else if (l > mid) {
return f(pos * 2 + 1, l, r);
} else {
node ls, rs;
ls = f(pos * 2, l, mid);
rs = f(pos * 2 + 1, mid + 1, r);
s.sum = ls.sum + rs.sum;
s.lm = max(ls.lm, ls.sum + rs.lm);
s.rm = max(rs.rm, rs.sum + ls.rm);
s.m = max(max(ls.m, rs.m), ls.rm + rs.lm);
return s;
}
}
int main() {
int m, n, c;
cin >> n >> m >> c;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) cin >> b[i];
for (int i = 1; i < n; i++) v[i] = (a[i + 1] - a[i]) / 2 - b[i] / 100 * c;
bd(1, 1, n - 1);
double ans = 0;
int l, r;
for (int i = 0; i < m; i++) {
cin >> l >> r;
ans += f(1, l, r - 1).m;
}
printf("%lf\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int T;
int answer = 0;
vector<int> v;
int main(void) {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> T;
while (T--) {
v.clear();
int n;
cin >> n;
v.resize(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
sort(v.begin(), v.end());
answer = 987654321;
for (int i = 1; i < n; ++i) {
int diff = v[i] - v[i - 1];
if (diff < answer) {
answer = diff;
}
}
cout << answer << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N;
int A[1002], pos[1002];
vector<pair<int, int> > V;
void reduce(int pos1, int pos2, int pos3) {
if (A[pos1] > A[pos2]) swap(pos1, pos2);
if (A[pos1] > A[pos3]) swap(pos1, pos3);
if (A[pos2] > A[pos3]) swap(pos2, pos3);
if (A[pos1] == 0) return;
int quotient = A[pos2] / A[pos1];
while (quotient) {
if (quotient & 1) {
A[pos2] -= A[pos1];
A[pos1] *= 2;
V.push_back(make_pair(pos1, pos2));
} else {
A[pos3] -= A[pos1];
A[pos1] *= 2;
V.push_back(make_pair(pos1, pos3));
}
quotient /= 2;
}
}
int main() {
cin >> N;
int nonzero = 0;
for (int i = 1; i <= N; ++i) {
cin >> A[i];
if (A[i] != 0) ++nonzero;
pos[i] = i;
}
if (nonzero <= 1) {
cout << -1 << '\n';
return 0;
}
for (int i = 1; i <= N - 2; ++i) {
while (min(A[pos[i]], min(A[pos[i + 1]], A[pos[i + 2]])) != 0)
reduce(pos[i], pos[i + 1], pos[i + 2]);
if (A[pos[i + 1]] == 0)
swap(pos[i], pos[i + 1]);
else if (A[pos[i + 2]] == 0)
swap(pos[i], pos[i + 2]);
}
cout << V.size() << '\n';
for (int i = 0; i < int(V.size()); ++i)
cout << V[i].first << ' ' << V[i].second << '\n';
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
int n, k, x;
int main() {
int i, l, r, cnt, tmp, ans = 0;
cin >> n >> k >> x;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
if (a[i] == x) {
l = r = i;
cnt = 0;
while (a[l] == a[r]) {
tmp = 2;
while (l > 0 && a[l - 1] == a[l]) l--, tmp++;
while (r < (n - 1) && a[r + 1] == a[r]) r++, tmp++;
--l;
++r;
if (tmp < 3) break;
cnt += tmp;
if (l < 0 || r >= n) break;
}
if (cnt - 1 > ans) ans = cnt - 1;
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1) cout << "1";
if (n == 2) cout << "2";
if (n == 3) cout << "6";
if (n == 4) cout << "20";
if (n == 5) cout << "70";
if (n == 6) cout << "252";
if (n == 7) cout << "924";
if (n == 8) cout << "3432";
if (n == 9) cout << "12870";
if (n == 10) cout << "48620";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n;
pair<long long, long long> a[3 * N];
multiset<long long> needs;
multiset<pair<long long, long long>> nexts;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
}
for (int i = 2; i <= n; i++) {
if (a[i].first > a[1].first) {
needs.insert(a[i].second - a[i].first + 1);
} else {
nexts.insert(a[i]);
}
}
int ans = needs.size() + 1;
while (true) {
ans = min(ans, (int)needs.size() + 1);
if (needs.size() == 0 || a[1].first == 0) {
break;
}
multiset<long long>::iterator it = needs.begin();
long long val = *it;
if (a[1].first >= val) {
a[1].first = a[1].first - val;
needs.erase(it);
} else {
a[1].first = 0;
}
while (true) {
if (nexts.size() == 0) {
break;
}
multiset<pair<long long, long long>>::iterator jt = nexts.end();
jt--;
long long val = (*jt).first;
long long wgth = (*jt).second;
if (val > a[1].first) {
needs.insert(wgth - val + 1);
nexts.erase(jt);
} else {
break;
}
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Product {
int buy_price;
int sell_price;
int count;
Product(int a = 0, int b = 0, int c = 0)
: buy_price(a), sell_price(b), count(c) {}
};
inline int min(int a, int c) { return a < c ? a : c; }
inline int max(int a, int c) { return a > c ? a : c; }
int main(int argc, char **argv) {
int n;
cin >> n;
int m;
cin >> m;
int k;
cin >> k;
vector<vector<Product> > p(n);
for (int planet = 0; planet < n; planet++) {
string name;
cin >> name;
vector<Product> pr(m);
for (int product = 0; product < m; product++) {
int a, b, c;
cin >> a;
cin >> b;
cin >> c;
pr[product] = Product(a, b, c);
}
p[planet] = pr;
}
int result = 0;
for (int buy_planet = 0; buy_planet < n; ++buy_planet) {
for (int sell_planet = 0; sell_planet < n; ++sell_planet) {
if (buy_planet == sell_planet) continue;
vector<Product> p_buy = p[buy_planet];
vector<Product> p_sell = p[sell_planet];
int capacity = k;
int profit = 0;
while (capacity > 0) {
int best_index = 0;
int best_diff = -1;
for (int i = 0; i < m; i++) {
int diff = (p_sell[i].sell_price - p_buy[i].buy_price);
if (p_buy[i].count > 0 && diff > best_diff) {
best_index = i;
best_diff = diff;
}
}
if (best_diff == -1) break;
int trade_count = min(p_buy[best_index].count, capacity);
capacity -= trade_count;
profit += best_diff * trade_count;
p_buy[best_index].count -= trade_count;
}
result = max(result, profit);
}
}
cout << result;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
int n, a, b, k, num = 0, ans = 0, flag = 0;
char s[200050];
int main() {
scanf("%d %d %d %d", &n, &a, &b, &k);
scanf("%s", s);
int len = strlen(s);
for (int i = 0; i < len; i++) {
if (s[i] == '0')
num++;
else
num = 0;
if (num >= b) {
num -= b;
ans++;
q.push(i + 1);
}
}
int k = ans - a + 1;
printf("%d\n", k);
for (int i = 1; i <= k; i++) {
if (i == 1)
printf("%d", q.front());
else
printf(" %d", q.front());
if (!q.empty()) q.pop();
}
printf("\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int par[200010][18];
int dep[200010];
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 18 - 1; i >= 0; i--)
if (dep[par[u][i]] >= dep[v]) u = par[u][i];
if (u == v) return u;
for (int i = 18 - 1; i >= 0; i--)
if (par[u][i] != par[v][i]) u = par[u][i], v = par[v][i];
return par[u][0];
}
int dist(int u, int v) {
int a = lca(u, v);
return dep[u] + dep[v] - 2 * dep[a];
}
int main() {
cin >> n;
dep[1] = 1;
for (int i = 2; i <= n; i++) {
cin >> par[i][0];
dep[i] = dep[par[i][0]] + 1;
}
for (int j = 1; j < 18; j++)
for (int i = 1; i <= n; i++) par[i][j] = par[par[i][j - 1]][j - 1];
int u = 1, v = 1;
for (int i = 2; i <= n; i++) {
if (dist(u, i) > dist(u, v))
v = i;
else if (dist(v, i) > dist(u, v))
u = i;
cout << dist(u, v) << ' ';
}
}
| 7 |
#include <bits/stdc++.h>
int main() {
std::string s;
std::cin >> s;
int c = 4;
if (s[0] == 'f') c = 3;
s.insert(c, "://");
c = s.find("ru", c + 4);
s.insert(c, ".");
c += 3;
if (c < s.length()) {
s.insert(c, "/");
}
std::cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, a, u, v;
scanf("%d", &n);
u = 101;
v = 101;
for (i = 1; i <= n; i++) {
scanf("%d", &a);
if (u > a) {
v = u;
u = a;
} else if ((v > a) && (a > u))
v = a;
}
if (v != 101)
cout << v << "\n";
else
cout << "NO\n";
return (0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[10];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
cout << a[n / 2];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class V>
struct SegTree {
int n;
vector<V> st;
vector<int> leaves;
SegTree(const int n) : n(n) {
leaves.resize(n);
init(1, 0, n - 1);
}
void init(const int si, const int lo, const int hi) {
if (lo == hi) {
if (si >= (int)st.size()) st.resize(si + 1);
st[si] = V();
leaves[lo] = si;
} else {
const int mid = (lo + hi) >> 1;
init(si << 1, lo, mid);
init(si << 1 | 1, mid + 1, hi);
st[si] = V(st[si << 1], st[si << 1 | 1]);
}
}
V query(const int l, const int r) {
return (l <= r && l < n && r >= 0) ? query(l, r, 1, 0, n - 1) : V();
}
V query(const int l, const int r, const int si, const int lo, const int hi) {
if (l <= lo && hi <= r) return st[si];
const int mid = (lo + hi) >> 1;
if (r <= mid) return query(l, r, si << 1, lo, mid);
if (mid < l) return query(l, r, si << 1 | 1, mid + 1, hi);
return V(query(l, r, si << 1, lo, mid),
query(l, r, si << 1 | 1, mid + 1, hi));
}
void update(const int i) {
int si = leaves[i];
st[si].v--;
for (si >>= 1; si; si >>= 1) st[si] = V(st[si << 1], st[si << 1 | 1]);
}
int find(int x) {
int si = 1, lo = 0, hi = n - 1, sum = 0;
while (lo != hi) {
int mid = (lo + hi) >> 1, l = si << 1, r = l | 1;
if (st[l] + sum - 1 >= x) {
si = l;
hi = mid;
} else {
si = r;
lo = mid + 1;
sum += st[l].v;
}
}
return lo;
}
};
struct StVal {
int v = 1;
StVal() {}
StVal(const int _v) : v(_v) {}
StVal(const StVal &v1, const StVal &v2) { v = v1 + v2; }
operator int() const { return v; }
};
vector<int> p, q;
int n;
void fact_base(vector<int> &v) {
SegTree<StVal> st(n);
for (auto &x : v) {
int y = x;
x = st.query(0, x) - 1;
st.update(y);
}
}
vector<int> fact_sum(vector<int> &p, vector<int> &q) {
vector<int> res(n);
int c = 0;
for (int i = 0; i < n; i++) {
int mod = i + 1, x = p[n - 1 - i] + q[n - 1 - i] + c;
res[n - 1 - i] = x % mod;
c = x / mod;
}
return move(res);
}
void build_perm(vector<int> &v) {
SegTree<StVal> st(n);
for (auto &x : v) {
x = st.find(x);
st.update(x);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n;
p.resize(n);
q.resize(n);
for (auto &x : p) {
cin >> x;
}
for (auto &x : q) {
cin >> x;
}
fact_base(p);
fact_base(q);
vector<int> res = fact_sum(p, q);
build_perm(res);
for (int i = 0; i < n; i++) {
cout << res[i];
if (i + 1 != n) {
cout << ' ';
} else {
cout << endl;
}
}
cin.ignore(2);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAXN = 1e3 + 100;
const int XX = 5000;
const long double lg2 = log(2);
const long double lg3 = log(3);
int val[XX];
pair<int, int> add(pair<int, int> a, pair<int, int> b) {
return {a.first + b.first, a.second + b.second};
}
pair<int, int> sub(pair<int, int> a, pair<int, int> b) {
return {a.first - b.first, a.second - b.second};
}
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a == b) return true;
if (a.first > b.first) return !cmp(b, a);
b.first -= a.first;
if (a.second < b.second) return false;
a.second -= b.second;
return a.second >= val[b.first];
}
int n, a[MAXN][MAXN];
int dp[8][MAXN][MAXN];
int dr[] = {-1, 0, 0, 1, -1, -1, 1, 1};
int dc[] = {0, -1, 1, 0, -1, 1, -1, 1};
bool valid(int r, int c) { return 0 <= r && r < n && 0 <= c && c < n; }
int go(int i, int r, int c) {
if (!valid(r, c)) return 0;
if (~dp[i][r][c]) return dp[i][r][c];
if (a[r][c] == 0) return dp[i][r][c] = 0;
return dp[i][r][c] = 1 + go(i, r + dr[i], c + dc[i]);
}
pair<int, int> p[8][MAXN][MAXN];
pair<int, int> get(int i, int r, int c) {
if (!valid(r, c)) return {0, 0};
if (~p[i][r][c].first) return p[i][r][c];
pair<int, int> now;
if (a[r][c] == 2) now.first = 1;
if (a[r][c] == 3) now.second = 1;
return p[i][r][c] = add(now, get(i, r - dr[i], c - dc[i]));
}
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < n; j++) {
a[i][j] = s[j] - '0';
}
}
for (int i = 1; i < XX; i++) {
int j = 0;
while (j * lg3 < i * lg2) ++j;
val[i] = j;
}
memset(dp, -1, sizeof(dp));
for (int i = 0; i < 8; i++)
for (int r = 0; r < n; r++)
for (int c = 0; c < n; c++) go(i, r, c);
for (int i = 0; i < 8; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++) p[i][j][k] = {-1, -1};
pair<int, int> best;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int d = min({dp[0][i][j], dp[1][i][j], dp[2][i][j], dp[3][i][j]}) - 1;
if (d >= 0) {
pair<int, int> now;
now = add(now, get(2, i + d * dr[2], j + d * dc[2]));
now = sub(now, get(2, i - (d + 1) * dr[2], j - (d + 1) * dc[2]));
now = add(now, get(3, i + d * dr[3], j + d * dc[3]));
now = sub(now, get(3, i - (d + 1) * dr[3], j - (d + 1) * dc[3]));
if (a[i][j] == 2) now.first--;
if (a[i][j] == 3) now.second--;
if (cmp(now, best)) best = now;
}
d = min({dp[4][i][j], dp[5][i][j], dp[6][i][j], dp[7][i][j]}) - 1;
if (d >= 0) {
pair<int, int> now;
now = add(now, get(6, i + d * dr[6], j + d * dc[6]));
now = sub(now, get(6, i - (d + 1) * dr[6], j - (d + 1) * dc[6]));
now = add(now, get(7, i + d * dr[7], j + d * dc[7]));
now = sub(now, get(7, i - (d + 1) * dr[7], j - (d + 1) * dc[7]));
if (a[i][j] == 2) now.first--;
if (a[i][j] == 3) now.second--;
if (cmp(now, best)) best = now;
}
}
}
int ans = 1;
for (int i = 0; i < best.first; i++) ans = 2ll * ans % MOD;
for (int i = 0; i < best.second; i++) ans = 3ll * ans % MOD;
if (best.first == 0 && best.second == 0) {
ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (a[i][j]) ans = 1;
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int te = 1;
for (int w = 1; w <= te; w++) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main(void) {
long long int count = 0;
int n, i, temp, ones = 0;
scanf("%d\n", &n);
for (i = 0; i < n; i++) {
scanf("%d", &temp);
if (!temp)
count += ones;
else
ones++;
}
printf("%lld\n", count);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long query(long long l, long long r) {
long long i, res = 0;
for (i = 60; i >= 0; i--) {
long long j = 1LL << i;
if ((l & j) == (r & j)) {
long long bit = l & j;
res += bit;
l -= bit;
r -= bit;
} else
break;
}
if (__builtin_popcountll(r) > i)
res += r;
else
res += (1LL << i) - 1;
return res;
}
signed main() {
long long n;
cin >> n;
while (n--) {
long long l, r;
cin >> l >> r;
cout << query(l, r) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
if (b % a != 0) {
cout << "-1\n";
} else {
long long q = b / a;
int steps = 0;
while (q % 2 == 0) {
steps++;
q /= 2;
}
while (q % 3 == 0) {
steps++;
q /= 3;
}
if (q != 1)
cout << "-1\n";
else
cout << steps << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n;
pair<int, int> a[60];
long double lo, mi, hi, eps, c[60], dyn[60][60][60];
bool ok(long double thr) {
for (i = 1; i <= n; i++)
c[i] = (long double)a[i].first - (long double)a[i].second * thr;
for (i = 0; i <= n; i++)
for (j = 0; j <= n; j++)
for (k = 0; k <= n; k++) dyn[i][j][k] = 1e9;
dyn[0][0][0] = 0;
for (i = 1; i <= n; i++) {
if (a[i].first != a[i - 1].first) {
for (j = 0; j <= i; j++)
for (k = 0; k <= i; k++) {
dyn[i][j + k][1] = min(dyn[i][j + k][1], dyn[i - 1][j][k] + c[i]);
if ((j + k) > 0)
dyn[i][j + k - 1][0] = min(dyn[i][j + k - 1][0], dyn[i - 1][j][k]);
}
} else {
for (j = 0; j <= i; j++)
for (k = 0; k <= i; k++) {
dyn[i][j][k + 1] = min(dyn[i][j][k + 1], dyn[i - 1][j][k] + c[i]);
if (j > 0) dyn[i][j - 1][k] = min(dyn[i][j - 1][k], dyn[i - 1][j][k]);
}
}
}
long double ans = 1;
for (j = 0; j <= n; j++)
for (k = 0; k <= n; k++) ans = min(ans, dyn[n][j][k]);
return (ans <= 0);
}
bool comp(pair<int, int> a, pair<int, int> b) { return a > b; }
int main() {
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i].first;
for (i = 1; i <= n; i++) cin >> a[i].second;
sort(a + 1, a + n + 1, comp);
lo = 0;
hi = 1e9;
eps = 1e-9;
while ((hi - lo) > eps) {
mi = (lo + hi) / 2;
if (ok(mi))
hi = mi;
else
lo = mi;
}
long long ans = lo * 1000;
cout << ans + 1;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char s[50];
unordered_map<long long, bool> mp;
int m;
int q[50];
int qb, qf, used;
struct node {
int nxt[2], fail, cnt;
void clear() {
memset(nxt, -1, sizeof nxt);
fail = -1;
cnt = 0;
}
} mem[50];
struct AC_automation {
int newnode() {
int ans = ++used;
mem[ans].clear();
return ans;
}
void init() {
used = -1;
newnode();
qb = qf = 0;
}
void insert(char *s, int n, int val) {
int now = 0;
for (int i = 0; i < n; i++) {
if (mem[now].nxt[s[i] - '0'] == -1) mem[now].nxt[s[i] - '0'] = newnode();
now = mem[now].nxt[s[i] - '0'];
}
mem[now].cnt += val;
return;
}
void build() {
mem[0].fail = 0;
for (int i = 0; i < m; i++) {
if (mem[0].nxt[i] == -1)
mem[0].nxt[i] = 0;
else {
mem[mem[0].nxt[i]].fail = 0;
q[qb++] = mem[0].nxt[i];
}
}
while (qb > qf) {
int u = q[qf++];
mem[u].cnt += mem[mem[u].fail].cnt;
for (int i = 0; i < m; i++) {
if (mem[u].nxt[i] == -1)
mem[u].nxt[i] = mem[mem[u].fail].nxt[i];
else {
mem[mem[u].nxt[i]].fail = mem[mem[u].fail].nxt[i];
q[qb++] = mem[u].nxt[i];
}
}
}
}
} ac;
long long dp[2][50];
int main() {
m = 2;
int n;
scanf("%d%s", &n, s);
int len = strlen(s);
if (len >= n / 2 + 3) {
long long tmp = 0;
for (int i = 0; i < len; i++) tmp = tmp * 2 + s[i] - '0';
int ans = 0;
long long val = 1LL << (n - 1);
for (int i = 0; i < 1 << (n - len); i++) {
long long st = tmp;
for (int j = 0; j < n - len; j++) {
st *= 2;
if (i & (1 << j)) st++;
}
for (int j = 0; j < n; j++) {
if (!mp.count(st)) {
ans++;
mp[st] = 1;
}
st = st / 2 + (st % 2) * val;
}
}
printf("%d\n", ans);
return 0;
}
long long ans = 0;
int p = len - 1;
for (int x = 0; x < 1 << p; x++) {
ac.init();
ac.insert(s, len, 1);
ac.build();
int ok = 0;
dp[0][0] = 1;
for (int j = 0; j < p; j++) {
int v = (x >> j) & 1;
for (int k = 0; k <= used; k++) {
if (dp[ok][k]) {
int kk = mem[k].nxt[v];
if (!mem[kk].cnt) dp[ok ^ 1][kk] += dp[ok][k];
dp[ok][k] = 0;
}
}
ok ^= 1;
}
for (int j = 0; j < n - p; j++) {
for (int k = 0; k <= used; k++) {
if (dp[ok][k]) {
for (int v = 0; v < 2; v++) {
int kk = mem[k].nxt[v];
if (!mem[kk].cnt) dp[ok ^ 1][kk] += dp[ok][k];
}
dp[ok][k] = 0;
}
}
ok ^= 1;
}
for (int j = 0; j < p; j++) {
int v = (x >> j) & 1;
for (int k = 0; k <= used; k++) {
if (dp[ok][k]) {
int kk = mem[k].nxt[v];
if (!mem[kk].cnt) dp[ok ^ 1][kk] += dp[ok][k];
dp[ok][k] = 0;
}
}
ok ^= 1;
}
ans += 1LL << (n - p);
for (int i = 0; i <= used; i++) {
ans -= dp[ok][i];
dp[ok][i] = 0;
}
}
printf("%I64d\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, mn[1000000], root, hson[1000000];
int timer, size[1000000], sum[1000000];
int dfn[1000000], id[1000000], gra[1000000];
long long dis[1000000];
set<pair<int, int> > s;
set<pair<int, int> >::iterator it;
int read() {
int x = 0, k = 1;
char c;
c = getchar();
while (c < '0' || c > '9') {
if (c == '-') k = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * k;
}
struct edge {
int cnp, to[1000000], last[1000000], head[1000000], co[1000000];
edge() { cnp = 2; }
void add(int u, int v, int w) {
to[cnp] = v, co[cnp] = w, last[cnp] = head[u], head[u] = cnp++;
to[cnp] = u, co[cnp] = w, last[cnp] = head[v], head[v] = cnp++;
}
} E1;
void Get_root(int u, int fa) {
size[u] = 1;
for (int i = E1.head[u]; i; i = E1.last[i]) {
int v = E1.to[i];
if (v == fa) continue;
Get_root(v, u);
size[u] += size[v];
hson[u] = max(hson[u], size[v]);
}
hson[u] = max(hson[u], n - size[u]);
if (hson[u] < hson[root]) root = u;
}
void dfs(int u, int fa) {
dfn[u] = ++timer;
id[timer] = u, size[u] = 1;
for (int i = E1.head[u]; i; i = E1.last[i]) {
int v = E1.to[i];
if (v == fa) continue;
dis[v] = dis[u] + E1.co[i];
dfs(v, u);
size[u] += size[v];
}
}
void Push_Up(int p) { mn[p] = min(mn[p << 1], mn[p << 1 | 1]); }
void Build(int p, int l, int r) {
if (l == r) {
mn[p] = id[l];
return;
}
int mid = (l + r) >> 1;
Build(p << 1, l, mid), Build(p << 1 | 1, mid + 1, r);
Push_Up(p);
}
int Query(int p, int l, int r, int L, int R) {
if (L <= l && R >= r) return mn[p];
if (L > r || R < l) return 999999999;
int mid = (l + r) >> 1;
int t = Query(p << 1, l, mid, L, R);
int t1 = Query(p << 1 | 1, mid + 1, r, L, R);
return min(t, t1);
}
void Update(int p, int l, int r, int x) {
if (l == r) {
mn[p] = 999999999;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
Update(p << 1, l, mid, x);
else
Update(p << 1 | 1, mid + 1, r, x);
Push_Up(p);
}
void dfs2(int u, int root, int fa) {
gra[u] = root;
for (int i = E1.head[u]; i; i = E1.last[i]) {
int v = E1.to[i];
if (v == fa) continue;
dfs2(v, root, u);
}
}
void del(int x) {
if (x != root) {
int t = gra[x];
it = s.lower_bound(make_pair(sum[t], t));
s.erase(it);
sum[t]--;
s.insert(make_pair(sum[t], t));
}
}
int main() {
n = read();
if (n == 1) {
printf("0\n1\n");
return 0;
}
for (int i = 1; i < n; i++) {
int u = read(), v = read(), w = read();
E1.add(u, v, w);
}
hson[root] = n + 1;
Get_root(1, 0);
dfs(root, 0);
timer = 0;
Build(1, 1, n);
long long ans = 0;
for (int i = 1; i <= n; i++) ans += dis[i];
printf("%I64d\n", ans * 2);
for (int i = E1.head[root]; i; i = E1.last[i]) {
int v = E1.to[i];
sum[v] = size[v] * 2;
dfs2(v, v, root);
s.insert(make_pair(sum[v], v));
}
for (int i = 1, t = -1; i <= n; i++) {
int res = n - i + 1;
if (t == -1) {
it = s.lower_bound(make_pair(res, 0));
if (it != s.end()) t = (*it).second;
}
int u = 999999999, x = gra[i];
if (t == -1) {
if (i == root)
u = Query(1, 1, n, 1, n);
else {
u = min(u, Query(1, 1, n, 1, dfn[x] - 1));
u = min(u, Query(1, 1, n, dfn[x] + size[x], n));
}
} else {
if (x == t) {
u = min(u, Query(1, 1, n, 1, dfn[x] - 1));
u = min(u, Query(1, 1, n, dfn[x] + size[x], n));
} else
u = Query(1, 1, n, dfn[t], dfn[t] + size[t] - 1);
}
printf("%d ", u);
del(i);
Update(1, 1, n, dfn[u]);
if (i != u) del(u);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while (scanf("%d %d ", &n, &m) != EOF) {
if (n < m) {
printf("-1\n");
continue;
}
if (m == 1) {
if (n == 1)
printf("a\n");
else
printf("-1\n");
continue;
}
int k = n - m + 2;
for (int i = 0; i < k; ++i)
if (i % 2)
printf("b");
else
printf("a");
for (int i = 2; i < m; ++i) printf("%c", 'a' + i);
printf("\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int max6 = 1e6 + 6;
const int oo = 1e9 + 9;
const long long inf = 1e18 + 18;
int main() {
int T;
cin >> T;
while (T--) {
int s, t, e;
cin >> s >> t >> e;
cout << max(0, e - max((t + e - s + 2) / 2, 0) + 1) << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double inf = 1ll << 60;
const int N = 2e5 + 1;
const int K = 50;
long double dp[K][N];
long double arr[N];
long double fun[N];
long double sum[N];
long double rec[N];
int n, k;
long double func(int l, int r) {
return (fun[r] - fun[l - 1]) - (rec[r] - rec[l - 1]) * sum[l - 1];
}
void calc(int l, int r, int optl, int optr, int i) {
if (l > r) {
return;
}
pair<long double, int> res = {inf, 0};
int q = l + r >> 1;
for (int j = optl; j <= min(q, optr); ++j) {
res = min(res, {dp[i - 1][j - 1] + func(j, q), j});
}
dp[i][q] = res.first;
calc(l, q - 1, optl, res.second, i);
calc(q + 1, r, res.second, optr, i);
}
void input() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
sum[i] = sum[i - 1] + arr[i];
rec[i] = rec[i - 1] + 1 / arr[i];
fun[i] = fun[i - 1] + sum[i] / arr[i];
}
}
void solve() {
for (int i = 1; i <= n; ++i) {
dp[0][i] = fun[i];
}
for (int i = 1; i < k; ++i) {
calc(1, n, 1, n, i);
}
cout << fixed << setprecision(10) << dp[k - 1][n] << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
input();
solve();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string ss;
cin >> ss;
int n = ss.length();
int freq[1010] = {0};
int ii = 0, jj = 0;
vector<pair<int, int>> vex;
for (int i = 0; i < n; i++) {
string s = "";
while (ss[i] != ',' && i < n) {
s += ss[i];
i++;
}
int l = s.size(), num = 0;
for (long long j = l - 1; j >= 0; j--) {
num += (s[j] - '0') * pow(10, l - 1 - j);
}
freq[num]++;
}
int j = 0;
for (int i = 0; i < 1005; i++) {
if (freq[i] != 0) {
ii = i;
for (j = i; j < 1005; j++) {
if (freq[j] == 0) {
jj = j - 1;
break;
}
}
vex.push_back(make_pair(ii, jj));
i = j;
}
}
for (int i = 0; i < vex.size(); i++) {
if (i == vex.size() - 1) {
if (vex[i].first != vex[i].second) {
cout << vex[i].first << "-" << vex[i].second;
} else {
cout << vex[i].first;
}
} else {
if (vex[i].first != vex[i].second) {
cout << vex[i].first << "-" << vex[i].second << ",";
} else {
cout << vex[i].first << ",";
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int n;
char s[N], s1[N];
vector<int> pos;
int cnt[N];
inline bool check(int t, char *s) {
int cur = 1, done = 0;
while (cur <= n) {
while (cur <= n && (cur <= done || s[cur] != '*')) {
if (s[cur] == 'P') done = max(done, cur + t);
cur++;
}
if (cur <= n) {
int nextP = -1, n2P = -1, cnt = 0;
for (int i = cur + 1; i <= min(cur + t, n); i++) {
if (s[i] == 'P') {
if (nextP == -1)
nextP = i;
else {
n2P = i;
break;
}
} else if (s[i] == '*' && nextP > 0) {
cnt++;
}
}
if (nextP == -1) return false;
if (n2P > 0) {
if (cnt)
done = max(done, nextP + t);
else
done = max(done, n2P + t);
cur = n2P + 1;
} else {
cur = nextP + 1;
}
}
}
return true;
}
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
s1[i] = s[n + 1 - i];
}
int lft = n, rgt = 0;
for (int i = 1; s[i]; i++) {
if (s[i] == 'P') {
pos.push_back(i);
}
cnt[i] = cnt[i - 1];
if (s[i] == '*') {
lft = min(lft, i);
rgt = i, cnt[i]++;
}
}
if (pos.size() == 1) {
if (cnt[pos[0]] > cnt[n] - cnt[pos[0]])
cout << cnt[pos[0]] << " " << pos[0] - lft << endl;
else if (cnt[pos[0]] < cnt[n] - cnt[pos[0]])
cout << cnt[n] - cnt[pos[0]] << " " << rgt - pos[0] << endl;
else {
cout << cnt[pos[0]] << " " << min(rgt - pos[0], pos[0] - lft) << endl;
}
return 0;
}
int l = 1, r = n;
while (l < r) {
int mid = (l + r) >> 1;
if (check(mid, s) || check(mid, s1))
r = mid;
else
l = mid + 1;
}
assert(l < n);
cout << cnt[n] << " " << l << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, inf = 1e9 + 15;
int c[N], g[N][2], h[N][2];
bool least[N];
vector<int> t[N];
void init(int u = 0, int p = -1, int pv = inf) {
if (c[u] < pv) {
least[u] = 1;
pv = c[u];
}
for (int v : t[u]) {
if (v == p) continue;
init(v, u, pv);
}
}
long long ans = 0;
void dfs(int u = 0, int p = -1) {
for (int v : t[u]) {
if (v == p) continue;
dfs(v, u);
h[u][0] += h[v][0];
h[u][1] += h[v][1];
}
if (least[u]) {
long long m = min(h[u][0], h[u][1]);
ans += 2LL * m * c[u];
h[u][0] -= m;
h[u][1] -= m;
}
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int a, b, ci;
cin >> c[i] >> b >> ci;
if (b != ci) {
++h[i][b];
}
}
for (int i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y;
--x, --y;
t[x].push_back(y);
t[y].push_back(x);
}
init();
dfs();
if (h[0][0] || h[0][1]) {
cout << -1 << '\n';
} else {
cout << ans << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long N, M, T;
vector<long long> A, B;
bool ok(long long X) {
if (X == 0) return true;
long long d = B[X - 1];
long long sum = 0, crtsum = 0, crt = 0, cnt = 0;
for (long long i = (long long)(0); i < (long long)(N); i++) {
if (A[i] > d) continue;
sum += A[i];
crtsum += A[i];
crt++;
cnt++;
if (cnt == X) break;
if (crt == M) {
sum += crtsum;
crtsum = 0;
crt = 0;
}
}
return sum <= T;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long Q;
cin >> Q;
for (long long _ = (long long)(0); _ < (long long)(Q); _++) {
cin >> N >> M >> T;
A.resize(N);
B.resize(N);
for (long long i = (long long)(0); i < (long long)(N); i++) {
cin >> A[i];
B[i] = A[i];
}
sort((B).begin(), (B).end());
long long lb = 0, ub = N + 1;
while (ub - lb > 1) {
long long mid = (lb + ub) / 2;
if (ok(mid))
lb = mid;
else
ub = mid;
}
if (lb == 0)
cout << lb << " " << T << '\n';
else
cout << lb << " " << B[lb - 1] << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long in[4], c, mi;
string s[3];
void go(vector<long long> v, int d) {
if (d == 3) {
int i;
for (i = 0; i < 4; i++)
if (v[i] > -1 && v[i] < mi) mi = v[i];
return;
}
int i, j;
for (i = 0; i < 4; i++)
if (v[i] > -1)
for (j = i + 1; j < 4; j++)
if (v[j] > -1) {
long long x = v[i], y = v[j];
if (s[d] == "+")
v[i] += v[j];
else
v[i] *= v[j];
v[j] = -1;
go(v, d + 1);
v[i] = x;
v[j] = y;
}
}
int main() {
int i, j, k, l, n, m;
while (cin >> in[1] >> in[2] >> in[3] >> in[0]) {
cin >> s[0] >> s[1] >> s[2];
mi = -1uLL / 2;
vector<long long> v;
for (i = 0; i < 4; i++) v.push_back(in[i]);
go(v, 0);
cout << mi << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101;
int a[N];
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (n == 1) {
if (a[0] % 2 == 1) {
cout << -1 << endl;
} else {
cout << "1\n1" << endl;
}
continue;
}
if (a[0] % 2 == 0) {
cout << "1\n1" << endl;
} else if (a[1] % 2 == 0) {
cout << "1\n2" << endl;
} else {
cout << "2\n1 2" << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int n, k, v[5];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &k), v[i % 3] += k;
if (v[0] >= v[1] && v[0] >= v[2])
printf("back\n");
else if (v[1] >= v[0] && v[1] >= v[2])
printf("chest\n");
else
printf("biceps\n");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
int mod = 10007;
int n;
char s1[maxn], s2[maxn];
unsigned int hash1[maxn], hash2[maxn];
unsigned int key = 10007;
char tank(char c) {
if (c == 'N') return 'S';
if (c == 'S') return 'N';
if (c == 'E') return 'W';
if (c == 'W') return 'E';
}
int main() {
scanf("%d", &n);
n--;
scanf("%s", s1 + 1);
scanf("%s", s2 + 1);
hash1[n] = s1[n];
for (int i = n - 1; i >= 1; i--) {
hash1[i] = s1[i] * key + hash1[i + 1];
key = key * mod;
}
hash2[n] = tank(s2[n]);
for (int i = n - 1; i >= 1; i--) {
hash2[i] = hash2[i + 1] * mod + tank(s2[i]);
}
bool ok = true;
for (int i = n; i >= 1; i--) {
if (hash1[i] == hash2[i]) ok = false;
}
if (ok)
puts("YES");
else
puts("NO");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
scanf("%d%d", &n, &m);
if (n == 1 && m == 1) {
puts("YES\n1");
return 0;
}
if ((n == 1 && m <= 3) || (m == 1 && n <= 3) || (n == 2 && m <= 3) ||
(m == 2 && n <= 3)) {
puts("NO");
return 0;
}
if (n == 1 && m == 4) {
puts("YES\n2 4 1 3");
return 0;
}
if (n == 4 && m == 1) {
puts("YES\n2\n4\n1\n3");
return 0;
}
if (n == 1 && m >= 5) {
puts("YES");
for (int i = 1; i <= m; i += 2) printf("%d ", i);
for (int i = 2; i <= m; i += 2) printf("%d ", i);
return 0;
}
if (n >= 5 && m == 1) {
puts("YES");
for (int i = 1; i <= n; i += 2) printf("%d\n", i);
for (int i = 2; i <= n; i += 2) printf("%d\n", i);
return 0;
}
if (n == m && n == 3) {
puts("YES\n6 1 8\n7 5 3\n2 9 4");
return 0;
}
vector<vector<int> > g;
g.resize(n);
for (int i = 0, u = 1; i < n; i++) {
g[i].resize(m);
for (int j = 0; j < m; j++) g[i][j] = u++;
}
if (n <= m) {
for (int i = 0; i < n; i++)
if (i & 1) {
vector<int> tmp;
for (int j = 0; j < m; j++) tmp.push_back(g[i][(j + 2) % m]);
tmp.swap(g[i]);
}
for (int j = 0; j < m; j++)
if (j & 1) {
vector<int> tmp;
for (int i = 0; i < n; i++) tmp.push_back(g[(i - 1 + n) % n][j]);
for (int i = 0; i < n; i++) g[i][j] = tmp[i];
}
} else {
for (int i = 0; i < n; i++)
if (i & 1) {
vector<int> tmp;
for (int j = 0; j < m; j++) tmp.push_back(g[i][(j - 1 + m) % m]);
tmp.swap(g[i]);
}
for (int j = 0; j < m; j++)
if (j & 1) {
vector<int> tmp;
for (int i = 0; i < n; i++) tmp.push_back(g[(i + 2) % n][j]);
for (int i = 0; i < n; i++) g[i][j] = tmp[i];
}
}
puts("YES");
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d ", g[i][j]);
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<long long> sa;
vector<long long> sort_cyclic_shifts(string const& s) {
long long n = s.size();
const long long alphabet = 256;
vector<long long> p(n), c(n), cnt(max(alphabet, n), 0);
for (long long i = 0; i < n; i++) cnt[s[i]]++;
for (long long i = 1; i < alphabet; i++) cnt[i] += cnt[i - 1];
for (long long i = 0; i < n; i++) p[--cnt[s[i]]] = i;
c[p[0]] = 0;
long long classes = 1;
for (long long i = 1; i < n; i++) {
if (s[p[i]] != s[p[i - 1]]) classes++;
c[p[i]] = classes - 1;
}
vector<long long> pn(n), cn(n);
for (long long h = 0; (1 << h) < n; ++h) {
for (long long i = 0; i < n; i++) {
pn[i] = p[i] - (1 << h);
if (pn[i] < 0) pn[i] += n;
}
fill(cnt.begin(), cnt.begin() + classes, 0);
for (long long i = 0; i < n; i++) cnt[c[pn[i]]]++;
for (long long i = 1; i < classes; i++) cnt[i] += cnt[i - 1];
for (long long i = n - 1; i >= 0; i--) p[--cnt[c[pn[i]]]] = pn[i];
cn[p[0]] = 0;
classes = 1;
for (long long i = 1; i < n; i++) {
pair<long long, long long> cur = {c[p[i]], c[(p[i] + (1 << h)) % n]};
pair<long long, long long> prev = {c[p[i - 1]],
c[(p[i - 1] + (1 << h)) % n]};
if (cur != prev) ++classes;
cn[p[i]] = classes - 1;
}
c.swap(cn);
}
return p;
}
string ss;
void create(string& s) {
ss = s;
s += '$';
sa = sort_cyclic_shifts(s);
sa.erase(sa.begin());
}
vector<long long> lcp_construction(string const& s,
vector<long long> const& p) {
long long n = s.size();
vector<long long> rank(n, 0);
for (long long i = 0; i < n; i++) rank[p[i]] = i;
long long k = 0;
vector<long long> lcp(n - 1, 0);
for (long long i = 0; i < n; i++) {
if (rank[i] == n - 1) {
k = 0;
continue;
}
long long j = p[rank[i] + 1];
while (i + k < n && j + k < n && s[i + k] == s[j + k]) k++;
lcp[rank[i]] = k;
if (k) k--;
}
return lcp;
}
const long long N = 1e5 + 10;
const long long LN = 17;
long long lg[N];
long long sp[LN][N];
long long get(long long l, long long r) {
if (l > r) swap(l, r);
if (l == r) return n - sa[l];
r--;
long long p = lg[r - l + 1];
return min(sp[p][l], sp[p][r - (1 << p) + 1]);
}
long long find(long long i, long long j) {
long long res = 0;
for (long long k = 0; k < n; k++) {
long long gg = get(k, i);
if (gg >= j)
res += j;
else if (k < i)
res += n - sa[k];
else
res += gg;
}
return res;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
n = s.length();
create(s);
vector<long long> lcp = lcp_construction(ss, sa);
for (long long i = 2; i <= n; i++) lg[i] = (lg[i - 1] + !(i & (i - 1)));
for (long long i = 0; i < n - 1; i++) sp[0][i] = lcp[i];
for (long long i = 1; i < LN; i++)
for (long long j = 0; j < n - 1; j++)
if (j + (1LL << (i - 1)) < n - 1)
sp[i][j] = min(sp[i - 1][j], sp[i - 1][j + (1LL << (i - 1))]);
long long l = 0;
long long r = n - 1;
long long res = -1;
long long k;
cin >> k;
if ((n * (n + 1)) / 2 < k) {
cout << "No such line.";
exit(0);
}
while (l <= r) {
long long mid = (l + r) / 2;
if (find(mid, n - sa[mid]) < k) {
l = mid + 1;
} else {
res = mid;
r = mid - 1;
}
}
l = 1;
r = n - sa[res];
long long res2 = -1;
while (l <= r) {
long long mid = (l + r) / 2;
if (find(res, mid) < k) {
l = mid + 1;
} else {
res2 = mid;
r = mid - 1;
}
}
for (long long i = 0; i < res2; i++) cout << ss[sa[res] + i];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2000005;
multiset<int> ms[N];
set<pair<int, int> > S;
int n, m, Q, mn[N], mx[N], s[N], x, y, p[N];
inline void B(const int rt, const int l, const int r) {
mn[rt] = 2e9, mx[rt] = s[rt] = 0;
if (l == r) return p[l] = rt, void();
const int mid = l + r >> 1;
B(rt << 1, l, mid), B(rt << 1 | 1, mid + 1, r);
}
inline int Max(const int p, const int q) { return p > q ? p : q; }
inline int Min(const int p, const int q) { return p < q ? p : q; }
inline void upd() {
register int rt = p[x], ls, rs;
x & 1 ? mn[rt] = (ms[x].size() ? *ms[x].begin() : 2e9)
: mx[rt] = (ms[x].size() ? *ms[x].rbegin() : 0);
while (rt >>= 1)
ls = rt << 1, rs = ls | 1, s[rt] = (s[ls] || s[rs] || (mn[ls] < mx[rs])),
mn[rt] = Min(mn[ls], mn[rs]), mx[rt] = Max(mx[ls], mx[rs]);
}
int main() {
scanf("%d%d%d", &n, &m, &Q), B(1, 1, n << 1);
pair<int, int> now;
while (Q--)
scanf("%d%d", &x, &y),
now = pair<int, int>(x, y), S.count(now) ? ms[x].erase(ms[x].find(y)),
S.erase(now), upd() : (ms[x].insert(y), S.insert(now), upd()),
s[1] ? puts("NO") : puts("YES");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6;
const int INF = 1e9 + 9;
const int B = 1e9 + 7;
int n, m;
int a[N];
set<pair<long long, long long> > st;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = int(1); i <= int(n); ++i) cin >> a[i];
long long lst = -INF;
cin >> m;
for (int i = int(1); i <= int(m); ++i) {
long long w, h;
cin >> w >> h;
long long x = max(lst, 1ll * a[w]);
cout << x << "\n";
lst = x + h;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
inline constexpr int ctoi(const char c) { return c - '0'; }
inline constexpr char itoc(const int n) { return n + '0'; }
template <typename T>
inline T clamp(const T& n, const T& lo, const T& hi) {
return std::max(lo, std::min(n, hi));
}
template <class T>
inline void sort(T& a) {
std::sort(a.begin(), a.end());
}
template <class T1, class T2>
inline void sort(T1& a, T2 comp) {
sort(a.begin(), a.end(), comp);
}
template <class T>
inline int read(T& n) {
return std::cin >> n ? 1 : -1;
}
template <typename T, typename... types>
inline int read(T& n, types&... args) {
return read(n) == -1 ? -1 : read(args...) + 1;
}
template <class T>
inline void write(const T& n) {
std::cout << n;
}
template <typename T, typename... types>
inline void write(const char sep, T& n, types&... args) {
write(n);
write(sep);
write(sep, args...);
}
template <typename T>
inline constexpr bool odd(const T a) {
return bool(a & 1);
}
template <typename T>
inline constexpr bool even(const T a) {
return !odd(a);
}
template <class T>
inline unsigned int mod(const T m, const T n) {
return m >= 0 ? m % n : (n - abs(m % n)) % n;
}
template <class T>
class reader {
public:
void operator()(T& t) const { std::cin >> t; }
};
template <class CONTAINER, class READ_Fn>
void read(CONTAINER& v, const unsigned int size,
const READ_Fn& rfn = reader<typename CONTAINER::value_type>()) {
for (int i = 0; i < size; ++i) {
rfn(v[i]);
}
}
auto pair_cmp = [](const std::pair<signed long, signed long>& p1,
const std::pair<signed long, signed long>& p2) {
return (p1.first < p2.first) ||
(p1.first == p2.first && p1.second < p2.second);
};
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
for (int j = 0; j < 1; ++j) {
int distN = 0, distS = 20000;
int n;
read(n);
bool g = true;
for (int i = 0; i < n; ++i) {
int k;
string s;
read(k, s);
if (s == "South") {
distN += k;
distS -= k;
}
if (s == "North") {
distN -= k;
distS += k;
}
if ((s == "East" || s == "West") && (distN <= 0 || distS <= 0)) g = false;
if (distN < 0 || distS < 0) g = false;
if (!g) break;
}
if (g && distN == 0 && distS == 20000)
cout << "YES";
else
cout << "NO";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 50 + 7;
long long int n, T, cnt = 0, m, mn = N, mx, ans, x, k;
vector<int> v;
string s;
long long int used[N];
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < s.size(); j++) {
if (s[j] == '1') {
used[j]++;
mx = max(mx, used[j]);
}
}
}
cout << mx;
}
int main() {
ios_base::sync_with_stdio(0);
int T = 1;
while (T--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void usort(vector<T> &x) {
sort((x).begin(), (x).end());
x.erase(unique((x).begin(), (x).end()), x.end());
}
template <typename T>
int index(const vector<T> &a, const T &x) {
return lower_bound((x).begin(), (x).end(), x) - a.begin();
}
template <typename T>
T sq(const T &x) {
return x * x;
}
inline int qd(const pair<int, int> &a) {
if ((a.second) > 0) return 0;
if ((a.second) == 0 && (a.first) > 0) return 0;
return 1;
}
bool cmp_len(const pair<int, int> &a, const pair<int, int> &b) {
return sq((a.first)) + sq((a.second)) < sq((b.first)) + sq((b.second));
}
bool cmp_cross(const pair<int, int> &a, const pair<int, int> &b) {
if (qd(a) != qd(b)) return qd(a) < qd(b);
return (a.first) * (b.second) > (b.first) * (a.second);
}
int main() {
vector<pair<int, int> > p;
for (int i = 0; i < (301); ++i) {
for (int j = i; j <= 300; j++) {
if (i | j) p.push_back(make_pair(i, j));
}
}
sort((p).begin(), (p).end(), cmp_len);
int n;
scanf("%d", &n);
vector<pair<int, int> > ans(n);
int t = 1;
for (int i = 1; i < ((int)(p).size()); i++) {
if (cmp_len(p[i - 1], p[i])) p[t++] = p[i];
}
p.erase(p.begin() + n + 1, p.end());
int sum = 0;
for (int i = 0; i < (n); ++i) sum += (p[i].first) + (p[i].second);
if (sum & 1) {
for (int i = n - 1; i >= 0; i--) {
if ((((p[i].first) + (p[i].second)) & 1) ^
(((p[n].first) + (p[n].second)) & 1)) {
p.erase(p.begin() + i);
break;
}
}
}
int x = 0;
int y = 0;
for (int i = n - 1; i >= 0; i--) {
int nx = 1e9, ny = 1e9;
for (int t = 1; t >= -1; t -= 2)
for (int q = 1; q >= -1; q -= 2) {
int mx = x + p[i].first * t, my = y + p[i].second * q;
if ((long long)mx * mx + (long long)my * my <
(long long)nx * nx + (long long)ny * ny) {
ans[i].first = p[i].first * t;
ans[i].second = p[i].second * q;
nx = mx;
ny = my;
}
mx = x + p[i].second * t;
my = y + p[i].first * q;
if ((long long)mx * mx + (long long)my * my <
(long long)nx * nx + (long long)ny * ny) {
ans[i].first = p[i].second * t;
ans[i].second = p[i].first * q;
nx = mx;
ny = my;
}
}
x += ans[i].first;
y += ans[i].second;
}
sort((ans).begin(), (ans).end(), cmp_cross);
puts("YES");
for (int i = 0; i < (n); ++i) {
printf("%d %d\n", x, y);
x += (ans[i].first);
y += (ans[i].second);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m, dx, dy;
int a[200000][2];
long long mul_inv(long long a, long long b) {
long long b0 = b, t, q;
long long x0 = 0, x1 = 1;
if (b == 1) return 1;
while (a > 1) {
q = a / b;
t = b, b = a % b, a = t;
t = x0, x0 = x1 - q * x0, x1 = t;
}
if (x1 < 0) x1 += b0;
return x1;
}
int cnt[2000000];
int main() {
int i, j, k;
scanf("%d%d%d%d", &n, &m, &dx, &dy);
for (i = 0; i < m; i++) scanf("%d%d", &a[i][0], &a[i][1]);
for (i = 0; i < m; i++) {
long long u = a[i][0] * mul_inv(dx, n) % n;
long long t = a[i][1] - u * dy;
t %= n, t += n, t %= n;
cnt[t]++;
}
int ma = 0, mai;
for (i = 0; i < n; i++) {
if (ma < cnt[i]) ma = cnt[i], mai = i;
}
printf("%d %d", 0, mai);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(17);
int n;
cin >> n;
int positives = 0, negatives = 0;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
if (v[i] >= 0)
positives++;
else
negatives++;
}
long long ans = 0;
if (n == 1) {
cout << v[0] << "\n";
return 0;
}
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
ans += abs(v[i]);
}
if (positives == 0) {
ans -= 2 * abs(v[n - 1]);
} else if (negatives == 0) {
ans -= 2 * abs(v[0]);
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string a, b;
cin >> a >> b;
int size = (int)a.size(), dif = 0;
int sizeb = (int)b.size();
int bb = 0, aa = 0, ans = 0;
for (int i = 0; i <= sizeb - 1; i++) {
if (b[i] == '1') bb++;
if (a[i] == '1') aa++;
}
if ((aa + bb) % 2 == 0) {
ans++;
}
for (int i = sizeb; i <= size - 1; i++) {
if (a[i] == '1') {
aa++;
}
if (a[i - sizeb] == '1') {
aa--;
}
if ((aa + bb) % 2 == 0) {
ans++;
}
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, nr, x, sol;
int d[2005], st[2005][2005], dr[2005][2005], sum[2005][2005];
char s[2005];
int modul(int x) {
if (x >= 998244353) {
return x - 998244353;
}
return x;
}
int main() {
cin >> s + 1;
n = strlen(s + 1);
st[0][0] = 1;
for (i = 1; i <= n; i++) {
if (s[i] != '(') {
st[i][0] = st[i - 1][0];
}
for (j = 1; j <= i; j++) {
if (s[i] == '(') {
st[i][j] = st[i - 1][j - 1];
} else {
if (s[i] == ')') {
st[i][j] = st[i - 1][j];
} else {
st[i][j] = modul(st[i - 1][j] + st[i - 1][j - 1]);
}
}
}
}
dr[n + 1][0] = sum[n + 1][0] = 1;
for (i = n; i >= 1; i--) {
if (s[i] != ')') {
dr[i][0] = dr[i + 1][0];
}
for (j = 1; j <= n - i + 1; j++) {
if (s[i] == '(') {
dr[i][j] = dr[i + 1][j];
} else {
if (s[i] == ')') {
dr[i][j] = dr[i + 1][j - 1];
} else {
dr[i][j] = modul(dr[i + 1][j] + dr[i + 1][j - 1]);
}
}
}
for (j = n - i + 1; j >= 0; j--) {
sum[i][j] = modul(dr[i][j] + sum[i][j + 1]);
}
}
for (i = 1; i <= n; i++) {
if (s[i] == '?') {
nr++;
}
if (s[i] == '?' || s[i] == '(') {
for (j = 1; j <= i; j++) {
x = st[i - 1][j - 1] * 1LL * sum[i + 1][j] % 998244353;
d[j] = modul(d[j] + x);
}
}
}
for (i = 1; i <= n; i++) {
d[i] -= d[i + 1];
if (d[i] < 0) {
d[i] += 998244353;
}
sol = (sol + d[i] * 1LL * i) % 998244353;
}
cout << sol;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
int l;
int i = 0;
cin >> k;
cin >> l;
if (l % k != 0) {
cout << "NO";
} else {
while ((l % k == 0) && (l != 0)) {
l = l / k;
i = i + 1;
}
if (l == 1) {
cout << "YES" << endl;
cout << i - 1;
} else {
cout << "NO";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int mark[201][201];
pair<int, int> a[201];
pair<int, int> b[201];
int r;
int n;
int m;
bool D = false;
pair<int, int> dad[201][201];
int ti[201][201];
void DFS(int x, int y) {
mark[x][y] = 1;
for (int i = 0; i < n; i++) {
if ((i + 1) > x) break;
if (0 + a[i].first + a[i].second + x + y - (i + 1) <= r) {
if (mark[x + a[i].first - (i + 1)][y + a[i].second] != -1) {
if (mark[x + a[i].first - (i + 1)][y + a[i].second] == 1) D = true;
continue;
}
dad[x + a[i].first - (i + 1)][y + a[i].second] = {x, y};
DFS(x + a[i].first - (i + 1), y + a[i].second);
}
}
for (int i = 0; i < m; i++) {
if ((i + 1) > y) break;
if (0 + b[i].first + b[i].second + x + y - (i + 1) <= r) {
if (mark[x + b[i].first][y + b[i].second - (i + 1)] != -1) {
if (mark[x + b[i].first][y + b[i].second - (i + 1)] == 1) D = true;
continue;
}
dad[x + b[i].first][y + b[i].second - (i + 1)] = {x, y};
DFS(x + b[i].first, y + b[i].second - (i + 1));
}
}
for (int i = 0; i < n; i++) {
if ((i + 1) > x) break;
if (x + a[i].first - (i + 1) != dad[x][y].first ||
y + a[i].second != dad[x][y].second)
ti[x][y] =
max(ti[x][y], ti[x + a[i].first - (i + 1)][y + a[i].second] + 1);
}
for (int i = 0; i < m; i++) {
if ((i + 1) > y) break;
if (x + b[i].first != dad[x][y].first ||
y + b[i].second - (i + 1) != dad[x][y].second)
ti[x][y] =
max(ti[x][y], ti[x + b[i].first][y + b[i].second - (i + 1)] + 1);
}
mark[x][y] = 2;
}
void BFS(int x, int y) {
queue<pair<int, int> > q;
q.push({x, y});
mark[x][y] = true;
while (q.size() > 0) {
pair<int, int> p = q.front();
x = p.first;
y = p.second;
q.pop();
for (int i = 0; i < n; i++) {
if ((i + 1) > x) break;
if (0 + a[i].first + a[i].second + x + y - (i + 1) <= r) {
if (mark[x + a[i].first - (i + 1)][y + a[i].second] != -1) continue;
mark[x + a[i].first - (i + 1)][y + a[i].second] = mark[x][y] + 1;
q.push({x + a[i].first - (i + 1), y + a[i].second});
}
}
for (int i = 0; i < m; i++) {
if ((i + 1) > y) break;
if (0 + b[i].first + b[i].second + x + y - (i + 1) <= r) {
if (mark[x + b[i].first][y + b[i].second - (i + 1)] != -1) continue;
mark[x + b[i].first][y + b[i].second - (i + 1)] = mark[x][y] + 1;
q.push({x + b[i].first, y + b[i].second - (i + 1)});
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int h, t;
cin >> h >> t >> r >> n;
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
cin >> m;
for (int i = 0; i < m; i++) cin >> b[i].first >> b[i].second;
for (int i = 0; i <= r; i++)
for (int j = 0; j <= r; j++) mark[i][j] = -1;
BFS(h, t);
if (mark[0][0] != -1) {
cout << "Ivan"
<< "\n"
<< mark[0][0] - 1;
return 0;
}
for (int i = 0; i <= r; i++)
for (int j = 0; j <= r; j++) mark[i][j] = -1;
DFS(h, t);
if (D) {
cout << "Draw";
return 0;
}
cout << "Zmey"
<< "\n"
<< ti[h][t];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 100010, MOD = 1e9 + 7;
int m;
int f[NMAX];
vector<int> fact[NMAX];
int prime[NMAX], p_cnt;
set<int> pri[NMAX];
int prime_init() {
bitset<NMAX> flag;
flag.reset();
for (int i = 2; i < NMAX; i++) {
if (!flag[i]) {
prime[p_cnt++] = i;
}
for (int j = 0; j < p_cnt; j++) {
if (i * prime[j] >= NMAX) break;
flag[i * prime[j]] = true;
if (i % prime[j] == 0) break;
}
}
for (int i = 1; i < NMAX; i++) {
for (int j = i * 2; j < NMAX; j += i) {
fact[j].push_back(i);
}
if (flag[i] == false && i != 1) {
for (int j = i; j < NMAX; j += i) {
pri[j].insert(i);
}
}
}
return 0;
}
int gcd(int x, int y) {
if (y) return gcd(y, x % y);
return x;
}
int Power(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = 1LL * ret * x % MOD;
x = 1LL * x * x % MOD;
y >>= 1;
}
return ret;
}
int inv(int x) { return Power(x, MOD - 2); }
int calc(int a, int b) {
int p[10], cnt = 0;
int tmpa = a / b;
cnt = pri[tmpa].size();
auto iter = pri[tmpa].begin();
for (int i = 0; i < cnt; i++) {
p[i] = *iter;
iter++;
}
int sum = 0;
for (int i = 0; i < (1 << cnt); i++) {
int mult = 1, sign = 1;
for (int j = 0; j < cnt; j++) {
if (i & (1 << j)) {
mult *= p[j];
sign *= -1;
}
}
sum += (m / b) / mult * sign;
}
return sum;
}
int main() {
prime_init();
scanf("%d", &m);
f[1] = 1;
for (int i = 2; i <= m; i++) {
int sum = 0;
for (int j : fact[i]) {
sum = (sum + 1LL * f[j] * calc(i, j) % MOD * inv(m) % MOD) % MOD;
}
f[i] = 1LL * (1 + sum) * (1LL * m * inv(m - calc(i, i)) % MOD) % MOD;
}
int sum = 0;
for (int i = 1; i <= m; i++) sum = (sum + 1LL * f[i] * inv(m) % MOD) % MOD;
printf("%d\n", sum);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ii = pair<ll, ll>;
using vi = vector<ll>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vii = vector<ii>;
using vvii = vector<vii>;
const int INF = 2000000000;
const ll LLINF = 9000000000000000000;
template <class T, T (*op)(T, T), T ident>
struct SegmentTree {
int n;
vector<T> tree;
SegmentTree(vector<T> &init) : n(init.size()), tree(2 * n, ident) {
copy(init.begin(), init.end(), tree.begin() + n);
for (int j = n - 1; j > 0; --j) tree[j] = op(tree[2 * j], tree[2 * j + 1]);
}
void update(int i, T val) {
for (tree[i + n] = val, i = (i + n) / 2; i > 0; i /= 2)
tree[i] = op(tree[2 * i], tree[2 * i + 1]);
}
T query(int l, int r) {
T lhs = T(ident), rhs = T(ident);
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) lhs = op(lhs, tree[l++]);
if (!(r & 1)) rhs = op(tree[r--], rhs);
}
return op(l == r ? op(lhs, tree[l]) : lhs, rhs);
}
};
ll mmin(ll l, ll r) { return l < r ? l : r; }
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
ll D, N;
int M;
cin >> D >> N >> M;
vii XP(M + 1, {0LL, 0LL});
for (int i = 1; i <= M; ++i) cin >> XP[i].first >> XP[i].second;
++M;
++M;
XP.push_back({D, 0LL});
assert(M == int(XP.size()));
sort(XP.begin(), XP.end());
vi X(M, 0LL), P(M, 0LL);
for (int i = 0; i < M; ++i) {
X[i] = XP[i].first;
P[i] = XP[i].second;
}
bool pos = true;
for (int i = 1; i < M; ++i) pos = pos && X[i] - X[i - 1] <= N;
if (!pos) {
cout << -1 << endl;
return 0;
}
SegmentTree<ll, mmin, LLINF> st(P);
int p = 0;
ll fuel = N, cost = 0LL;
while (p != M - 1) {
int l = p + 1, r = M - 1;
while (l < r) {
int m = (l + r + 1) / 2;
if (X[m] - X[p] > N)
r = m - 1;
else
l = m;
}
int R = l;
ll mn = st.query(p + 1, R);
if (mn < P[p]) {
l = p + 1;
r = R;
while (l < r) {
int m = (l + r) / 2;
if (st.query(p + 1, m) < P[p])
r = m;
else
l = m + 1;
}
cost += max(0LL, X[l] - X[p] - fuel) * P[p];
fuel += max(0LL, X[l] - X[p] - fuel);
} else {
l = p + 1;
r = R;
while (l < r) {
int m = (l + r) / 2;
if (st.query(p + 1, m) > mn)
l = m + 1;
else
r = m;
}
cost += (N - fuel) * P[p];
fuel = N;
}
assert(p < l);
fuel -= X[l] - X[p];
p = l;
}
cout << cost << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, M = 1e5 + 7;
int n, m;
struct Graph {
int to[M << 1], head[N], next[M << 1], color[M << 1], tot;
void clear() {
fill(head, head + n, -1);
tot = 0;
}
void _add_edge(int a, int b, int c) {
to[tot] = b, next[tot] = head[a], color[tot] = c, head[a] = tot++;
}
void add_edge(int a, int b, int c) {
_add_edge(a, b, c);
_add_edge(b, a, c);
}
} g;
int father[N], f_color[N], visit_edge[M], visit_node[N];
vector<vector<int> > cycles;
void dfs(int u) {
visit_node[u] = 1;
for (int i = g.head[u]; ~i; i = g.next[i]) {
if (visit_edge[i >> 1]) continue;
visit_edge[i >> 1] = 1;
int v = g.to[i];
if (visit_node[v]) {
vector<int> cycle;
int t = u;
while (t != v) {
cycle.push_back(f_color[t]);
visit_node[t]++;
t = father[t];
}
cycle.push_back(g.color[i]);
cycles.push_back(cycle);
} else {
father[v] = u;
f_color[v] = g.color[i];
dfs(v);
}
}
if (visit_node[u] == 1 && u != 0) {
vector<int> cycle;
cycle.push_back(f_color[u]);
cycle.push_back(f_color[u]);
cycles.push_back(cycle);
}
}
vector<int> colors[M];
int character[N], bel[N];
int ans = 0;
int main() {
scanf("%d %d", &n, &m);
g.clear();
for (int i = 0; i < m; i++) {
int u, v, c;
scanf("%d %d %d", &u, &v, &c);
u--, v--;
g.add_edge(u, v, c);
}
dfs(0);
for (int i = 0; i < cycles.size(); i++) {
character[i] = 0;
bel[i] = i;
for (auto c : cycles[i]) {
colors[c].push_back(i);
}
}
ans = -cycles.size();
function<int(int)> get_bel = [&](int u) {
int t = u;
for (; bel[t] != t; t = bel[t])
;
for (int tar = t; u != tar; t = bel[u], bel[u] = tar, u = t)
;
return u;
};
for (int i = 1; i <= m; i++) {
if (colors[i].size() == 0) {
continue;
} else {
ans++;
for (int j = 0; j + 1 < colors[i].size(); j++) {
int a = get_bel(colors[i][j]);
int b = get_bel(colors[i][j + 1]);
if (a != b) {
ans++;
bel[a] = b;
if (character[a] && character[b]) {
ans--;
}
character[b] |= character[a];
} else {
if (character[a] == 0) {
ans++;
character[a] = 1;
}
}
}
}
}
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf(1010101010);
int le_res, aa;
char naam[1000];
int le_naam;
char naam_and_res[1000];
char occ[1000];
int zvals[1000];
void z_functie(char* s, int n, int* z) {
int a(0), b(0);
for (int i(0); i < (n); i++) z[i] = n;
for (int i = 1; i < n; i++) {
int k = max(0, min(b - i, z[i - a]));
while (i + k < n && s[i + k] == s[k]) k++;
z[i] = k;
if (i + k > b) a = i, b = i + k;
}
}
bool chk(char* s) {
for (int i(0); i < (le_res); i++) naam_and_res[le_naam + 1 + i] = s[i];
naam_and_res[le_naam + 1 + le_res] = 0;
z_functie(naam_and_res, le_naam + 1 + le_res, zvals);
for (int i(0); i < (le_res - le_naam + 1); i++) {
int zz(zvals[le_naam + 1 + i]);
if (zz == le_naam && occ[i] == '0') return false;
if (zz != le_naam && occ[i] == '1') return false;
}
return true;
}
char tpl[1000];
char ans[1000];
int main() {
cin >> le_res >> aa;
scanf("%s", naam), le_naam = strlen(naam);
for (int i(0); i < (le_naam); i++) naam_and_res[i] = naam[i];
naam_and_res[le_naam] = '$';
scanf("%s", occ);
for (int i(0); i < (le_res); i++) tpl[i] = '.';
for (int i(0); i < (le_res - le_naam + 1); i++) {
if (occ[i] == '1') {
for (int j(i); j < (i + le_naam); j++) {
tpl[j] = naam[j - i];
}
}
}
for (int i(0); i < (le_naam); i++) {
char c('a' + (((naam[i] - 'a') + 1) % aa));
for (int i(0); i < (le_res); i++) {
if (tpl[i] == '.')
ans[i] = c;
else
ans[i] = tpl[i];
}
if (chk(ans)) {
ans[le_res] = 0;
printf("%s\n", ans);
goto done;
}
}
puts("No solution");
done:;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.