solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 25, M = 3e4 + 25, oo = 1e9 + 7;
const long long OO = 1e18 + 25;
int t, n, m, x, ans;
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
ans = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
ans += x;
}
if (m < n || n == 2)
printf("-1\n");
else {
printf("%d\n", ans * 2);
for (int i = 1; i < n; i++) printf("%d %d\n", i, i + 1);
printf("%d 1\n", n);
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int MOD = 1000000000 + 9;
int n, m, k;
bool ok(int v) {
return (v * k <= n &&
v * k + (n - v * k) / k * (k - 1) + (n - v * k) % k >= m);
}
long long pw(long long a, long long n) {
if (n == 0) return 1;
long long x = pw(a, n / 2);
x = x * x;
x %= MOD;
if (n & 1) x *= a, x %= MOD;
return x;
}
int main() {
cin >> n >> m >> k;
long long res = 0;
int L = 0, R = n / k;
while (abs(L - R) > 1) {
int v = (L + R) / 2;
if (ok(v))
R = v;
else
L = v;
}
while (R >= 0 && ok(R)) R--;
R++;
res = (pw(2, 1 + (2 * R + 1) / 2) + MOD - 2) % MOD;
if (R == 0) res = 0;
res *= k;
res %= MOD;
res += m - k * R;
cout << res % MOD << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 401;
int a[N][N], f[N][N][N];
int tHash[222222], times = 0, pos[N * N];
int n, m, ans;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", a[i] + j);
}
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
for (int k = 1; k <= m; k++) f[i][j][k] = m + 1;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
++times;
for (int k = m; k >= 1; k--) {
if (tHash[a[i][k]] == times) {
f[i][j][k] = min(f[i][j][k], pos[a[i][k]]);
}
tHash[a[i][k]] = times;
pos[a[i][k]] = k;
if (i == j) continue;
if (tHash[a[j][k]] == times) {
f[i][j][k] = min(f[i][j][k], pos[a[j][k]]);
}
tHash[a[j][k]] = times;
pos[a[j][k]] = k;
}
}
ans = 0;
for (int i = m; i >= 1; i--) {
for (int length = 1; length <= n; length++)
for (int j = 1; j + length - 1 <= n; j++) {
int k = j + length - 1;
ans = max(ans, length * (f[j][k][i] - i));
if (j > 1) {
f[j - 1][k][i] = min(f[j - 1][k][i], f[j][k][i]);
}
if (k < n) {
f[j][k + 1][i] = min(f[j][k + 1][i], f[j][k][i]);
}
if (i > 1) {
f[j][k][i - 1] = min(f[j][k][i - 1], f[j][k][i]);
}
}
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bitset<400> iseq[26][400];
bitset<400> sol[400];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, r, c, i, j, k;
char ch;
cin >> n >> m;
for (i = 0; i < n; ++i) {
sol[i].flip();
for (j = 0; j < m; ++j) {
cin >> ch;
iseq[ch - 'a'][i].set(j);
}
}
cin >> r >> c;
for (i = 0; i < r; ++i)
for (j = 0; j < c; ++j) {
cin >> ch;
if (ch == '?') continue;
for (k = 0; k < n; ++k) {
sol[k] &= iseq[ch - 'a'][(k + i) % n] >> j % m |
iseq[ch - 'a'][(k + i) % n] << (m - j % m);
}
}
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) cout << sol[i][j];
cout << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, dap[11111];
struct abc {
int x, y, t, idx;
} a[22222], O;
bool compare1(const abc &i, const abc &j) {
return i.x < j.x || i.x == j.x && i.y < j.y;
}
bool compare2(const abc &i, const abc &j) {
return (double)(i.y - O.y) / (i.x - O.x) < (double)(j.y - O.y) / (j.x - O.x);
}
void go(int lft, int rgt) {
if (lft >= rgt) return;
int mn_idx = min_element(a + lft, a + rgt + 1, compare1) - a;
swap(a[lft], a[mn_idx]);
O = a[lft];
sort(a + lft + 1, a + rgt + 1, compare2);
int mid = rgt + 1, s[2] = {};
s[a[lft].t]++;
while (1) {
s[a[--mid].t]++;
if (s[0] == s[1] && a[lft].t != a[mid].t) break;
}
if (a[lft].t)
dap[a[mid].idx] = a[lft].idx;
else
dap[a[lft].idx] = a[mid].idx;
go(lft + 1, mid - 1);
go(mid + 1, rgt);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= 2 * n; i++) {
scanf("%d %d", &a[i].x, &a[i].y);
a[i].t = (i > n);
a[i].idx = i;
}
go(1, 2 * n);
for (int i = 1; i <= n; i++) {
printf("%d\n", dap[i] - n);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int dd[101][3], d[101] = {0}, kc[101][101];
long long h[101];
void init() {
for (int i = 1; i <= 100; i++) h[i] = 1000000001;
}
int main() {
int n, a[101] = {0};
long x;
cin >> n >> x;
init();
for (int i = 2; i < n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) kc[i][j] = 1000000001;
}
for (int i = 1; i <= n; i++) {
cin >> dd[i][1] >> dd[i][2];
}
d[1] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i != j) {
kc[i][j] = (abs(dd[i][1] - dd[j][1]) + abs(dd[i][2] - dd[j][2])) * x;
if (a[i] != 0) kc[i][j] -= a[i];
}
}
}
int k = 1, min, vt = 1, kt = 0;
h[1] = 0;
while (1) {
min = 1000000001;
kt = 0;
for (int i = 1; i <= n; i++) {
if (d[i] == 0) {
if (h[i] > h[k] + kc[k][i]) h[i] = h[k] + kc[k][i];
}
}
for (int i = 1; i <= n; i++) {
if (min > h[i] && d[i] == 0) {
min = h[i];
vt = i;
}
}
d[vt] = 1;
k = vt;
for (int i = 1; i <= n; i++)
if (d[i] == 0) {
kt = 1;
break;
}
if (kt == 0) break;
}
if (h[n] == 1000000001)
cout << "0";
else
cout << h[n];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[100005], freq[100005];
int t, n, m, x, y, a, b, c, z, p, q, r, qq, sum = 0;
int x1, x2, yy1, y2;
vector<int> adj[100005], v;
set<int> s;
int main() {
cin >> n >> q >> c;
int dp[11][105][105];
for (int p = 0; p <= c; p++) {
for (int i = 1; i < 101; i++) {
for (int j = 1; j < 101; j++) {
dp[p][i][j] = 0;
}
}
}
for (int i = 0; i < n; i++) {
cin >> x1 >> yy1 >> m;
dp[m][x1][yy1]++;
}
for (int i = 0; i <= c; i++) {
for (int j = 1; j <= 100; j++) {
for (int k = 1; k <= 100; k++) {
dp[i][j][k] +=
(dp[i][j - 1][k] + dp[i][j][k - 1] - dp[i][j - 1][k - 1]);
}
}
}
while (q--) {
cin >> t >> x1 >> yy1 >> x2 >> y2;
int ans = 0;
for (int i = 0; i <= c; i++) {
int z = (i + t) % (c + 1);
int count = dp[i][x2][y2] - dp[i][x2][yy1 - 1] - dp[i][x1 - 1][y2] +
dp[i][x1 - 1][yy1 - 1];
ans += (count * z);
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, cx[200010], cy[200010], ans = -1;
char c;
map<char, int> listx, listy;
bool check(int p) {
for (int i = 1; i + p - 1 <= n; i++) {
int j = i + p - 1;
int x1 = cx[n] - (cx[j] - cx[i - 1]);
int y1 = cy[n] - (cy[j] - cy[i - 1]);
int tmp = p - abs(x - x1) - abs(y - y1);
if (tmp >= 0 && tmp % 2 == 0) return 1;
}
return 0;
}
int main() {
listy['U'] = 1;
listy['D'] = -1;
listx['L'] = -1;
listx['R'] = 1;
scanf("%d", &n);
getchar();
for (int i = 1; i <= n; i++) {
scanf("%c", &c);
cx[i] = cx[i - 1] + listx[c];
cy[i] = cy[i - 1] + listy[c];
}
scanf("%d%d", &x, &y);
int l = 0, r = n, mid;
while (l <= r) {
mid = (l + r) / 2;
if (check(mid)) {
r = mid - 1;
ans = mid;
} else
l = mid + 1;
}
printf("%d", ans);
}
| 5 |
#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;
}
pair<float, float> solve(pair<float, float> a, pair<float, float> b,
pair<float, float> c) {
pair<float, float> ans;
if (a.first == b.first) {
ans.first = c.first;
ans.second = c.second + (a.second - b.second);
return ans;
}
if (a.second == b.second) {
ans.second = c.second;
ans.first = c.first + (a.first - b.first);
return ans;
}
if (a.first == c.first) {
ans.first = b.first;
ans.second = b.second + (a.second - c.second);
return ans;
}
if (a.second == c.second) {
ans.second = b.second;
ans.first = b.first + (a.first - c.first);
return ans;
}
float m1 = (a.second - b.second) / (float)(a.first - b.first);
float m2 = (a.second - c.second) / (float)(a.first - c.first);
ans.first =
((b.second - c.second) - (m2 * b.first - m1 * c.first)) / (m1 - m2);
ans.second = m1 * ans.first - m1 * c.first + c.second;
return ans;
}
int main() {
pair<float, float> a, b, c;
scanf("%f%f%f%f%f%f", &a.first, &a.second, &b.first, &b.second, &c.first,
&c.second);
map<pair<float, float>, int> m;
m[solve(a, b, c)] = 1;
m[solve(b, a, c)] = 1;
m[solve(a, c, b)] = 1;
m[solve(c, a, b)] = 1;
m[solve(b, c, a)] = 1;
m[solve(c, b, a)] = 1;
cout << m.size() << "\n";
for (auto it : m) {
float xa = (it.first).first;
float ya = (it.first).second;
if (ya == -0) ya = 0;
if (xa == -0) xa = 0;
cout << xa << " " << ya << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int dp0[300000], dp1[300000], pp[300000], qq[300000];
struct E {
int i, j, a;
} ee[300000];
struct L {
struct L *next;
int h;
};
struct V {
struct L adj;
int h, d, i, a, dp0, dp1;
} vv[300000], *ww[1 + 300000];
void link(int i, int h) {
static struct L ll_[300000 * 2], *l = ll_;
l->h = h;
l->next = vv[i].adj.next;
vv[i].adj.next = l++;
}
void dfs(int h_, int i, int d) {
struct V *u = &vv[i];
struct L *l;
u->h = h_;
u->d = d;
for (l = u->adj.next; l; l = l->next) {
int h = l->h;
if (h != h_) {
struct E *e = &ee[h];
int j = i ^ e->i ^ e->j;
dfs(h, j, d + 1);
}
}
}
struct V *lca(struct V *u, struct V *v, int a) {
while (u != v) {
struct V *tmp;
struct E *e;
if (u->d < v->d) tmp = u, u = v, v = tmp;
e = &ee[u->h];
if (e->a == a) return v;
if (e->a) return NULL;
e->a = a;
u = &vv[u->i ^ e->i ^ e->j];
if (u->a == a) return v;
if (u->a) return NULL;
u->a = a;
}
return u;
}
void dfs2(int p, int i) {
struct V *u = &vv[i];
struct L *l;
int c, h;
long long x;
for (l = u->adj.next; l; l = l->next) {
int h = l->h;
struct E *e = &ee[h];
int j = i ^ e->i ^ e->j;
if (j != p) dfs2(i, j);
}
c = 0;
for (l = u->adj.next; l; l = l->next) {
int h = l->h;
struct E *e = &ee[h];
int j = i ^ e->i ^ e->j;
if (j != p) {
struct V *v = &vv[j];
dp0[c] = v->dp0;
dp1[c] = v->dp1;
c++;
}
}
x = 1;
for (h = 0; h < c; h++) {
x = x * (dp0[h] + dp1[h]) % 998244353;
pp[h] = x;
}
x = 1;
for (h = c - 1; h >= 0; h--) {
x = x * (dp0[h] + dp1[h]) % 998244353;
qq[h] = x;
}
if (u->a) {
u->dp0 = 0;
u->dp1 = x;
} else {
u->dp0 = x;
x = 0;
for (h = 0; h < c; h++) {
long long f = h > 0 ? pp[h - 1] : 1;
long long g = h + 1 < c ? qq[h + 1] : 1;
x = (x + dp1[h] * f % 998244353 * g) % 998244353;
}
u->dp1 = x;
}
}
int main() {
int n, k, h, i, j;
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &vv[i].a);
vv[i].i = i;
}
for (h = 0; h < n - 1; h++) {
struct E *e = &ee[h];
scanf("%d%d", &i, &j), i--, j--;
e->i = i, e->j = j;
link(i, h), link(j, h);
}
dfs(-1, 0, 0);
for (i = 0; i < n; i++) {
struct V *v = &vv[i];
int a = v->a;
if (!a) continue;
if (!ww[a]) {
ww[a] = v;
continue;
}
if (!(ww[a] = lca(v, ww[a], a))) {
printf("0\n");
return 0;
}
}
dfs2(-1, 0);
printf("%d\n", vv[0].dp1);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, j, x, sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> j;
sum = sum + j;
}
cout << (double)sum / n << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long i, j, k, l;
long long x, y, z;
int a, b, r;
cin >> a >> b >> r;
if (a < 2 * r || b < 2 * r)
cout << "Second";
else
cout << "First";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 5;
int n, x, y;
int ask(vector<int> v) {
if (v.size() == 0) return 0;
printf("? %d", v.size());
for (int x : v) {
printf(" %d", x);
}
puts("");
fflush(stdout);
int ans;
scanf("%d", &ans);
return ans;
}
int pos1, pos2;
void solve(vector<int> v) {
int l = 0, r = v.size() - 1, ans = -1;
while (l <= r) {
int mid = l + r >> 1;
vector<int> a;
for (int i = 0; i <= mid; i++) a.push_back(v[i]);
int temp = ask(a);
if (temp == (x ^ y) || temp == y) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
pos1 = v[ans];
}
int main() {
scanf("%d%d%d", &n, &x, &y);
int diff = 0, spe_bit = 0;
for (int i = 0; i <= 9; i++) {
vector<int> v;
for (int j = 1; j <= n; j++) {
if (j >> i & 1) v.push_back(j);
}
int temp = ask(v);
if (temp == (x ^ y) || temp == y) {
diff ^= (1 << i), spe_bit = i;
}
}
vector<int> a, b;
for (int i = 1; i <= n; i++) {
if (i >> spe_bit & 1)
a.push_back(i);
else
b.push_back(i);
}
if (a.size() > b.size())
solve(b);
else
solve(a);
pos2 = pos1 ^ diff;
if (pos2 < pos1) swap(pos1, pos2);
printf("! %d %d\n", pos1, pos2);
fflush(stdout);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[1000] = {0}, n = 0, h = 0, w = 0;
cin >> n;
cin >> h;
for (size_t i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > h)
w += 2;
else
w += 1;
}
cout << w;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int ans = 8;
if (s == "a1" || s == "a8" || s == "h1" || s == "h8")
ans = 3;
else if (s[0] == 'a' || s[0] == 'h' || s[1] == '1' || s[1] == '8')
ans = 5;
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
const int ALPH = 26;
int N, vis[ALPH];
int T, ord[ALPH];
string S[MAXN];
vector<int> adj[ALPH];
void dfs(int v) {
vis[v] = 1;
for (int n : adj[v]) {
if (vis[n] == 1) {
cout << "Impossible\n";
exit(0);
} else if (!vis[n]) {
dfs(n);
}
}
vis[v] = 2;
ord[T++] = v;
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> S[i];
if (i > 0) {
for (int j = 0; j < MAXN; j++) {
if (j == S[i].size()) {
cout << "Impossible\n";
return 0;
}
if (j == S[i - 1].size()) {
break;
}
if (S[i][j] != S[i - 1][j]) {
adj[S[i][j] - 'a'].push_back(S[i - 1][j] - 'a');
break;
}
}
}
}
for (int i = 0; i < ALPH; i++) {
if (!vis[i]) {
dfs(i);
}
}
for (int i = 0; i < ALPH; i++) {
cout << char(ord[i] + 'a');
}
cout << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long maxi = 1e18;
unsigned long long prime[] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
unsigned long long dp[15][1005], mi[15][1005], ans;
int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
for (int i = 1; i <= 10; i++) {
mi[i][0] = 1;
for (int j = 1; j <= 1000; j++) {
mi[i][j] = mi[i][j - 1] * prime[i];
if (mi[i][j] > maxi) mi[i][j] = maxi;
}
}
int n;
cin >> n;
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= n; j++) dp[i][j] = maxi;
}
for (int i = 1; i <= n; i++) dp[1][i] = mi[1][i - 1];
for (int i = 2; i <= 10; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= j; k++) {
if (j % k == 0) {
unsigned long long temp;
bool flag =
__builtin_mul_overflow(dp[i - 1][j / k], mi[i][k - 1], &temp);
if (!flag) dp[i][j] = min(dp[i][j], dp[i - 1][j / k] * mi[i][k - 1]);
}
}
}
}
cout << dp[10][n] << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int P = 1e9 + 7;
bool comp(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) return a.second < b.second;
return a.first < b.first;
}
bool check(int idx, vector<int>& arr, int n) {
int i = idx;
int j = n - 1;
int cnt = n - i;
int last = 0;
int now;
while (cnt != 0) {
now = min(arr[i], arr[j]);
if (now < last) return false;
last = now;
cnt--;
if (arr[i] < arr[j])
i++;
else
j--;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
vector<int> arr(n);
int i, j;
vector<pair<int, int>> now(n);
for (i = 0; i < n; i++) {
cin >> arr[i];
}
int low = 0;
int high = n;
int mid = 0;
int ans = INT_MAX;
while (high - low > 1) {
mid = (low + high) / 2;
if (check(mid, arr, n)) {
ans = min(ans, mid);
high = mid;
} else
low = mid;
}
if (check(mid, arr, n)) ans = min(ans, mid);
if (check(0, arr, n)) ans = 0;
cout << ans << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
template <typename Tp>
inline void read(Tp &x) {
x = 0;
bool f = true;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar()) f ^= ch == '-';
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + (ch ^ 48);
x = f ? x : -x;
}
const long long N = 1e5 + 7, P = 1e9 + 7;
long long a[N];
struct Matrix {
long long m[3][3];
};
Matrix dp;
inline Matrix operator*(Matrix a, Matrix b) {
Matrix c;
c.m[1][1] = (a.m[1][1] * b.m[1][1] + a.m[1][2] * b.m[2][1]) % P;
c.m[1][2] = (a.m[1][1] * b.m[1][2] + a.m[1][2] * b.m[2][2]) % P;
c.m[2][1] = (a.m[2][1] * b.m[1][1] + a.m[2][2] * b.m[2][1]) % P;
c.m[2][2] = (a.m[2][1] * b.m[1][2] + a.m[2][2] * b.m[2][2]) % P;
return c;
}
inline Matrix operator+(Matrix a, Matrix b) {
Matrix c;
c.m[1][1] = (a.m[1][1] + b.m[1][1]) % P;
c.m[1][2] = (a.m[1][2] + b.m[1][2]) % P;
c.m[2][1] = (a.m[2][1] + b.m[2][1]) % P;
c.m[2][2] = (a.m[2][2] + b.m[2][2]) % P;
return c;
}
inline Matrix power(Matrix a, long long x) {
Matrix ans;
ans.m[1][1] = ans.m[2][2] = 1, ans.m[1][2] = ans.m[2][1] = 0;
while (x) {
if (x & 1) ans = ans * a;
a = a * a;
x >>= 1;
}
return ans;
}
struct Node {
Matrix val;
long long tag;
};
struct Segment_Tree {
Node tre[N << 2];
inline void pushdown(long long p) {
if (tre[p].tag) {
tre[p << 1].tag += tre[p].tag, tre[p << 1 | 1].tag += tre[p].tag;
Matrix v = power(dp, tre[p].tag);
tre[p << 1].val = tre[p << 1].val * v,
tre[p << 1 | 1].val = tre[p << 1 | 1].val * v;
tre[p].tag = 0;
}
}
inline void build(long long p, long long l, long long r) {
if (l == r) {
tre[p].val = power(dp, a[l] - 1);
return;
}
long long mid = (l + r) >> 1;
build(p << 1, l, mid), build(p << 1 | 1, mid + 1, r);
tre[p].val = tre[p << 1].val + tre[p << 1 | 1].val;
}
inline void update(long long p, long long l, long long r, long long x,
long long y, long long k, Matrix v) {
if (l >= x && r <= y) {
tre[p].val = tre[p].val * v;
tre[p].tag += k;
return;
}
pushdown(p);
long long mid = (l + r) >> 1;
if (x <= mid) update(p << 1, l, mid, x, y, k, v);
if (y > mid) update(p << 1 | 1, mid + 1, r, x, y, k, v);
tre[p].val = tre[p << 1].val + tre[p << 1 | 1].val;
}
inline Matrix query(long long p, long long l, long long r, long long x,
long long y) {
if (l >= x && r <= y) return tre[p].val;
pushdown(p);
long long mid = (l + r) >> 1;
if (y <= mid) return query(p << 1, l, mid, x, y);
if (x > mid) return query(p << 1 | 1, mid + 1, r, x, y);
return query(p << 1, l, mid, x, y) + query(p << 1 | 1, mid + 1, r, x, y);
}
};
Segment_Tree T;
signed main() {
dp.m[1][2] = dp.m[2][2] = dp.m[2][1] = 1;
long long n, m;
read(n), read(m);
for (long long i = 1; i <= n; ++i) read(a[i]);
T.build(1, 1, n);
while (m--) {
long long opt;
read(opt);
if (opt == 1) {
long long l, r, k;
read(l), read(r), read(k);
T.update(1, 1, n, l, r, k, power(dp, k));
} else {
long long l, r;
read(l), read(r);
printf("%lld\n", T.query(1, 1, n, l, r).m[2][2]);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) {
if (!b) return a;
return (b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long is_prime(long long n) {
if (n == 1) return 0;
if (n == 2) return 1;
for (long long i = 2; i <= sqrt(n); i++)
if (n % i == 0) return 0;
return 1;
}
long long is_integer(double n) {
if (floor(n) == ceil(n)) return 1;
return 0;
}
long long sto_int(string s) {
stringstream ss(s);
long long n;
ss >> n;
return n;
}
string to_string(long long n) {
stringstream ss;
ss << n;
string s = ss.str();
return s;
}
long long now[200001], dis[200001];
vector<pair<long long, long long> > v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
;
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> now[i];
for (long long i = 1; i <= n; i++) cin >> dis[i];
for (long long i = 1; i <= n; i++) {
v.push_back({now[i] - dis[i], i});
}
long long ans = 0;
sort((v).begin(), (v).end());
for (long long i = 1; i <= k; i++) {
ans += now[v[i - 1].second];
}
for (long long i = k + 1; i <= n; i++) {
ans += min(now[v[i - 1].second], dis[v[i - 1].second]);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h = 0, n, k, y, sum = 0;
cin >> n;
cin >> k;
for (int i = 0; i < n; i++) {
cin >> y;
if (y + k <= 5) h++;
if (h == 3) {
sum++;
h = 0;
}
}
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char a[100000 + 10];
int nex[100000 + 10];
int h[100000 + 10];
int ans[100000][2];
int sum[100000 + 10];
void init(char *c) {
int lenc = strlen(c);
for (int i = 1; i < lenc; i++) {
int j = nex[i - 1];
while (c[i] != c[j] && j != 0) {
j = nex[j - 1];
}
if (c[i] == c[j]) j++;
nex[i] = j;
}
return;
}
int KMP(char *c, char *d) {
int lena = strlen(c);
int lenb = strlen(d);
int ans = 0;
int j = 0;
for (int i = 0; i < lena; i++) {
if (c[i] == d[j]) {
if (j == lenb - 1) {
ans++;
j = nex[j];
} else {
j++;
}
} else {
while (j != 0 && c[i] != d[j]) {
j = nex[j - 1];
}
if (c[i] == d[j]) {
j++;
}
}
}
return ans;
}
int main() {
scanf("%s", a);
init(a);
int lena = strlen(a);
int tot = 0;
int i = lena;
int num = 0;
for (int j = lena; j >= 0; j--) h[j] = 1;
for (int j = lena - 1; j >= 0; j--) {
h[nex[j]] += h[j + 1];
}
while (i > 0) {
ans[++tot][0] = i;
ans[tot][1] = h[i];
i = nex[i - 1];
}
printf("%d\n", tot);
for (int i = tot; i >= 1; i--) {
printf("%d %d\n", ans[i][0], ans[i][1]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long f[2][205][1005], t;
int n, K, a[205], ans, D;
int main() {
cin >> n >> K;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
f[0][0][0] = 1;
for (int i = 0; i < n; i++) {
D ^= 1;
memset(f[D], 0, sizeof(f[D]));
for (int j = 0; j <= i; j++)
for (int k = 0; k <= K; k++)
if (t = f[D ^ 1][j][k]) {
int tmp = k + j * (a[i + 1] - a[i]);
if (tmp > K) continue;
(f[D][j][tmp] += j * t % 1000000007) %= 1000000007;
(f[D][j][tmp] += t) %= 1000000007;
if (j) (f[D][j - 1][tmp] += j * t % 1000000007) %= 1000000007;
(f[D][j + 1][tmp] += t) %= 1000000007;
}
}
for (int i = 0; i <= K; i++) ans = (ans + f[D][0][i]) % 1000000007;
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const int maxn = 2e5 + 10;
const int maxm = 100 + 10;
int T, n, cnt;
int ans[maxn];
char s[maxn];
queue<int> q0;
queue<int> q1;
int main() {
scanf("%d", &T);
while (T--) {
cnt = 0;
scanf("%d", &n);
scanf("%s", s);
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
if (!q1.empty()) {
int t = q1.front();
q1.pop();
q0.push(t);
ans[i] = t;
} else {
q0.push(++cnt);
ans[i] = cnt;
}
} else {
if (!q0.empty()) {
int t = q0.front();
q0.pop();
q1.push(t);
ans[i] = t;
} else {
q1.push(++cnt);
ans[i] = cnt;
}
}
}
printf("%d\n", cnt);
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
printf("\n");
while (!q0.empty()) q0.pop();
while (!q1.empty()) q1.pop();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 200;
template <class Ruby_Rose>
inline void read(Ruby_Rose &x) {
x = 0;
char ch = getchar(), w = 0;
while (!isdigit(ch)) w = (ch == '-'), ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
x = w ? -x : x;
}
int m, n, k, t, val[N], dif[N];
struct trap {
int l, r, d;
};
vector<trap> buc[N];
bool cmp(int a, int b) { return a > b; }
inline int check(int x) {
for (register int i = 1; i <= n + 1; i++) {
for (register int j = 0; j < buc[i].size(); j++) {
if (buc[i][j].d > val[x]) {
dif[i]++, dif[buc[i][j].r + 1]--;
}
}
}
int tmp = n + 1;
for (register int i = 1; i <= n; i++) {
dif[i] += dif[i - 1];
if (dif[i] > 0) tmp += 2;
}
for (register int i = 1; i <= n; i++) dif[i] = 0;
return (tmp <= t);
}
int main() {
read(m), read(n), read(k), read(t);
for (register int i = 1; i <= m; i++) read(val[i]);
sort(val + 1, val + 1 + m, cmp);
for (register int i = 1; i <= k; i++) {
trap tmp;
read(tmp.l), read(tmp.r), read(tmp.d);
buc[tmp.l].push_back(tmp);
}
int l = 0, r = m;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (check(mid))
l = mid;
else
r = mid - 1;
}
cout << l << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int a[N + 2], p[N + 2];
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
a[x] = i, p[i] = 0;
}
p[n + 1] = 1;
int nx = -1;
for (int i = 1; i <= n; i++) {
if (nx == -1) {
p[a[i]] = 1;
if (p[a[i] + 1] == 0) nx = a[i] + 1;
} else {
if (a[i] != nx) {
cout << "NO\n";
return;
}
nx++;
if (p[nx]) nx = -1;
}
}
cout << "YES\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
void read(char& a) { scanf("%c", &a); }
void write(const char& a) { printf("%c", a); }
char BUF[1234560];
void read(string& a) {
scanf("%s", BUF);
a = string(BUF);
}
void write(const string& a) { printf("%s", a.c_str()); }
void read(int& a) { scanf("%d", &a); }
void write(const int& a) { printf("%d", a); }
void read(long long& a) { scanf("%I64d", &a); }
void write(const long long& a) { printf("%I64d", a); }
void read(double& a) { scanf("%lf", &a); }
void write(const double& a) { printf("%lf", a); }
void read(long double& a) { scanf("%Lf", &a); }
void write(const long double& a) { printf("%Lf", a); }
template <template <typename T, typename A = allocator<T> > class C, class T>
void read(C<T>& a) {
int sz = a.size();
for (int i = 0; i < sz; ++i) read(a[i]);
}
template <template <typename T, typename A = allocator<T> > class C, class T>
void write(C<T>& a) {
int sz = a.size();
if (sz != 0) write(a[0]);
for (int i = 0; i < sz; ++i) {
write(' ');
write(a[i]);
}
}
template <typename T1, typename T2>
void read(T1& t1, T2& t2) {
read(t1);
read(t2);
}
template <typename T1, typename T2>
void write(const T1& t1, const T2& t2) {
write(t1);
write(' ');
write(t2);
}
template <typename T1, typename T2, typename T3>
void read(T1& t1, T2& t2, T3& t3) {
read(t1);
read(t2);
read(t3);
}
template <typename T1, typename T2, typename T3>
void write(const T1& t1, const T2& t2, const T3& t3) {
write(t1);
write(' ');
write(t2);
write(' ');
write(t3);
}
template <template <typename T, typename A = allocator<T> > class C, class T>
void sort(C<T>& a) {
sort((a).begin(), (a).end());
}
int main() {
string s;
read(s);
string t;
read(t);
int n = s.size();
int m = t.size();
int it{0};
int jt{m - 1};
for (auto i = ((0)); i < decltype(i)((n)); ++i) {
while (it < m && t[it] != s[i]) ++it;
++it;
}
for (auto j = ((n - 1)); j > decltype(j)((-1)); --j) {
while (jt > -1 && t[jt] != s[j]) --jt;
--jt;
}
int a{jt - it + 2};
write(a < 0 ? 0 : a);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 210000;
const long long base = 1e9 + 7;
struct Node {
int x, y, w;
};
void solve() {
long long result = 0;
long long n;
cin >> n;
vector<long long> zx(n), zy(n);
long long lastb = 0;
for (int i = 0; i < n / 2; ++i) {
long long t;
cin >> t;
zx[i] = t;
long long a, b;
a = -1;
b = 1000000;
long long b1 = sqrt(t) + 3;
for (long long j = 1; j < b1; ++j) {
if (t % j != 0) continue;
long long k = t / j;
if (j >= k) break;
if (j % 2 != k % 2) continue;
long long na = (k - j) / 2;
long long nb = (k + j) / 2;
if (na > lastb && nb < b) {
a = na;
b = nb;
}
}
if (a <= lastb) {
cout << "No" << endl;
return;
}
zy[i] = a * a - lastb * lastb;
lastb = b;
}
cout << "Yes" << endl;
for (int i = 0; i < n / 2; ++i) {
cout << zy[i] << ' ' << zx[i] << ' ';
}
}
int main() {
const int inId = 0;
const int outId = 0;
if (inId > 0) {
cerr << "redirect stdin to input " << inId << endl;
string s = "input";
s += to_string(inId);
s += ".txt";
auto r = freopen(s.c_str(), "r", stdin);
if (r == nullptr) {
cerr << "invalid input file " << s;
}
}
if (outId > 0) {
cerr << "redirect stdout to stdout " << outId << endl;
string s = "stdout";
s += to_string(outId);
s += ".txt";
auto r = freopen(s.c_str(), "w", stdout);
if (r == nullptr) {
cerr << "invalid output file " << s;
}
}
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(10);
solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
long long x, y;
cin >> t;
while (t--) {
cin >> x >> y;
if (x > y + 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long MOD = 998244353;
const long long inf = 1e18;
const long long MAX = 2e5 + 1;
inline long long add(long long a, long long b) {
return ((a % mod) + (b % mod)) % mod;
}
inline long long sub(long long a, long long b) {
return ((a % mod) - (b % mod) + mod) % mod;
}
inline long long mul(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
long long pwr(long long x, long long n) {
x = x % mod;
if (!n) return 1;
if (n & 1)
return mul(x, pwr(mul(x, x), (n - 1) / 2));
else
return pwr(mul(x, x), n / 2);
}
long long modinv(long long n) { return pwr(n, mod - 2); }
long long inv(long long i) {
if (i == 1) return 1;
return (MOD - (MOD / i) * inv(MOD % i) % MOD) % MOD;
}
bool f(int a, int b) { return a > b; }
struct cmp {
bool operator()(const int& k1, const int& k2) { return k1 > k2; }
};
vector<int> ans;
void dfs(vector<vector<int>>& graph, vector<int>& vis, int node) {
vis[node] = 1;
for (int child : graph[node]) {
if (!vis[child]) dfs(graph, vis, child);
}
ans.push_back(node);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tt = 1;
cin >> tt;
while (tt--) {
int n, m;
cin >> n >> m;
vector<vector<int>> graph(n);
vector<pair<int, int>> edges;
ans.clear();
for (int i = 0; i < m; i++) {
int t, x, y;
cin >> t >> x >> y;
x--;
y--;
edges.push_back({x, y});
if (t) graph[x].push_back(y);
}
vector<int> vis(n, 0);
for (int i = 0; i < n; i++) {
if (!vis[i]) dfs(graph, vis, i);
}
vector<int> pos(n);
for (int i = 0; i < n; i++) pos[ans[i]] = i;
bool counter = false;
for (int i = 0; i < n; i++) {
for (int child : graph[i]) {
if (pos[child] > pos[i]) {
counter = true;
}
}
}
if (counter)
cout << "NO\n";
else {
cout << "YES\n";
for (auto p : edges) {
int x = p.first, y = p.second;
if (pos[x] > pos[y])
cout << x + 1 << " " << y + 1 << "\n";
else
cout << y + 1 << " " << x + 1 << "\n";
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int SIZE = 100005;
int h[SIZE], l[SIZE], r[SIZE], dp[SIZE];
vector<int> g[SIZE], c[SIZE];
int calc(int a, int b) { return min(r[a], r[b]) - max(l[a], l[b]); }
class panel {
public:
int num, height, pos;
bool is_left;
panel() {}
panel(int a, int b, int c, bool d) : num(a), height(b), pos(c), is_left(d){};
bool operator<(const panel& Tp_) const {
if (pos != Tp_.pos) return pos < Tp_.pos;
if (is_left != Tp_.is_left) return is_left < Tp_.is_left;
return num < Tp_.num;
}
};
vector<panel> pan;
int get_dp(int p) {
if (p == 0) {
return 2147483647;
} else if (dp[p] == -1) {
int tmp = 0;
for (int i = 0; i < g[p].size(); i++) {
tmp = max(tmp, min(get_dp(g[p][i]), c[p][i]));
}
return dp[p] = tmp;
} else
return dp[p];
}
int main() {
int n, t;
scanf("%d%d", &n, &t);
n += 2;
h[0] = 0;
h[1] = t;
l[0] = l[1] = -2147483647 / 2;
r[0] = r[1] = 2147483647 / 2;
for (int i = 2; i < n; i++) {
scanf("%d%d%d", h + i, l + i, r + i);
pan.push_back(panel(i, h[i], l[i], true));
pan.push_back(panel(i, h[i], r[i], false));
}
sort(pan.begin(), pan.end());
set<pair<int, int> > now;
now.insert(make_pair(0, 0));
now.insert(make_pair(t, 1));
for (int i = 0; i < pan.size(); i++) {
if (!pan[i].is_left) {
now.erase(make_pair(pan[i].height, pan[i].num));
} else {
set<pair<int, int> >::iterator it =
now.insert(make_pair(pan[i].height, pan[i].num)).first;
int down = (--it)->second;
++it;
int up = (++it)->second;
if (g[up].size() && g[up].back() == down) {
g[up].pop_back();
c[up].pop_back();
}
g[up].push_back(pan[i].num);
c[up].push_back(calc(up, pan[i].num));
g[pan[i].num].push_back(down);
c[pan[i].num].push_back(calc(pan[i].num, down));
}
}
for (int i = 0; i < n; i++) dp[i] = -1;
printf("%d\n", get_dp(1));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int N;
long long mod = 1e9 + 7;
long long fastPow(long long N, long long P) {
if (P == 0) return 1;
long long res = fastPow(N, P >> 1);
res = (res * res) % mod;
if (P & 1) res = (res * N) % mod;
return res;
}
long long modInv(long long num) { return fastPow(num, mod - 2); }
long long nCr(long long n, long long r) {
if (n == r) return 1;
return (((nCr(n - 1, r) * n) % mod) * modInv((n - r))) % mod;
}
int main() {
cin >> N;
cout << nCr(N << 1, N) - N << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long x;
int main() {
scanf("%lld", &x);
vector<pair<long long, long long> > res;
long long to = sqrt(x);
bool flag = false;
for (long long i = 1; i <= to; i++) {
long long s = x - (i - 1) * (i - 1 + 1ll) * (2 * (i - 1) + 1ll) / 6ll;
s += i * (1 + (i - 1)) * (i - 1) / 2;
long long temp = i * i - (1 + (i - 1)) * (i - 1) / 2;
if (temp <= 0) break;
if (s <= 0) break;
if (s % temp == 0) {
long long m = s / temp;
if (m < i) break;
if (i == m) flag = true;
res.push_back(pair<long long, long long>(i, m));
}
}
printf("%d\n", res.size() * 2 - flag);
for (int i = 0; i < res.size(); i++)
printf("%lld %lld\n", res[i].first, res[i].second);
for (int i = (int)res.size() - 1; i >= 0; i--)
if (res[i].first != res[i].second)
printf("%lld %lld\n", res[i].second, res[i].first);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long a, b;
cin >> a >> b;
if (a == 0 and b == 1)
cout << "YES";
else if (a == 1 and b == 0)
cout << "YES";
else if (a == 0 and b == 0)
cout << "NO";
else if (abs(a - b) <= 1)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> fname;
void splitString(vector<string>* v, string str) {
vector<int> begin;
vector<int> end;
bool inWord = false;
for (int i = 0; i < str.length(); i++) {
if ((str[i] <= 'Z' && str[i] >= 'A') || (str[i] <= 'z' && str[i] >= 'a') ||
(str[i] <= '9' && str[i] >= '0')) {
if (!inWord) {
begin.push_back(i);
inWord = true;
}
if (i == str.length() - 1) {
end.push_back(i + 1);
}
} else {
if (inWord) {
end.push_back(i);
inWord = false;
}
}
}
(*v).clear();
for (int i = 0; i < begin.size(); i++) {
(*v).push_back(str.substr(begin[i], end[i] - begin[i]));
}
return;
}
int dataTypeCode(string str) {
if (str == "T") {
return 1;
} else if (str == "int") {
return 2;
} else if (str == "double") {
return 3;
} else if (str == "string") {
return 4;
} else {
cout << " unknown data type: " << str << endl;
}
return -1;
}
int makeIndex(string* func, vector<int>* types, int mask) {
int ind = 0;
int m = 1;
int mask_i = 1;
for (int i = 0; i < 5; i++) {
bool mm = (mask & mask_i);
if (i >= (*types).size()) {
if (!mm) {
return 0;
} else {
mask_i *= 2;
continue;
}
}
int code = (*types)[i];
if (!mm) {
ind += m;
} else {
ind += m * code;
}
m *= 5;
mask_i *= 2;
}
int f_ind;
map<string, int>::iterator it = fname.find(*func);
if (it == fname.end()) {
f_ind = fname.size();
fname[*func] = f_ind;
} else {
f_ind = it->second;
}
ind += 3125 * f_ind;
return ind;
}
int main() {
int n;
cin >> n;
vector<int> data;
data.reserve(n);
string str;
vector<string> v;
v.reserve(10);
getline(cin, str);
vector<int> types;
types.reserve(5);
for (int i = 0; i < n; i++) {
types.clear();
getline(cin, str);
splitString(&v, str);
for (int j = 0; j < v.size() - 2; j++) {
types.push_back(dataTypeCode(v[j + 2]));
}
int ind = makeIndex(&(v[1]), &types, 31);
data.push_back(ind);
}
sort(data.begin(), data.end());
int m;
map<string, int> vars;
cin >> m;
getline(cin, str);
for (int i = 0; i < m; i++) {
getline(cin, str);
splitString(&v, str);
vars[v[1]] = dataTypeCode(v[0]);
}
int k;
cin >> k;
getline(cin, str);
for (int i = 0; i < k; i++) {
types.clear();
getline(cin, str);
splitString(&v, str);
for (int j = 0; j < v.size() - 1; j++) {
types.push_back(vars[v[j + 1]]);
}
int ans = 0;
for (int j = 0; j < 32; j++) {
int ind = makeIndex(&(v[0]), &types, j);
if (ind < 0) continue;
if (binary_search(data.begin(), data.end(), ind)) {
ans++;
}
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k;
cin >> s;
if (n == 1 && k > 0)
s[0] = '0';
else {
if (s[0] != '1' && k > 0) {
s[0] = '1';
k--;
}
for (int i = 1; i < n; i++) {
if (s[i] != '0' && k > 0) {
s[i] = '0';
k--;
}
}
}
cout << s;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[(1 << 20)], maxi[(1 << 20)], b, k[200], c[200], dp2[(1 << 20)],
maxi2[(1 << 20)];
int a[200];
vector<pair<long long int, pair<long long int, long long int> > > v;
int main() {
int i, j, n, m, q;
cin >> n >> m >> b;
for (i = 0; i < n; i++) {
cin >> c[i] >> k[i] >> j;
int p = 0;
while (j--) {
cin >> q;
q--;
p = p | (1 << q);
}
a[i] = p;
v.push_back(make_pair(k[i], make_pair(c[i], a[i])));
}
sort(v.begin(), v.end());
memset(dp, -1, sizeof(dp));
memset(maxi, 0, sizeof(maxi));
dp[0] = 0;
maxi[0] = 0;
long long int ans = 1e18 + 1e15;
for (i = 0; i < n; i++) {
k[i] = v[i].first;
c[i] = v[i].second.first;
a[i] = v[i].second.second;
for (j = 0; j < (1 << m); j++)
if (dp[j] != -1) {
if (dp[j | a[i]] == -1 || dp[j | a[i]] > dp[j] + c[i]) {
dp[j | a[i]] = dp[j] + c[i];
}
}
if (dp[(1 << m) - 1] != -1) ans = min(ans, dp[(1 << m) - 1] + b * k[i]);
}
if (ans == 1e18 + 1e15)
cout << -1;
else
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gi() {
T x = 0;
bool f = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') f = 1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return f ? -x : x;
}
const int N = 5010, M = 1e5 + 10;
int len[M], x[M], y[M], dir[M], ans[M], n, Q;
namespace cpp1 {
int c[N << 1][N], x[M], y[M];
void add(int x, int y, int k) {
for (; x <= n * 2; x += (x & (-x)))
for (int i = y; i <= n; i += (i & (-i))) c[x][i] += k;
}
int sum(int x, int y) {
int res = 0;
for (; x; x -= (x & (-x)))
for (int i = y; i; i -= (i & (-i))) res += c[x][i];
return res;
}
int t[N << 1];
void add(int x, int k) {
for (; x <= 2 * n; x += (x & (-x))) t[x] += k;
}
int sum(int x) {
int res = 0;
for (; x; x -= (x & (-x))) res += t[x];
return res;
}
void solve(int op) {
memset(t, 0, sizeof(t));
for (int i = 1; i <= Q; i++) {
if (dir[i] == op) add(x[i] + y[i], 1), add(x[i] + y[i] + len[i] + 1, -1);
if (!dir[i]) ans[i] += sum(x[i] + y[i]);
}
memset(c, 0, sizeof(c));
for (int i = 1; i <= Q; i++) {
if (dir[i] == op) {
add(x[i] + y[i], 1, -1);
add(x[i] + y[i], x[i], 1);
add(x[i] + y[i] + len[i] + 1, 1, 1);
add(x[i] + y[i] + len[i] + 1, x[i], -1);
}
if (!dir[i]) ans[i] += sum(x[i] + y[i], x[i]);
}
memset(c, 0, sizeof(c));
for (int i = 1; i <= Q; i++) {
if (dir[i] == op) {
add(x[i] + y[i], 1, -1);
add(x[i] + y[i], y[i], 1);
add(x[i] + y[i] + len[i] + 1, 1, 1);
add(x[i] + y[i] + len[i] + 1, y[i], -1);
}
if (!dir[i]) ans[i] += sum(x[i] + y[i], y[i]);
}
}
} // namespace cpp1
int main() {
n = gi<int>(), Q = gi<int>();
for (int i = 1; i <= Q; i++)
if (gi<int>() == 1)
dir[i] = gi<int>(), x[i] = gi<int>(), y[i] = gi<int>(),
len[i] = gi<int>();
else
x[i] = gi<int>(), y[i] = gi<int>();
for (int i = 1; i <= Q; i++) cpp1 ::x[i] = x[i], cpp1 ::y[i] = y[i];
cpp1 ::solve(1);
for (int i = 1; i <= Q; i++) cpp1 ::y[i] = n - y[i] + 1, cpp1 ::x[i] = x[i];
cpp1 ::solve(2);
for (int i = 1; i <= Q; i++) cpp1 ::x[i] = n - x[i] + 1, cpp1 ::y[i] = y[i];
cpp1 ::solve(3);
for (int i = 1; i <= Q; i++)
cpp1 ::x[i] = n - x[i] + 1, cpp1 ::y[i] = n - y[i] + 1;
cpp1 ::solve(4);
for (int i = 1; i <= Q; i++)
if (!dir[i]) printf("%d\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
namespace SA {
const int MAXN = 1 << 20;
char* S;
int N, gap;
int sa[MAXN], pos[MAXN], tmp[MAXN], lcp[MAXN];
bool sufCmp(int i, int j) {
if (pos[i] != pos[j]) return pos[i] < pos[j];
i += gap;
j += gap;
return (i < N && j < N) ? pos[i] < pos[j] : i > j;
}
void buildSA() {
N = strlen(S);
for (int i = 0; i < (int)(N); ++i) sa[i] = i, pos[i] = S[i];
for (gap = 1;; gap *= 2) {
sort(sa, sa + N, sufCmp);
for (int i = 0; i < (int)(N - 1); ++i)
tmp[i + 1] = tmp[i] + sufCmp(sa[i], sa[i + 1]);
for (int i = 0; i < (int)(N); ++i) pos[sa[i]] = tmp[i];
if (tmp[N - 1] == N - 1) break;
}
}
void buildLCP() {
for (int i = 0, k = 0; i < N; ++i)
if (pos[i] != N - 1) {
for (int j = sa[pos[i] + 1]; S[i + k] == S[j + k];) ++k;
lcp[pos[i]] = k;
if (k) --k;
}
}
} // namespace SA
char s[500005];
int v[500005];
int n;
int nkless[500005];
vector<int> vls[1000005];
int cwv(int vl, int s, int e) {
if (e - s <= 0) return 0;
vl += 500002;
return lower_bound(vls[vl].begin(), vls[vl].end(), e) -
lower_bound(vls[vl].begin(), vls[vl].end(), s);
}
int proc(int i, int mj) {
int ej = nkless[i];
return cwv(v[i], mj, ej + 1);
}
int main() {
scanf("%d %s", &n, s);
SA::S = s;
SA::buildSA();
SA::buildLCP();
for (int i = (0); i < (n); i++) {
v[i + 1] = v[i];
if (s[i] == '(')
v[i + 1]++;
else
v[i + 1]--;
}
for (int i = (0); i < (n + 1); i++) {
vls[v[i] + 500002].push_back(i);
}
vector<pair<int, int> > stk;
stk.emplace_back(-1e8, n);
for (int i = n - 1; i >= 0; i--) {
while (stk.back().first >= v[i]) stk.pop_back();
nkless[i] = stk.back().second;
stk.emplace_back(v[i], i);
}
int clen = 0;
long long res = 0;
for (int z = (0); z < (n); z++) {
int i = SA::sa[z];
int a = proc(i, i + clen + 1);
res += a;
clen = SA::lcp[z];
}
printf("%lld\n", res);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int mod = 7340033;
long long powmod(long long a, long long b) {
long long res = 1;
if (a >= mod) a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a;
if (res >= mod) res %= mod;
a = a * a;
if (a >= mod) a %= mod;
}
return res;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
namespace FFT {
const int MAX = 3000;
const double PI = acos(-1);
int N;
complex<double> omega[MAX];
complex<double> a1[MAX], a2[MAX];
complex<double> z1[MAX], z2[MAX];
void fft(complex<double> *a, complex<double> *z, int m = N) {
if (m == 1) {
z[0] = a[0];
} else {
int s = N / m;
m /= 2;
fft(a, z, m);
fft(a + s, z + m, m);
for (int i = (0); i < (m); ++i) {
complex<double> c = omega[s * i] * z[m + i];
z[m + i] = z[i] - c;
z[i] += c;
}
}
}
void mult(long long *a, long long *b, long long *c, int len) {
N = 2 * len;
while (N & (N - 1)) ++N;
assert(N <= MAX);
for (int i = (0); i < (N); ++i) a1[i] = 0;
for (int i = (0); i < (N); ++i) a2[i] = 0;
for (int i = (0); i < (len); ++i) a1[i] = a[i];
for (int i = (0); i < (len); ++i) a2[i] = b[i];
for (int i = (0); i < (N); ++i) omega[i] = polar(1.0, 2 * PI / N * i);
fft(a1, z1, N);
fft(a2, z2, N);
for (int i = (0); i < (N); ++i) omega[i] = complex<double>(1, 0) / omega[i];
for (int i = (0); i < (N); ++i) a1[i] = z1[i] * z2[i] / complex<double>(N, 0);
fft(a1, z1, N);
for (int i = (0); i < (2 * len); ++i) c[i] = round(z1[i].real());
}
void mult_mod(long long *a, long long *b, long long *c, int len, int mod) {
static long long a0[MAX], a1[MAX];
static long long b0[MAX], b1[MAX];
static long long c0[MAX], c1[MAX], c2[MAX];
for (int i = (0); i < (len); ++i) a0[i] = a[i] & 0xFFFF;
for (int i = (0); i < (len); ++i) a1[i] = a[i] >> 16;
for (int i = (0); i < (len); ++i) b0[i] = b[i] & 0xFFFF;
for (int i = (0); i < (len); ++i) b1[i] = b[i] >> 16;
FFT::mult(a0, b0, c0, len);
FFT::mult(a1, b1, c2, len);
for (int i = (0); i < (len); ++i) a0[i] += a1[i];
for (int i = (0); i < (len); ++i) b0[i] += b1[i];
FFT::mult(a0, b0, c1, len);
for (int i = (0); i < (2 * len); ++i) c1[i] -= c0[i] + c2[i];
for (int i = (0); i < (2 * len); ++i) c1[i] %= mod;
for (int i = (0); i < (2 * len); ++i) c2[i] %= mod;
for (int i = (0); i < (2 * len); ++i)
c[i] = (c0[i] + (c1[i] << 16) + (c2[i] << 32)) % mod;
}
} // namespace FFT
long long p[50][3000], temp[3000];
void compute() {
int i, j;
p[1][0] = 1;
for (i = 2; i <= 35; i++) {
FFT ::mult_mod(p[i - 1], p[i - 1], temp, 1002, mod);
FFT ::mult_mod(temp, temp, temp, 1002, mod);
for (j = 1000; j; j--) p[i][j] = temp[j - 1];
p[i][0] = 1;
}
}
int main() {
ios_base::sync_with_stdio(false);
;
cin.tie(0);
int t, nn, k, n;
cin >> t;
compute();
while (t--) {
cin >> nn >> k;
n = 0;
while (nn & 1) {
n = n * 2 + 1;
nn = nn / 2;
}
if (nn) n = n * 2 + 1;
assert(((n + 1) & n) == 0);
n = log(n + 1) / log(2) + 0.5;
cout << p[n][k] << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
const long long mod = 1e9 + 7;
long long a[1005][1005];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cin >> a[i][j];
}
vector<int> V;
long long now = a[2][1] * a[3][1] / a[3][2];
now = sqrt(now);
V.push_back(now);
for (int i = 2; i <= n; i++) {
V.push_back(a[i][1] / V[0]);
}
for (auto &x : V) {
cout << x << ' ';
}
cout << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char ele[4] = {'A', 'C', 'G', 'T'};
int id[6][4] = {{0, 1, 2, 3}, {0, 2, 1, 3}, {0, 3, 1, 2},
{1, 2, 0, 3}, {1, 3, 0, 2}, {2, 3, 0, 1}};
int n, m;
int solve1(vector<vector<char> > &A, vector<vector<char> > &ans) {
int res = n * m + 1;
for (int ti = 0; ti < 6; ti++) {
vector<vector<char> > B = A;
int cnt = 0;
for (int i = 0; i < n; i++) {
int tmp[2] = {0};
for (int j = 0; j < m; j++)
for (int k = 0; k < 2; k++) {
tmp[k] += (A[i][j] != ele[id[ti][2 * (i & 1) + ((j & 1) ^ k)]]);
}
int select = tmp[0] < tmp[1] ? 0 : 1;
cnt += tmp[select];
for (int j = 0; j < m; j++)
B[i][j] = ele[id[ti][2 * (i & 1) + ((j & 1) ^ select)]];
}
if (cnt < res) {
res = cnt;
ans = B;
}
}
return res;
}
int solve2(vector<vector<char> > &A, vector<vector<char> > &ans) {
int res = n * m + 1;
for (int ti = 0; ti < 6; ti++) {
vector<vector<char> > B = A;
int cnt = 0;
for (int i = 0; i < m; i++) {
int tmp[2] = {0};
for (int j = 0; j < n; j++)
for (int k = 0; k < 2; k++) {
tmp[k] += (A[j][i] != ele[id[ti][2 * (i & 1) + ((j & 1) ^ k)]]);
}
int select = tmp[0] < tmp[1] ? 0 : 1;
cnt += tmp[select];
for (int j = 0; j < n; j++)
B[j][i] = ele[id[ti][2 * (i & 1) + ((j & 1) ^ select)]];
}
if (cnt < res) {
res = cnt;
ans = B;
}
}
return res;
}
const int N = 3e5 + 10;
char s[N];
void print(vector<vector<char> > &A) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%c", A[i][j]);
puts("");
}
}
int main() {
scanf("%d%d", &n, &m);
vector<vector<char> > A(n, vector<char>(m));
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++) A[i][j] = s[j];
}
vector<vector<char> > ans1, ans2;
int res1 = solve1(A, ans1), res2 = solve2(A, ans2);
if (res1 < res2)
print(ans1);
else
print(ans2);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
for (int i = 0; i < (int)s.size(); i++) {
if (s[i] == '.')
cout << "0";
else {
if (s[i + 1] == '.')
cout << "1";
else
cout << "2";
i++;
}
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long base, long long exp) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base);
base = (base * base);
exp /= 2;
}
return res;
}
long long mod(long long a, long long b) { return (a % b + b) % b; }
long long powerm(long long base, long long exp, long long mod) {
long long ans = 1;
while (exp) {
if (exp & 1) ans = (ans * base) % mod;
exp >>= 1, base = (base * base) % mod;
}
return ans;
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t;
t = 1;
while (t--) {
string s;
cin >> s;
cout << s;
for (long long i = s.size() - 1; i >= 0; i--) cout << s[i];
cout << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, L[1010], BE[1010], T1[1010], T2[1010], chk[1010], Dep[1010], T3[1010],
par[1010], DEBUG = 0;
vector<int> TR[1010];
int Dist[1010][1010];
vector<int> G[1010];
char p[1010];
void Query(int *T) {
int i, j;
if (!DEBUG) {
printf("?");
for (i = 1; i <= n; i++) printf(" %d", min(L[i], n - 1));
puts("");
}
fflush(stdout);
if (!DEBUG) {
scanf("%s", p);
for (i = 1; i <= n; i++) {
T[i] = p[i - 1] - '0';
}
} else {
for (i = 1; i <= n; i++) {
T[i] = 0;
for (j = 1; j <= n; j++) {
if (L[j] && Dist[i][j] <= L[j]) T[i] = 1;
}
}
}
}
void Add(int a, int dep) {
Dep[a] = dep;
G[dep].push_back(a);
chk[a] = 1;
}
void DFS(int a, int pp, int d, int rt) {
Dist[rt][a] = d;
for (auto &x : TR[a]) {
if (x == pp) continue;
DFS(x, a, d + 1, rt);
}
}
int main() {
int i, j, k, l;
scanf("%d", &n);
if (DEBUG) {
srand(193);
for (i = 2; i <= n; i++) {
int a = rand() % (i - 1) + 1;
TR[a].push_back(i);
TR[i].push_back(a);
printf("%d %d\n", a, i);
}
for (i = 1; i <= n; i++) {
DFS(i, 0, 0, i);
}
}
for (i = 1; i <= n; i++) {
BE[i] = 0;
}
Add(1, 0);
for (i = 512; i >= 2; i >>= 1) {
for (j = 1; j <= n; j++) L[j] = 0;
for (j = 0; j <= 1000; j += i * 4) {
for (auto &t : G[j]) {
L[t] = i;
}
}
Query(T1);
for (j = 1; j <= n; j++) L[j] = 0;
for (j = 0; j <= 1000; j += i * 4) {
for (auto &t : G[j]) {
L[t] = i - 1;
}
}
Query(T2);
for (j = 1; j <= n; j++) {
if (!chk[j] && BE[j] % (4 * i) == 0) {
if (T1[j] != T2[j]) {
Add(j, BE[j] + i);
}
}
}
for (j = 1; j <= n; j++) {
if (!chk[j] && BE[j] % (4 * i) == 0) {
if (!T1[j]) {
BE[j] += i;
}
}
}
for (j = 1; j <= n; j++) L[j] = 0;
for (j = 2 * i; j <= 1000; j += i * 4) {
for (auto &t : G[j]) {
L[t] = i;
}
}
Query(T1);
for (j = 1; j <= n; j++) L[j] = 0;
for (j = 2 * i; j <= 1000; j += i * 4) {
for (auto &t : G[j]) {
L[t] = i - 1;
}
}
Query(T2);
for (j = 1; j <= n; j++) {
if (!chk[j] && BE[j] % (4 * i) == 2 * i) {
if (T1[j] != T2[j]) {
Add(j, BE[j] + i);
}
}
}
for (j = 1; j <= n; j++) {
if (!chk[j] && BE[j] % (4 * i) == 2 * i) {
if (!T1[j]) {
BE[j] += i;
}
}
}
}
for (i = 1; i <= n; i++) {
if (!chk[i]) {
Add(i, BE[i] + 1);
}
}
for (i = 0; i < 3; i++) {
for (j = 0; j < 10; j++) {
for (k = 1; k <= n; k++) L[k] = 0;
for (k = i; k <= n; k += 3) {
for (l = 0; l < G[k].size(); l++) {
if ((l >> j) & 1) L[G[k][l]] = 1;
}
}
Query(T1);
for (k = i + 1; k <= n; k += 3) {
for (auto &x : G[k]) {
if (T1[x]) {
par[x] += (1 << j);
}
}
}
}
}
printf("!\n");
for (i = 2; i <= n; i++) {
printf("%d %d\n", G[Dep[i] - 1][par[i]], i);
}
fflush(stdout);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> a[3001];
int can[3001];
int res[3001];
int main() {
scanf("%d", &n);
for (int i = 0; i < (int)(n); ++i) scanf("%d", &a[i].first), a[i].second = i;
sort(a, a + n, greater<pair<int, int> >());
a[n] = make_pair(0, -1);
int mx = 0;
for (int i = 1; i <= n; ++i) {
int need = (i + 1) / 2 * 2 + i;
if (need > n) {
break;
}
mx = max(mx, a[i - 1].first - a[i].first);
}
can[0] = -1;
for (int i = 1; i <= n; ++i) {
int need = (i + 1) / 2 * 2 + i;
if (need > n) {
for (int j = i; j <= n; ++j) {
can[j] = can[j - 1];
}
break;
}
can[i] = can[i - 1];
if (a[i - 1].first - a[i].first == mx) {
can[i] = i;
}
}
pair<int, int> best = make_pair(-1, -1);
int bestI = -1;
int bestJ = -1;
int bestK = -1;
for (int j = 2; j <= n; ++j) {
for (int k = 1; j + k <= n; ++k) {
int mn = 1;
mn = max(mn, (k + 1) / 2);
mn = max(mn, (j + 2) / 3);
mn = max(mn, j - 2 * k);
int mx = n;
mx = min(mx, 2 * j / 3);
mx = min(mx, j - (k + 1) / 2);
mx = min(mx, 2 * k);
if (mx > 0 && can[mx] >= mn) {
pair<int, int> cur = make_pair(a[j - 1].first - a[j].first,
a[j + k - 1].first - a[j + k].first);
if (cur > best) {
best = cur;
bestI = can[mx];
bestJ = j;
bestK = j + k;
}
}
}
}
memset(res, -1, sizeof res);
for (int i = 0; i < bestI; ++i) {
res[a[i].second] = 1;
}
for (int i = bestI; i < bestJ; ++i) {
res[a[i].second] = 2;
}
for (int i = bestJ; i < bestK; ++i) {
res[a[i].second] = 3;
}
for (int i = 0; i < (int)(n); ++i) printf("%d ", res[i]);
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int i, j, n, s[maxn];
int main() {
scanf("%d", &n);
if (!(n & 1)) {
printf("NO\n");
return 0;
}
int l = 1, r = 2 * n;
bool turn = true;
for (i = 0, j = n; i < n; i++, j++) {
if (turn) {
s[i] = l++;
s[j] = l++;
} else {
s[i] = r--;
s[j] = r--;
}
turn = !turn;
}
printf("YES\n");
for (int i = 0; i < 2 * n; i++) printf("%d ", s[i]);
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class BIT {
private:
vector<long long> tree;
int n;
int LSOne(int x) { return x & (-x); }
public:
BIT(int x) {
n = x;
tree.resize(n + 1);
}
long long sum(int a) {
long long sum = 0;
for (; a > 0; a -= LSOne(a)) sum += tree[a];
return sum;
}
long long sum(int a, int b) { return sum(b) - (a == 1 ? 0 : sum(a - 1)); }
void update(int p, long long v) {
for (; p < n + 1; p += LSOne(p)) tree[p] += v;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<pair<int, long long>> q(n);
vector<long long> nums;
map<long long, int> uniq;
for (int i = 0; i < (int)n; i++) {
cin >> q[i].first >> q[i].second;
long long k = q[i].second;
if (uniq.count(k)) continue;
nums.push_back(k);
uniq[k] = 1;
}
sort(nums.begin(), nums.end());
for (int i = 0; i < (int)nums.size(); i++) uniq[nums[i]] = i + 1;
BIT sumTree(nums.size()), ctTree(nums.size());
set<long long> minDouble;
int tot = 0;
for (int i = 0; i < (int)n; i++) {
bool add = q[i].second > 0;
if (add)
tot += 1;
else {
q[i].second = -q[i].second;
tot -= 1;
}
if (q[i].first) {
if (add)
minDouble.insert(q[i].second);
else
minDouble.erase(q[i].second);
}
int idx = uniq[q[i].second];
ctTree.update(idx, (add ? 1 : -1));
sumTree.update(idx, (add ? q[i].second : -q[i].second));
int ididx = -1;
if (minDouble.size()) {
ididx = uniq[*minDouble.begin()];
ctTree.update(ididx, -1);
sumTree.update(ididx, -(*minDouble.begin()));
}
int d = minDouble.size();
if (d == tot) d -= 1;
int lo = 1, hi = nums.size() + 2, ans = nums.size() + 1;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (ctTree.sum(mid, nums.size()) >= d) {
lo = mid + 1;
ans = mid;
} else
hi = mid;
}
cout << sumTree.sum(nums.size()) + sumTree.sum(ans, nums.size()) +
(minDouble.size() ? *minDouble.begin() : 0)
<< '\n';
if (minDouble.size()) {
ctTree.update(ididx, 1);
sumTree.update(ididx, (*minDouble.begin()));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[6][1002];
int pos[6][1002];
int dp[1002];
int main() {
int i, j, ij;
cin >> n >> k;
for (i = 1; i <= k; i++)
for (j = 1; j <= n; j++) {
cin >> a[i][j];
pos[i][a[i][j]] = j;
}
int ans = 1;
dp[n] = 1;
for (i = n - 1; i >= 1; i--) {
dp[i] = 1;
for (j = i + 1; j <= n; j++) {
bool ok = true;
for (ij = 1; ij <= k; ij++)
if (pos[ij][a[1][i]] > pos[ij][a[1][j]]) {
ok = false;
break;
}
if (ok) dp[i] = max(dp[i], dp[j] + 1);
}
ans = max(ans, dp[i]);
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long modn = 1000000007;
inline long long mod(long long x) { return x % modn; }
template <class num>
inline void read(num &x) {
char c;
while (isspace(c = getchar()))
;
bool neg = false;
if (!isdigit(c))
neg = (c == '-'), x = 0;
else
x = c - '0';
while (isdigit(c = getchar())) x = (x << 3) + (x << 1) + c - '0';
if (neg) x = -x;
}
const int N = 3e3 + 7;
int n;
int x[2];
int v[N][3];
int p[N];
int memo[2][N][N];
vector<int> res[2];
bool cmp_t(int i, int j) {
return pair<int, int>(v[i][0], v[i][1]) > pair<int, int>(v[j][0], v[j][1]);
}
int pd(int k, int i, int g) {
if (k == 2) return 0;
if (g > x[k]) return -1e7;
if (i == n) return pd(k + 1, i, i - g);
if (g == x[k]) return pd(k + 1, i, i - g);
int &me = memo[k][i][g];
if (me != -1) return me;
me = max(pd(k, i + 1, g + 1) + v[p[i]][k], pd(k, i + 1, g) + v[p[i]][k + 1]);
return me;
}
void build(int k, int i, int g) {
if (i == n) return;
if (k == 2) return;
if (g > x[k]) assert(false);
if (g == x[k]) {
build(k + 1, i, i - g);
return;
}
int me = pd(k, i, g);
if (pd(k, i + 1, g + 1) + v[p[i]][k] == me) {
if (k < 2) res[k].push_back(p[i]);
build(k, i + 1, g + 1);
return;
} else {
if (k + 1 < 2) res[k + 1].push_back(p[i]);
build(k, i + 1, g);
return;
}
}
int main() {
memset(memo, -1, sizeof memo);
int i, j;
scanf("%d", &n);
scanf("%d %d", &x[0], &x[1]);
for (int i = 0; i < n; i++) {
scanf("%d", &v[i][0]);
v[i][2] = 0;
p[i] = i;
}
for (int i = 0; i < n; i++) scanf("%d", &v[i][1]);
sort(p, p + n, cmp_t);
printf("%d\n", pd(0, 0, 0));
build(0, 0, 0);
for (int k = 0; k < 2; k++) {
for (int i = 0; i < res[k].size(); i++) printf("%d ", res[k][i] + 1);
printf("\n");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int MOD(int a, int b) {
if (a > b)
return a - b;
else
return b - a;
}
long long int max3(long long int a, long long int b, long long int c) {
return max(c, max(a, b));
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int max(long long int a, long long int b) { return (a > b) ? a : b; }
long long int min(long long int a, long long int b) { return (a < b) ? a : b; }
long long int gcd(long long int a, long long int b) {
if (b == 1)
return 1;
else if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
int a[200005];
int b[200005];
int tree[1000000];
void build(int node, int start, int end) {
if (start == end) {
tree[node] = b[start];
} else {
int mid = (start + end) / 2;
build(2 * node, start, mid);
build(2 * node + 1, mid + 1, end);
tree[node] = tree[node * 2] + tree[node * 2 + 1];
}
}
int query(int node, int start, int end, int l, int r) {
if ((r < start) || (l > end))
return 0;
else if ((start >= l) && (end <= r)) {
return tree[node];
} else {
int mid = (start + end) / 2;
int p1 = query(2 * node, start, mid, l, r);
int p2 = query(2 * node + 1, mid + 1, end, l, r);
return p1 + p2;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, i, j, k;
long long int ans = 0;
cin >> n >> m;
cin.clear();
string a1, b1;
cin >> a1 >> b1;
if (n >= m) {
a1 = a1.substr(n - m, m);
} else {
for (i = 0; i < m - n; i++) {
a1 = "0" + a1;
}
}
for (i = 0; i < m; i++) {
a[i + 1] = a1[i] - 48;
b[i + 1] = b1[i] - 48;
}
build(1, 1, m);
for (i = 1; i < m + 1; i++) {
int x = query(1, 1, m, 1, i);
if (a[i] == 0) continue;
ans += x * power(2, m - i, 998244353);
ans %= 998244353;
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) f = ch == '-' ? -1 : 1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
const long long inf = 1e18 + 7;
int n;
int a[500010];
int minx;
vector<int> e[500010];
long long fa[500010][20];
long long ans;
void dfs(int x, int fath) {
fa[x][0] = fath;
for (int j = 0; j < 20; ++j) {
if (fa[x][j - 1] != -1) {
fa[x][j] = fa[fa[x][j - 1]][j - 1];
}
}
int j;
long long minn = inf;
for (j = 0; j < 20 && fa[x][j] != -1; ++j) {
minn = min(minn, (long long)(j + 1) * a[fa[x][j]] + a[x]);
}
minn = min(minn, (long long)(j + 1) * a[minx] + a[x]);
if (fath != -1) ans += minn;
for (int u : e[x]) {
if (u != fath) dfs(u, x);
}
}
int main() {
memset(fa, -1, sizeof fa);
n = read();
a[minx] = 1e9 + 7;
for (int i = 1; i <= n; ++i) {
a[i] = read();
if (a[minx] > a[i]) {
minx = i;
}
}
for (int i = 1, x, y; i < n; ++i) {
x = read();
y = read();
e[x].push_back(y);
e[y].push_back(x);
}
dfs(minx, -1);
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int a[t];
for (int i = 0; i < t; ++i) {
cin >> a[i];
if (a[i] % 2 == 0)
cout << a[i] - 1 << " ";
else
cout << a[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
bool Is_tp(string t, int k);
string Trans_t(string t, int tp);
string rv(string s);
int main() {
ll t;
cin >> t;
for (ll i = 0; i < t; i++) {
string s, t;
cin >> s >> t;
bool find = 0;
for (int j = 0; j < t.size(); j++) {
if (Is_tp(t, j)) {
int f = s.find(Trans_t(t, j));
if (f != -1) {
cout << "YES" << endl;
find = 1;
break;
}
}
}
if (!find) {
cout << "NO" << endl;
}
}
return 0;
}
bool Is_tp(string t, int k) {
if (k == 0 || k == t.size() - 1) {
return 1;
}
if (k < t.size() / 2) {
if (t.substr(0, k) == rv(t.substr(k + 1, k))) {
return 1;
} else {
return 0;
}
} else {
if (t.substr(k + 1, t.size() - k - 1) ==
rv(t.substr(2 * k + 1 - t.size(), t.size() - k - 1))) {
return 1;
} else {
return 0;
}
}
return 0;
}
string Trans_t(string t, int tp) {
string ans;
if (tp < t.size() / 2) {
ans = rv(t.substr(tp, t.size() - tp));
} else {
ans = t.substr(0, tp + 1);
}
return ans;
}
string rv(string s) {
string t = s;
for (int i = 0; i < s.size(); i++) {
t[i] = s[s.size() - i - 1];
}
return t;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const int Mod = 1000000007;
int n, m;
char s[60][60];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%s", s[i]);
m = strlen(s[i]);
}
int ans = INF;
for (int i = 0; i < m; ++i) {
int cnt = i;
for (int j = 2; j <= n; ++j) {
bool flag = false;
for (int k = 0; k < m; ++k) {
bool f = true;
for (int t = 0; t < m; ++t)
if (s[j][(k + t) % m] != s[1][(i + t) % m]) f = false;
if (f) {
flag = true;
cnt += k;
break;
}
}
if (!flag) {
puts("-1");
exit(0);
}
}
ans = min(ans, cnt);
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const int maxn = 2e5 + 7;
const int inf = 2e9 + 7;
const long long infl = 1e18 + 7;
const long double eps = 1e-9;
const long long mod = 1e9 + 7;
int n, Mx = -1, a[maxn];
vector<int> adj[maxn], D[maxn];
map<int, int> m[maxn];
int gcd(int a, int b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
void dfs(int v, int p) {
for (int u : adj[v]) {
if (u != p) dfs(u, v);
}
if (a[v] == 1) return;
Mx = max(Mx, 0);
for (int d : D[a[v]]) {
m[v][d] = 0;
}
for (int u : adj[v]) {
if (u != p) {
for (auto i : m[u]) {
int g = gcd(i.first, a[v]);
for (int d : D[g]) {
Mx = max(Mx, m[v][d] + i.second + 1);
}
}
for (auto i : m[u]) {
int g = gcd(i.first, a[v]);
for (int d : D[g]) {
m[v][d] = max(m[v][d], i.second + 1);
}
}
m[u].clear();
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 2; i < maxn; i++) {
if (!D[i].size()) {
for (int j = i; j < maxn; j += i) {
D[j].push_back(i);
}
}
}
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1, v, u; i < n; i++) {
cin >> v >> u;
adj[v].push_back(u);
adj[u].push_back(v);
}
dfs(1, 0);
cout << Mx + 1;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
const long long MOD = 1e9 + 7;
const double err = 1e-10;
const int N = 5e3 + 5;
int n, m;
vector<vector<int>> adj(N);
vector<bool> vis(N, 0);
vector<int> tsort;
void topsort(int u) {
vis[u] = 1;
for (auto v : adj[u]) {
if (!vis[v]) {
topsort(v);
}
}
tsort.push_back(u);
}
void solve() {
cin >> n >> m;
vector<pair<int, int>> edges;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
edges.push_back({u, v});
}
bool f = 0;
for (int i = 1; i < n + 1; i++) {
if (!vis[i]) {
topsort(i);
}
}
reverse((tsort).begin(), (tsort).end());
vector<int> pos(N);
for (int i = 0; i < n; i++) {
pos[tsort[i]] = i;
}
int mx = 0;
vector<int> col(m);
for (int i = 0; i < m; i++) {
if (pos[edges[i].first] < pos[edges[i].second]) {
col[i] = 1;
} else {
col[i] = 2;
}
mx = max(mx, col[i]);
}
cout << mx << endl;
for (auto i : col) cout << i << ' ';
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int p[100005];
int sz[100005];
bool com(pair<int, pair<int, int> > a, pair<int, pair<int, int> > b) {
return a.first < b.first;
}
int findd(int u) {
if (u == p[u]) return u;
return p[u] = findd(p[u]);
}
vector<pair<int, pair<int, int> > > op;
int main() {
int n, m, k, i, j;
cin >> n >> m >> k;
for (i = 0; i < k; i++) {
int x;
cin >> x;
sz[x] = 1;
}
for (i = 0; i <= n; i++) p[i] = i;
for (i = 0; i < m; i++) {
int x, y, z;
cin >> x >> y >> z;
op.push_back(make_pair(z, make_pair(x, y)));
}
sort(op.begin(), op.end(), com);
for (i = 0; i < op.size(); i++) {
int x = findd(op[i].second.first);
int y = findd(op[i].second.second);
if (x != y) {
p[y] = x;
sz[x] += sz[y];
if (sz[x] >= k) {
for (j = 0; j < k; j++) cout << op[i].first << " ";
return 0;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<string, int> mp;
int n, m;
cin >> n >> m;
int same = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
mp[s] = 1;
}
for (int i = 0; i < m; i++) {
string s;
cin >> s;
if (mp[s]) same++;
}
n = n - same;
m = m - same;
if (same % 2 == 1)
n >= m ? cout << "YES" : cout << "NO";
else
n > m ? cout << "YES" : cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<string, string> mp;
void mapping(string a, string b) {
for (map<string, string>::iterator i = mp.begin(); i != mp.end(); i++) {
if (i->second == a) {
a = i->first;
mapping(a, b);
}
}
mp[a] = b;
}
int main() {
map<string, string> mapo;
vector<pair<string, string>> vec;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string a, b;
cin >> a >> b;
mapping(a, b);
}
cout << mp.size() << endl;
for (map<string, string>::iterator i = mp.begin(); i != mp.end(); i++) {
cout << i->first << " " << i->second << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int main() {
cin >> n;
int ans = 0;
for (long long i = 1; 1; ++i) {
long long tmp = i * (3 * i + 1) / 2;
if (tmp > n) break;
if ((n - tmp) % 3 == 0) ++ans;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
void pre() {}
void solve() {}
struct UF {
vector<int> e;
UF(int n) : e(n, -1) {}
bool same_set(int a, int b) { return find(a) == find(b); }
int size(int x) { return -e[find(x)]; }
int find(int x) { return e[x] < 0 ? x : e[x] = find(e[x]); }
void join(int a, int b) {
a = find(a), b = find(b);
if (a == b) return;
if (e[a] > e[b]) swap(a, b);
e[a] += e[b];
e[b] = a;
}
};
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
long long n, k;
cin >> n >> k;
long long arr[n];
for (int i = 0; i < (n); ++i) cin >> arr[i];
vector<long long> temp;
long long i = 0;
long long ans = 0;
while (i < n) {
temp.push_back(arr[i]);
sort(temp.begin(), temp.end());
int a = 0;
for (int i = temp.size() - 1; i >= 0; i -= 2) {
a += temp[i];
if (a > k) {
cout << ans;
return 0;
}
}
ans++;
i++;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double s1, s2, s3, a, b, c;
cin >> s1 >> s2 >> s3;
a = sqrt((s1 * s3) / s2);
b = sqrt((s1 * s2) / s3);
c = sqrt((s2 * s3) / s1);
cout << 4 * (a + b + c) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
for (; b; a %= b, swap(a, b))
;
return a;
}
int n;
int e[200001];
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) cin >> e[i];
sort(e, e + n);
int ans = 0;
int curCnt = 0;
int curMax = 0;
for (int i = 0; i < n; i++) {
curMax = max(curMax, e[i]);
curCnt++;
if (curCnt >= curMax) {
ans++;
curCnt = 0;
curMax = 0;
}
}
cout << ans << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
struct LPSolver {
int m, n;
vector<int> B, N;
vector<vector<long double> > D;
LPSolver(const vector<vector<long double> > &A, const vector<long double> &b,
const vector<long double> &c)
: m(b.size()),
n(c.size()),
N(n + 1),
B(m),
D(m + 2, vector<long double>(n + 2)) {
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) D[i][j] = A[i][j];
for (int i = 0; i < m; i++) {
B[i] = n + i;
D[i][n] = -1;
D[i][n + 1] = b[i];
}
for (int j = 0; j < n; j++) {
N[j] = j;
D[m][j] = -c[j];
}
N[n] = -1;
D[m + 1][n] = 1;
}
void Pivot(int r, int s) {
for (int i = 0; i < m + 2; i++)
if (i != r)
for (int j = 0; j < n + 2; j++)
if (j != s) D[i][j] -= D[r][j] * D[i][s] / D[r][s];
for (int j = 0; j < n + 2; j++)
if (j != s) D[r][j] /= D[r][s];
for (int i = 0; i < m + 2; i++)
if (i != r) D[i][s] /= -D[r][s];
D[r][s] = 1.0 / D[r][s];
swap(B[r], N[s]);
}
bool Simplex(int phase) {
int x = phase == 1 ? m + 1 : m;
while (true) {
int s = -1;
for (int j = 0; j <= n; j++) {
if (phase == 2 && N[j] == -1) continue;
if (s == -1 || D[x][j] < D[x][s] || D[x][j] == D[x][s] && N[j] < N[s])
s = j;
}
if (D[x][s] > -EPS) return true;
int r = -1;
for (int i = 0; i < m; i++) {
if (D[i][s] < EPS) continue;
if (r == -1 || D[i][n + 1] / D[i][s] < D[r][n + 1] / D[r][s] ||
(D[i][n + 1] / D[i][s]) == (D[r][n + 1] / D[r][s]) && B[i] < B[r])
r = i;
}
if (r == -1) return false;
Pivot(r, s);
}
}
long double Solve(vector<long double> &x) {
int r = 0;
for (int i = 1; i < m; i++)
if (D[i][n + 1] < D[r][n + 1]) r = i;
if (D[r][n + 1] < -EPS) {
Pivot(r, n);
if (!Simplex(1) || D[m + 1][n + 1] < -EPS)
return numeric_limits<long double>::infinity();
for (int i = 0; i < m; i++)
if (B[i] == -1) {
int s = -1;
for (int j = 0; j <= n; j++)
if (s == -1 || D[i][j] < D[i][s] ||
D[i][j] == D[i][s] && N[j] < N[s])
s = j;
Pivot(i, s);
}
}
if (!Simplex(2)) return numeric_limits<long double>::infinity();
x = vector<long double>(n);
for (int i = 0; i < m; i++)
if (B[i] < n) x[B[i]] = D[i][n + 1];
return D[m][n + 1];
}
};
int N, D, adj[510][510], wei[510][510], deg[510];
int A[510][510], b[510], c[510];
void dfs(int *A, int u, int p, int d) {
if (d < 0) return;
A[u]--;
for (int i = 0; i < deg[u]; i++) {
int v = adj[u][i];
if (v == p) continue;
dfs(A, v, u, d - wei[u][v]);
}
}
int main() {
int sum = 0;
scanf("%d%d", &N, &D);
for (int i = 0; i < N; i++) {
int type;
scanf("%d", &type);
c[i] = type - 1;
sum += type;
}
for (int i = 1; i < N; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
u--, v--;
adj[u][deg[u]++] = v;
adj[v][deg[v]++] = u;
wei[u][v] = wei[v][u] = w;
}
for (int i = 0; i < N; i++) {
dfs(A[i], i, -1, D);
b[i] = -1;
}
for (int i = 0; i < N; i++) A[N][i] = 1;
b[N] = sum;
vector<vector<long double> > _A(N + 1);
vector<long double> _B(b, b + N + 1);
vector<long double> _C(c, c + N);
for (int i = 0; i <= N; i++) _A[i] = vector<long double>(A[i], A[i] + N);
LPSolver solver(_A, _B, _C);
vector<long double> x;
long double ans = solver.Solve(x);
if (ans == numeric_limits<long double>::infinity())
puts("-1");
else
printf("%d\n", (int)(-ans + 0.5));
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long c;
long long s[10005], p[10005];
long long dp[2][10005];
int main() {
long long ans = 1e18;
int i, j;
scanf("%d%lld", &n, &c);
for (i = 1; i <= n; i++) {
scanf("%lld", &p[i]);
}
for (i = 1; i <= n; i++) {
scanf("%lld", &s[i]);
}
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
int x = i % 2, y = 1 - x;
memset(dp[x], 0x7f, sizeof(dp[x]));
for (j = 0; j <= i; j++) {
if (j != 0) {
dp[x][j] = min(dp[x][j], dp[y][j - 1] + s[i]);
}
if (j != i) {
dp[x][j] = min(dp[x][j], dp[y][j] + p[i] + j * c);
}
}
}
for (i = 0; i <= n; i++) {
ans = min(ans, dp[n % 2][i]);
}
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
int a[m], i, j, sum = 0, temp;
if (m == 1) {
printf("%d\n", n);
return 0;
}
for (i = 0; i < m; i++) a[i] = n / (m + 1);
temp = i;
while (sum == 0) {
for (i = i - 1; i >= 0; i--) {
a[i]++;
for (j = 0; j < m; j++) sum = sum + a[j];
if (sum == n) break;
sum = 0;
}
i = temp;
}
for (j = 0; j < m; j++) printf("%d ", a[j]);
printf("\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int cost(long long int x[], long long int a, long long int n,
long long int r, long long int m, long long int val) {
long long int pos = 0;
long long int neg = 0;
for (int i = 0; i < n; i++) {
if (x[i] > val)
pos += x[i] - val;
else
neg += val - x[i];
}
if (a + r < m)
return a * neg + r * pos;
else {
if (pos > neg)
return neg * m + (pos - neg) * r;
else
return pos * m + (neg - pos) * a;
}
}
long long int binary(long long int x[], long long int a, long long int n,
long long int r, long long int m, long long int min,
long long int max) {
if (min > max)
return -1;
else {
long long int mid = (min + max) / 2;
long long int q = cost(x, a, n, r, m, mid);
long long int w = cost(x, a, n, r, m, mid - 1);
long long int e = cost(x, a, n, r, m, mid + 1);
if (q <= w && q <= e) {
return q;
} else if (w > q && q > e)
return binary(x, a, n, r, m, mid + 1, max);
else
return binary(x, a, n, r, m, min, mid - 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, a, r, m;
cin >> n >> a >> r >> m;
long long int *x = new long long int[n];
long long int min = 100000001;
long long int max = 0;
for (int i = 0; i < n; i++) {
cin >> x[i];
if (x[i] > max) max = x[i];
if (x[i] < min) min = x[i];
}
long long int sum = binary(x, a, n, r, m, min, max);
cout << sum << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e3 + 10;
const int INF = 0x3f3f3f3f;
int n, a[MAXN];
int f[MAXN][3];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int j = (n + 1) / 2; j >= 0; --j)
for (int i = 0; i <= 2; ++i) f[j][i] = INF;
f[0][0] = f[1][1] = 0;
for (int i = 2; i <= n; ++i)
for (int j = (i + 1) / 2; j >= 1; --j) {
f[j][0] = min(f[j][0], f[j][2]);
f[j][2] = f[j][1] + max(0, a[i] - a[i - 1] + 1);
f[j][1] =
min(f[j - 1][0] + max(0, a[i - 1] - a[i] + 1),
f[j - 1][2] + max(0, min(a[i - 1], a[i - 2] - 1) - a[i] + 1));
}
for (int j = 1; j <= (n + 1) / 2; ++j)
cout << min(f[j][0], min(f[j][1], f[j][2])) << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct fenvick {
vector<bool> got;
vector<long long> fen;
fenvick() {}
fenvick(int n) {
fen.resize(n);
got.resize(n);
}
void upd(int pos) {
if (got[pos] == true) {
return;
}
got[pos] = true;
while (pos < fen.size()) {
fen[pos]++;
pos |= (pos + 1);
}
}
long long getPref(int pos) {
if (pos < 0) {
return 0;
}
long long res = 0;
while (pos >= 0) {
res += fen[pos];
pos &= (pos + 1);
pos--;
}
return res;
}
long long getSum(int l, int r) { return getPref(r) - getPref(l - 1); }
};
bool comp(pair<long long, long long>& a, pair<long long, long long>& b) {
if (a.second == b.second) {
return a.first < b.first;
} else {
return a.second > b.second;
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, cur = 0, ans = 0;
cin >> n;
vector<pair<long long, long long>> arr(n);
vector<bool> used;
map<long long, int> cnt, indX;
for (int i = 0; i < n; i++) {
cin >> arr[i].first >> arr[i].second;
cnt[arr[i].first]++;
}
sort(arr.begin(), arr.end(), comp);
used.resize(n);
for (auto to : cnt) {
indX[to.first] = cur;
cur++;
}
fenvick sosi(cnt.size());
for (int i = 0; i < n; i++) {
int pos = indX[arr[i].first];
int tmpI = i;
while (tmpI < n) {
if (used[tmpI]) {
break;
}
if (arr[tmpI].second == arr[i].second) {
used[tmpI] = true;
sosi.upd(indX[arr[tmpI].first]);
tmpI++;
} else {
break;
}
}
long long l0 = 0, r0 = cnt.size() - 1;
if (i > 0) {
if (arr[i - 1].second == arr[i].second) {
l0 = indX[arr[i - 1].first] + 1;
}
}
ans += sosi.getSum(l0, pos) * sosi.getSum(pos, r0);
}
cout << ans << '\n';
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
int run_test(){
int n;
cin >> n;
vector<ll> v(n);
for(int i = 0; i < n; i++){
cin >> v[i];
}
sort(v.begin(), v.end());
ll dp[n + 1][n + 1];
for(int i = 0; i < n; i++){
dp[i][i] = 0;
}
for(int i = n - 1; i >= 0; i--){
for(int j = i + 1; j < n; j++){
dp[i][j] = v[j] - v[i];
if(i < n - 1 && j == 0){
dp[i][j] += dp[i + 1][j];
}
else if(i == n - 1 && j > 0){
dp[i][j] += dp[i][j - 1];
}
else{
dp[i][j] += min(dp[i+1][j], dp[i][j-1]);
}
}
}
cout << dp[0][n - 1] << '\n';
return 0;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int tt;
tt = 1;
while(tt--){
run_test();
}
} | 5 |
#include <bits/stdc++.h>
int main() {
using namespace std;
int d[100], a, b, n, i, years = 0, y;
cin >> n;
for (i = 0; i < n - 1; i++) cin >> d[i];
cin >> a >> b;
y = b - a;
while (y--) {
years += d[a - 1];
a++;
}
cout << years;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp, vis, mark, ans;
int deep, last;
vector<int> vec;
int n, a, b;
int arr[100010];
void dfs(int u) {
vis[u] = ++deep;
last = u;
vec.push_back(u);
int x = a - u;
if (mp.count(x) && !vis.count(x)) dfs(x);
x = b - u;
if (mp.count(x) && !vis.count(x)) dfs(x);
}
void dfs(int u, int f, int uu) {
mark[u] = 1;
int x = a - u;
if (mp.count(x) && !mark.count(x) && x - uu) {
if (!f) ans[u] = 0, ans[x] = 0;
dfs(x, f ^ 1, u);
}
x = b - u;
if (mp.count(x) && !mark.count(x) && x - uu) {
if (!f) ans[u] = ans[x] = 1;
dfs(x, f ^ 1, u);
}
}
int main() {
cin >> n >> a >> b;
for (int i = 1; i <= n; ++i) {
scanf("%d", arr + i);
mp[arr[i]] = 1;
}
for (int i = 1; i <= n; ++i) {
if (!vis.count(arr[i])) {
last = 0;
deep = 0;
vec.clear();
dfs(arr[i]);
if (deep % 2 == 0) {
dfs(last, 0, 0);
} else {
int can = 0;
for (int i = 0; i < vec.size(); ++i) {
int u = vec[i];
if (u + u == a) {
ans[u] = 0;
int x = b - u;
mark[u] = 1;
if (mp.count(x) && x != u) {
dfs(x, 0, 0);
}
can = 1;
break;
}
if (u + u == b) {
ans[u] = 1;
int x = a - u;
mark[u] = 1;
if (mp.count(x) && x != u) {
dfs(x, 0, 0);
}
can = 1;
break;
}
}
if (!can) {
puts("NO");
return 0;
}
}
}
}
puts("YES");
for (int i = 1; i <= n; ++i) printf("%d ", ans[arr[i]]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int id;
long long c[100005];
bool cap[100005];
long long ans = 0;
long long sum = 0;
memset(cap, 0, sizeof(cap));
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%I64d", &c[i]);
sum += c[i];
}
c[0] = c[n];
while (k--) {
scanf("%d", &id);
cap[id] = true;
sum -= c[id];
ans += c[id] * sum;
}
cap[0] = cap[n];
for (int i = 1; i <= n; ++i) {
if (cap[i]) continue;
if (!cap[i - 1]) ans += c[i] * c[i - 1];
}
printf("%I64d", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
int ans = (n % 2) ? 1 : 2;
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int t[35];
bool dp[330][330][10], prev_[330][330][10], visited[330][330];
int dir[8][2] = {{-1, 0}, {-1, 1}, {0, 1}, {1, 1},
{1, 0}, {1, -1}, {0, -1}, {-1, -1}};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> t[i];
prev_[160 - t[1] + 1][160][0] = true;
for (int i = 0; i < t[1]; i++) {
visited[160 - i][160] = true;
}
for (int l = 2; l <= n; l++) {
for (int i = 0; i <= 320; i++) {
for (int j = 0; j <= 320; j++) {
for (int d = 0; d < 8; d++) {
if (prev_[i][j][d]) {
int d1 = (d + 1) % 8;
int d2 = (d + 7) % 8;
for (int k = 0; k <= t[l]; k++) {
if (i + k * dir[d1][0] >= 0 && i + k * dir[d1][0] <= 320 &&
j + k * dir[d1][1] >= 0 && j + k * dir[d1][1] <= 320)
visited[i + k * dir[d1][0]][j + k * dir[d1][1]] = true;
if (i + k * dir[d2][0] >= 0 && i + k * dir[d2][0] <= 320 &&
j + k * dir[d2][1] >= 0 && j + k * dir[d2][1] <= 320)
visited[i + k * dir[d2][0]][j + k * dir[d2][1]] = true;
}
if (i + t[l] * dir[d1][0] >= 0 && i + t[l] * dir[d1][0] <= 320 &&
j + t[l] * dir[d1][1] >= 0 && j + t[l] * dir[d1][1] <= 320)
dp[i + t[l] * dir[d1][0]][j + t[l] * dir[d1][1]][d1] = true;
if (i + t[l] * dir[d2][0] >= 0 && i + t[l] * dir[d2][0] <= 320 &&
j + t[l] * dir[d2][1] >= 0 && j + t[l] * dir[d2][1] <= 320)
dp[i + t[l] * dir[d2][0]][j + t[l] * dir[d2][1]][d2] = true;
}
}
}
}
for (int i = 0; i <= 320; i++) {
for (int j = 0; j <= 320; j++) {
for (int d = 0; d < 8; d++) {
prev_[i][j][d] = dp[i][j][d];
dp[i][j][d] = false;
}
}
}
}
int ans = 0;
for (int i = 0; i <= 320; i++) {
for (int j = 0; j <= 320; j++) {
if (visited[i][j]) {
ans++;
}
}
}
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int sol[10000000];
int appartiene[19][3] = {{0, 0, 2}, {0, 1, 3}, {0, 2, 4}, {1, 0, 1}, {1, 1, 2},
{1, 2, 3}, {1, 3, 4}, {2, 0, 0}, {2, 1, 1}, {2, 2, 2},
{2, 3, 3}, {2, 4, 4}, {3, 1, 0}, {3, 2, 1}, {3, 3, 2},
{3, 4, 3}, {4, 2, 0}, {4, 3, 1}, {4, 4, 2}};
int righe[5][5] = {{0, 1, 2, -1, -1},
{3, 4, 5, 6, -1},
{7, 8, 9, 10, 11},
{12, 13, 14, 15, -1},
{16, 17, 18, -1, -1}};
int sx[5][5] = {{0, 3, 7, -1, -1},
{1, 4, 8, 12, -1},
{2, 5, 9, 13, 16},
{6, 10, 14, 17, -1},
{11, 15, 18, -1, -1}};
int dx[5][5] = {{7, 12, 16, -1, -1},
{3, 8, 13, 17, -1},
{0, 4, 9, 14, 18},
{1, 5, 10, 15, -1},
{2, 6, 11, -1, -1}};
bool Presente(int bitmask, int num) {
if (num == -1) return false;
if ((bitmask & (1 << num)) == (1 << num))
return true;
else
return false;
}
int Prova(int chi, int bitmask) {
int winner = ((chi == 1) ? 2 : 1);
if (sol[bitmask] != 0) {
if (sol[bitmask] == 1)
return winner;
else
return chi;
}
if (bitmask == 0) return winner;
int appo = bitmask;
for (int i = 0; i < 19; i++) {
appo = bitmask;
if (Presente(appo, i)) {
if (Prova(winner, appo - (1 << i)) == chi) {
sol[bitmask] = 2;
return chi;
}
int riga = appartiene[i][0], s = appartiene[i][1], d = appartiene[i][2],
mappa = appo;
for (int j = 0; j < 5; j++) {
if (righe[riga][j] == -1) break;
mappa = appo;
int x = j;
while (Presente(mappa, righe[riga][x]) && x < 5) {
mappa -= (1 << righe[riga][x]);
if (Prova(winner, mappa) == chi) {
sol[bitmask] = 2;
return chi;
}
x++;
}
}
for (int j = 0; j < 5; j++) {
if (sx[d][j] == -1) break;
mappa = appo;
int x = j;
while (Presente(mappa, sx[s][x]) && x < 5) {
mappa -= (1 << sx[s][x]);
if (Prova(winner, mappa) == chi) {
sol[bitmask] = 2;
return chi;
}
x++;
}
}
for (int j = 0; j < 5; j++) {
if (dx[d][j] == -1) break;
mappa = appo;
int x = j;
while (Presente(mappa, dx[d][x]) && x < 5) {
mappa -= (1 << dx[d][x]);
if (Prova(winner, mappa) == chi) {
sol[bitmask] = 2;
return chi;
}
x++;
}
}
}
}
sol[bitmask] = 1;
return winner;
}
int main() {
ios::sync_with_stdio(false);
int bitmask = 0;
for (int i = 0; i < 19; i++) {
char tmp;
cin >> tmp;
if (tmp == 'O') bitmask |= (1 << i);
}
int win = Prova(1, bitmask);
if (win == 1)
cout << "Karlsson\n";
else
cout << "Lillebror\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<long long> v(n + 1), t(n + 1), su(n + 5), pre(n + 5), res(n + 5);
for (int i = 1; i <= n; ++i) {
cin >> v[i];
}
for (int i = 1; i <= n; ++i) {
cin >> t[i];
}
for (int i = 1; i <= n; ++i) {
su[i] = t[i] + su[i - 1];
}
for (int i = 1; i <= n; ++i) {
long long val = v[i] + su[i - 1];
int l = 0, r = n + 1, mid;
while (r > l + 1) {
mid = (l + r) / 2;
if (su[mid] <= val)
l = mid;
else
r = mid;
}
if (l == i - 1) {
res[i] += v[i];
} else {
pre[i] += 1, pre[l + 1] -= 1;
if (su[l] != val) res[l + 1] += val - su[l];
}
}
for (int i = 1; i <= n; ++i) {
pre[i] += pre[i - 1];
cout << pre[i] * t[i] + res[i] << ' ';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
vector<long long> a(s.size());
string ans;
long long n = s.size();
for (long long i = 0; i < n; i++) {
int c = (int)s[i];
a[i] = (long long)c - 48LL;
}
long long id1 = n + 1;
string s1 = s, s2 = s;
for (long long i = 0; i < a[n - 1]; i += 2) {
for (long long j = 0; j < n; j++) {
if (a[j] == i) {
id1 = min(id1, j);
break;
}
}
}
if (id1 != n + 1) {
swap(s1[id1], s1[n - 1]);
}
long long id2 = -1;
for (long long i = a[n - 1] + 1; i <= 8; i += 2) {
for (long long j = n - 1; j >= 0; j--) {
if (a[j] == i) {
id2 = max(id2, j);
break;
}
}
}
if (id2 != -1) {
swap(s2[id2], s2[n - 1]);
}
if (id2 == -1 && id1 == n + 1) {
cout << -1 << endl;
return;
} else {
if (s1 == s2) {
ans = s1;
} else if (s1 == s) {
ans = s2;
} else if (s2 == s) {
ans = s1;
} else {
for (long long i = 0; i < n; i++) {
if ((int)s1[i] > (int)s2[i]) {
ans = s1;
break;
} else if ((int)s1[i] < (int)s2[i]) {
ans = s2;
break;
}
}
}
long long i = 0;
while (i < n) {
if (a[i] == 0) {
i++;
} else {
break;
}
}
cout << ans.substr(i, n - i);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
{ solve(); }
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<int, int> poz;
struct node {
int idx;
char ch;
int parent;
vector<int> adj;
int level;
int dfs_enter;
int dfs_exit;
int cnt[26];
int mk[26];
void print() {
printf("{{{Node %d:\n", idx);
printf("char:%c parent:%d level:%d\n", ch, parent, level);
printf("DFSN: [%d, %d]\n kids: %d\n", dfs_enter, dfs_exit, adj.size());
printf("Cnt:\n");
for (int i = 0; i <= 25; i++) printf("%d", cnt[i]);
printf("\nMk:\n");
for (int i = 0; i <= 25; i++) printf("%d", mk[i]);
printf("\nEndnode}}}\n");
}
node() {
for (int i = 0; i <= 25; i++) cnt[i] = mk[i] = 0;
}
node(int E, int H) {
dfs_enter = E;
level = H;
}
const bool operator<(const node& a) const {
if (this->level == a.level) {
return this->dfs_enter < a.dfs_enter;
}
return this->level < a.level;
}
};
node a[500005];
int n, m;
char s[500005];
int T;
void DFS(int curr, int l) {
a[curr].level = l;
a[curr].dfs_enter = T++;
int sz = a[curr].adj.size();
for (int i = 0; i <= sz - 1; i++) {
int nxt = a[curr].adj[i];
DFS(nxt, l + 1);
}
a[curr].dfs_exit = T++;
}
int left(int v, int h) {
node q(a[poz[v]].dfs_enter, h);
node* it = lower_bound(a + 1, a + n + 1, q);
return it - a;
}
int right(int v, int h) {
node q(a[poz[v]].dfs_exit, h);
node* it = upper_bound(a + 1, a + n + 1, q);
--it;
return it - a;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 2; i <= n; i++) {
int v;
scanf("%d", &v);
a[i].parent = v;
a[v].adj.push_back(i);
}
scanf("%s", s);
for (int i = 0; i <= n - 1; i++) {
a[i + 1].idx = i + 1;
a[i + 1].ch = s[i];
}
T = 0;
DFS(1, 1);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
poz[a[i].idx] = i;
int idx = a[i].ch - 'a';
a[i].cnt[idx] = 1;
for (int j = 0; j <= 25; j++) {
a[i].mk[j] = a[i - 1].mk[j] + a[i].cnt[j];
}
}
for (int i = 1; i <= m; i++) {
int v, h;
scanf("%d %d", &v, &h);
int L = left(v, h);
int R = right(v, h);
if (L > R) {
printf("Yes\n");
continue;
}
int np = 0;
for (int j = 0; j <= 25; j++) {
int num = a[R].mk[j] - a[L - 1].mk[j];
if (num % 2 != 0) {
np++;
}
}
if (np <= 1) {
printf("Yes\n");
} else {
printf("No\n");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
long long shift[61];
long long p2[61];
int level(long long X) {
for (int i = 0; i < 60; ++i) {
if (X < p2[i + 1] && X >= p2[i]) return i;
}
return 60;
}
long long getorig(long long V, long long l) {
return p2[l] + ((V - p2[l] - shift[l]) % p2[l] + p2[l]) % p2[l];
}
void op1(long long X, long long K) {
int l = level(X);
K %= p2[l];
if (K < 0) K += p2[l];
shift[l] += K;
shift[l] %= p2[l];
}
void op2(long long X, long long K) {
int l = level(X);
K %= p2[l];
if (K < 0) K += p2[l];
for (int i = l; i < 60; ++i) {
shift[i] += K;
shift[i] %= p2[i];
K *= 2;
}
}
void op3(long long X, int l) {
long long P = X - p2[l];
long long V = (p2[l]) + ((P + shift[l]) % p2[l] + p2[l]) % p2[l];
for (int i = l; i >= 0; --i) {
long long Z = getorig(V, i);
printf("%I64d ", Z);
V /= 2;
}
printf("\n");
}
int main() {
p2[0] = 1;
for (int i = 1; i < 61; ++i) p2[i] = 2 * p2[i - 1];
int N;
scanf("%d \n", &N);
for (int i = 0; i < N; ++i) {
int T;
scanf("%d ", &T);
if (T != 3) {
long long K, X;
scanf("%I64d %I64d \n", &X, &K);
if (T == 1) op1(X, K);
if (T == 2) op2(X, K);
} else {
long long X;
scanf("%I64d \n", &X);
op3(X, level(X));
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v[120001], vn;
long long a, b, c[120001], n, m, i, z, k, l, lc, zn;
long long Check(long long d) {
if (d == v[z].size()) return -1;
long long i, del = v[z][d] - v[z][0];
for (i = 0; i < v[z].size(); i++) {
a = v[z][i];
b = v[z][(i + d) % v[z].size()];
if (a < b) swap(a, b);
if (min(a - b, n - (a - b)) != del) return -1;
}
return del;
}
long long gcd(long long a, long long b) {
if (a < b) swap(a, b);
while (b != 0) {
a %= b;
swap(a, b);
}
return a;
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> a >> b;
if (a < b) swap(a, b);
v[min(a - b, n - (a - b))].push_back(a);
v[min(a - b, n - (a - b))].push_back(b);
}
for (z = 1; z <= n; z++) {
if (v[z].size() == 0) continue;
sort(v[z].begin(), v[z].end());
vn.clear();
for (i = 0; i < v[z].size() - 1; i++)
if (v[z][i] != v[z][i + 1]) vn.push_back(v[z][i]);
vn.push_back(v[z][v[z].size() - 1]);
v[z] = vn;
}
for (z = 1; z <= n; z++) {
if (v[z].size() == 0) continue;
zn = 1000000000000000000LL;
for (i = 1; i * i <= v[z].size(); i++)
if (v[z].size() % i == 0) {
if (Check(i) != -1) zn = min(zn, Check(i));
if (Check(v[z].size() / i) != -1) zn = min(zn, Check(v[z].size() / i));
}
if (zn == 1000000000000000000LL) {
cout << "No" << '\n';
return 0;
}
k++;
c[k] = zn;
}
l = c[1];
for (i = 1; i <= k; i++) {
l = lcm(l, c[i]);
if (l >= n) break;
}
if (l < n)
cout << "Yes";
else
cout << "No";
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int main() {
cin >> n;
long long ans = 0;
for (long long i = 1;; i++) {
long long tmp = (i - 1) * i / 2 * 3 + i * 2;
if (tmp > n) break;
if ((n - 2 * i) % 3) continue;
ans++;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
string direc = "RDLU";
const long long MOD2 = (long long)998244353 * (long long)998244353;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
long long a[200135];
struct lsp {
long long a[60] = {0};
const int maxBit = 54;
bool insert(long long x) {
for (int i = maxBit; ~i; i--)
if (x & (1LL << i)) {
if (a[i] != 0)
x ^= a[i];
else {
for (int(j) = 0; (j) < (int)(i); (j)++)
if (x & (1LL << j)) x ^= a[j];
for (int j = i + 1; j <= maxBit; j++)
if (a[j] & (1LL << i)) a[j] ^= x;
a[i] = x;
return 1;
}
}
return 0;
}
} sp;
int p[66], Ans;
void calsm() {
vector<long long> bs;
for (int(j) = 0; (j) < (int)(sp.maxBit); (j)++)
if (sp.a[j]) bs.push_back(sp.a[j]);
assert(bs.size() == k);
for (int(i) = 0; (i) < (int)(1 << k); (i)++) {
long long ss = 0;
for (int(j) = 0; (j) < (int)(k); (j)++)
if (i & (1 << j)) ss ^= bs[j];
p[__builtin_popcountll(ss)]++;
}
for (int i = 0; i <= m; i++) {
printf("%lld ", (long long)p[i] * fastPow(2, n - k) % 998244353);
}
exit(0);
}
void calbg() {
vector<int> vp;
for (int(j) = 0; (j) < (int)(sp.maxBit); (j)++)
if (sp.a[j]) vp.push_back(j);
int N = m - k;
vector<vector<vector<int>>> dp(
k + 1, vector<vector<int>>(k + 1, vector<int>(1 << N, 0)));
dp[0][0][0] = 1;
for (int(i) = 1; (i) <= (int)(k); (i)++) {
int w = vp[i - 1], cc = 0;
int zz = 0;
for (int(j) = 0; (j) < (int)(sp.maxBit); (j)++)
if (!sp.a[j]) {
if (sp.a[w] & (1LL << j)) zz += 1 << cc;
cc++;
}
for (int j = 0; j < i; j++) {
for (int s = 0; s < (1 << N); s++) {
addmod(dp[i][j][s], dp[i - 1][j][s]);
addmod(dp[i][j + 1][s ^ zz], dp[i - 1][j][s]);
}
}
}
for (int j = 0; j <= k; j++) {
for (int s = 0; s < (1 << N); s++) {
addmod(p[j + __builtin_popcount(s)], dp[k][j][s]);
}
}
for (int i = 0; i <= m; i++) {
printf("%lld ", (long long)p[i] * fastPow(2, n - k) % 998244353);
}
exit(0);
}
void fmain(int tid) {
scanf("%d%d", &n, &m);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%lld", a + i);
for (int(i) = 1; (i) <= (int)(n); (i)++) k += sp.insert(a[i]);
if (k <= 20) calsm();
calbg();
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int x, h, m;
cin >> x >> h >> m;
if (h / 10 == 7 || h % 10 == 7 || m / 10 == 7 || m % 10 == 7) {
cout << 0;
return 0;
}
for (int i = 0;; ++i) {
m -= x;
if (m < 0) {
m = 59 + m + 1;
h--;
if (h < 0) h = 23;
}
if (h / 10 == 7 || h % 10 == 7 || m / 10 == 7 || m % 10 == 7) {
cout << i + 1;
return 0;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, n, x = 0, y = 0;
cin >> n;
bool k = true;
long long a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n - 1; i++) {
if (a[i] > a[i + 1]) {
x = i;
break;
}
}
for (i = n - 1; i > 0; i--) {
if (a[i - 1] > a[i]) {
y = i;
break;
}
}
for (i = x; i < y; i++) {
if (a[i] < a[i + 1]) {
k = false;
break;
}
}
if (k == false or (y + 1 < n and a[x] > a[y + 1]) or
(x - 1 >= 0 and a[y] < a[x - 1])) {
cout << "no";
} else {
cout << "yes" << endl << x + 1 << ' ' << y + 1;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long min(long long a, long long b) { return a > b ? b : a; }
long long max(long long a, long long b) { return a > b ? a : b; }
long long n, m;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
long long a[2] = {1, 1}, b[2] = {n, m};
for (int i = 0; i < n * m; i++) {
if (i % 2 == 0) {
cout << a[0] << " " << a[1] << "\n";
if (a[1] == m) {
a[0]++;
a[1] = 1;
} else {
a[1]++;
}
} else {
cout << b[0] << " " << b[1] << "\n";
if (b[1] == 1) {
b[1] = m;
b[0]--;
} else {
b[1]--;
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
const int N = 2e5 + 3;
int n, m;
int x[N], y[N], w[N], cnt[N];
bool vis[N], del[N];
vector<int> food[N], ans;
priority_queue<pii, vector<pii>, greater<pii> > pq;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> w[i];
}
for (int i = 1; i <= m; i++) {
cin >> x[i] >> y[i];
cnt[x[i]]++, cnt[y[i]]++;
food[x[i]].push_back(i);
food[y[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (cnt[i])
pq.emplace(max(0, cnt[i] - w[i]), i);
else
del[i] = true;
}
while (!pq.empty()) {
pii now = pq.top();
pq.pop();
if (now.first != max(0, cnt[now.second] - w[now.second])) continue;
if (now.first > 0) {
cout << "DEAD\n";
return 0;
}
vector<int> nx;
for (int it : food[now.second]) {
if (vis[it]) continue;
ans.push_back(it);
if (x[it] == now.second) swap(x[it], y[it]);
if (!del[x[it]]) nx.push_back(x[it]);
vis[it] = true;
}
sort(nx.begin(), nx.end());
for (int i = 0; i < nx.size(); i++) {
cnt[nx[i]]--;
if (i == nx.size() - 1 || nx[i] != nx[i + 1]) {
if (!max(0, cnt[nx[i]] - w[nx[i]])) del[nx[i]] = true;
pq.emplace(max(0, cnt[nx[i]] - w[nx[i]]), nx[i]);
}
}
}
cout << "ALIVE\n";
reverse(ans.begin(), ans.end());
for (int it : ans) cout << it << ' ';
cout << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100000 + 10;
vector<int> G[maxN], can, all[2];
queue<int> Q;
int n = 0, m = 0, a1, a2;
int vis[maxN], deg[maxN], __connect[maxN], color[maxN];
void ins(int a, int b) { G[a].push_back(b); }
void fillColor(int total) {
int __count = 0;
for (int i = 0; i < all[0].size(); i++) {
if (vis[all[0][i]]) continue;
__count++;
vis[all[0][i]] = total;
if (__count == 3) __count = 0, ++total;
}
for (int i = 0; i < all[1].size(); i++) {
if (vis[all[1][i]]) continue;
__count++;
vis[all[1][i]] = total;
if (__count == 3) __count = 0, ++total;
}
}
void print() {
for (int i = 1; i <= n; i++) printf("%d ", vis[i]);
puts("");
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &a1, &a2);
ins(a1, a2);
ins(a2, a1);
deg[a1]++, deg[a2]++;
}
memset(color, -1, sizeof color);
for (int s = 1; s <= n; s++)
if (color[s] == -1) {
while (!Q.empty()) Q.pop();
Q.push(s);
color[s] = 0;
all[0].push_back(s);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = 0; i < G[x].size(); i++)
if (color[G[x][i]] == -1) {
Q.push(G[x][i]);
color[G[x][i]] = (color[x] ^ 1);
all[color[G[x][i]]].push_back(G[x][i]);
}
}
}
if (all[0].size() % 3 == 0) {
puts("YES");
fillColor(1);
print();
} else {
if (all[0].size() % 3 == 2) swap(all[0], all[1]);
for (int i = 0; i < all[0].size(); i++)
if (all[1].size() - deg[all[0][i]] >= 2) {
puts("YES");
vis[all[0][i]] = 1;
memset(__connect, 0, sizeof __connect);
for (int j = 0; j < G[all[0][i]].size(); j++)
__connect[G[all[0][i]][j]] = 1;
int need = 2;
for (int j = 0; j < all[1].size(); j++)
if (!__connect[all[1][j]]) {
need--;
vis[all[1][j]] = 1;
if (need == 0) break;
}
fillColor(2);
print();
return 0;
}
for (int i = 0; i < all[1].size(); i++)
if (all[0].size() - deg[all[1][i]] >= 2) can.push_back(all[1][i]);
if (can.size() >= 2) {
puts("YES");
for (int i = 0; i < 2; i++) {
int tmp = can[i];
vis[tmp] = i + 1;
memset(__connect, 0, sizeof __connect);
for (int j = 0; j < G[tmp].size(); j++) __connect[G[tmp][j]] = 1;
int need = 2;
for (int j = 0; j < all[0].size(); j++)
if (!__connect[all[0][j]]) {
need--;
vis[all[0][j]] = i + 1;
if (need == 0) break;
}
}
fillColor(3);
print();
} else
puts("NO");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;
using ld = long double;
const int N = 1e6 + 228;
const int inf = 1e9 + 228;
int t[4 * N];
void push(int v, int len) {
t[v << 1] = min(t[v << 1], t[v]);
t[v << 1 | 1] = min(t[v << 1 | 1], t[v] + ((len + 1) >> 1));
}
void upd(int v, int l, int r, int l1, int r1, int x) {
if (r < l1 || r1 < l) {
return;
}
if (l1 <= l && r <= r1) {
t[v] = min(t[v], x);
return;
}
push(v, r - l + 1);
int m = (l + r) >> 1;
upd(v << 1, l, m, l1, r1, x);
upd(v << 1 | 1, m + 1, r, l1, r1, x + ((r - l + 1 + 1) >> 1));
}
int get(int v, int l, int r, int pos) {
if (l == r) {
return t[v];
}
push(v, r - l + 1);
int m = (l + r) >> 1;
if (pos <= m) {
return get(v << 1, l, m, pos);
}
return get(v << 1 | 1, m + 1, r, pos);
}
int n;
vector<pair<char, int>> g[N];
int in[N], out[N], timer;
int k;
int ins[N];
vi s;
vi qs;
int dp[N];
void dfs(int v) {
in[v] = timer++;
for (auto to : g[v]) {
dfs(to.second);
}
out[v] = timer++;
}
void solve(int v) {
if (ins[v] != -1) {
dp[v] = min(dp[v], get(1, 0, N - 1, ins[v]));
}
int lf = 0, rg = k - 1;
while (lf < rg) {
int md = (lf + rg) >> 1;
if (in[s[md]] >= in[v]) {
rg = md;
} else {
lf = md + 1;
}
}
int L = lf;
lf = 0, rg = k - 1;
while (lf < rg) {
int md = (lf + rg + 1) >> 1;
if (in[s[md]] < out[v]) {
lf = md;
} else {
rg = md - 1;
}
}
int R = lf;
if (L <= R && in[v] <= in[s[L]] && out[s[L]] <= out[v]) {
upd(1, 0, N - 1, L, R, dp[v] + 1 - L);
}
for (auto e : g[v]) {
int to = e.second;
dp[to] = dp[v] + 1;
solve(to);
}
}
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
int p;
char c;
cin >> p >> c;
g[p].push_back(make_pair(c, i));
}
for (int u = 0; u <= n; u++) {
sort((g[u]).begin(), (g[u]).end());
}
dfs(0);
cin >> k;
s.resize(k);
qs.resize(k);
for (int i = 0; i < k; i++) {
cin >> s[i];
qs[i] = s[i];
}
sort((s).begin(), (s).end(), [&](int u, int v) { return in[u] < in[v]; });
memset(ins, -1, sizeof(ins));
for (int i = 0; i < k; i++) {
ins[s[i]] = i;
}
for (int i = 0; i < 4 * N; i++) {
t[i] = inf;
}
solve(0);
for (int u : qs) {
cout << dp[u] << ' ';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int binpow(long long int a, long long int b) {
if (b == 0) return 1;
long long int res = binpow(a, b / 2);
if (b % 2)
return res * res * a;
else
return res * res;
}
long long int modexpo(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
vector<int> getPrimes() {
int M = 10000005;
vector<int> p(M, 1), prime;
for (int i = 2; i * i <= M; ++i) {
if (p[i]) {
for (int j = i * i; j <= M; j += i) p[i] = 0;
}
}
for (int i = 2; i < M; ++i)
if (p[i]) prime.push_back(i);
return prime;
}
bool cmp(pair<int, int> a, pair<int, int> b) {
return a.first > b.first && a.second < b.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
int x = 10000000;
for (int i = 0; i < n; ++i) a[i] = x--;
sort(a.begin(), a.end());
for (int i = 0; i < n; ++i) cout << a[i] << " ";
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, r[200];
vector<string> anslist;
bool check() {
for (int i = 2; i <= n; i++) {
if (r[i] != r[1]) return false;
}
return true;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> r[i];
while (!check()) {
string temp;
int h, s_h, hp, s_hp;
int minval = 300000, maxval = 0, mincnt = 0;
for (int i = 1; i <= n; i++) {
if (r[i] < minval) {
minval = r[i];
mincnt = 1;
} else if (r[i] == minval) {
mincnt++;
} else if (r[i] > maxval) {
maxval = r[i];
}
}
if (maxval - minval == 1 && mincnt == n - 3) {
for (int i = 1; i <= n; i++) {
if (r[i] == maxval) {
temp.push_back('1');
} else {
temp.push_back('0');
}
}
anslist.push_back(temp);
break;
}
if (r[1] > r[2]) {
h = r[1];
hp = 1;
s_h = r[2];
s_hp = 2;
} else {
h = r[2];
hp = 2;
s_h = r[1];
s_hp = 1;
}
for (int i = 3; i <= n; i++) {
if (r[i] > h) {
s_h = h;
s_hp = hp;
h = r[i];
hp = i;
} else if (r[i] > s_h) {
s_h = r[i];
s_hp = i;
}
}
r[hp] = max(r[hp] - 1, 0);
r[s_hp] = max(r[s_hp] - 1, 0);
for (int i = 1; i <= n; i++) {
if (i == hp || i == s_hp)
temp.push_back('1');
else
temp.push_back('0');
}
anslist.push_back(temp);
}
cout << r[1] << endl;
cout << anslist.size() << endl;
for (unsigned int i = 0; i < anslist.size(); i++) {
cout << anslist[i] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6;
int close[4 * maxn], open[4 * maxn], cnt[4 * maxn], n, q;
vector<int> seg;
string str;
void up(int idx) {
int L = 2 * idx + 1, R = 2 * idx + 2;
cnt[idx] = cnt[L] + cnt[R];
cnt[idx] += min(close[R], open[L]);
close[idx] = (close[L] + close[R]) - min(close[R], open[L]);
open[idx] = (open[R] + open[L]) - min(close[R], open[L]);
}
void make(int s, int e, int id, char c, int idx) {
if (s == e - 1) {
if (c == ')') close[idx] += 1;
if (c == '(') open[idx] += 1;
return;
}
int mid = (s + e) / 2, L = 2 * idx + 1, R = 2 * idx + 2;
if (id < mid) make(s, mid, id, c, L);
if (id >= mid) make(mid, e, id, c, R);
up(idx);
}
void gets(int s, int e, int l, int r, int idx) {
if (e <= l || r <= s) return;
if (l == s and e == r) {
seg.push_back(idx);
return;
}
int mid = (s + e) / 2, L = 2 * idx + 1, R = 2 * idx + 2;
gets(s, mid, l, min(mid, r), L);
gets(mid, e, max(l, mid), r, R);
}
int ans() {
int ans = 0, o = 0, c = 0;
for (int i = 0; i < seg.size(); i++) {
ans += cnt[seg[i]];
o += open[seg[i]];
if (i + 1 < seg.size()) {
ans += min(o, close[seg[i + 1]]);
o -= min(o, close[seg[i + 1]]);
}
}
seg.clear();
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> str;
n = str.size();
for (int i = 0; i < n; i++) make(0, n, i, str[i], 0);
cin >> q;
while (q--) {
int r, l;
cin >> l >> r;
l--;
gets(0, n, l, r, 0);
cout << 2 * ans() << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[100009];
int b[100009];
int q = 0, w = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
if (k > 0) {
if (k % 2) {
a[q++] = k;
} else
ans += k;
} else
b[w++] = k;
}
if (q % 2 == 1) {
for (int i = 0; i < q; i++) ans += a[i];
cout << ans << endl;
return 0;
}
sort(a, a + q);
sort(b, b + w);
if (q == 0) {
for (int i = w - 1; i >= 0; i--) {
if (-b[i] % 2 == 1) {
cout << ans + b[i];
return 0;
}
}
cout << "-1";
return 0;
}
for (int i = 1; i < q; i++) {
ans += a[i];
}
for (int i = w - 1; i >= 0; i--) {
if (-b[i] % 2 == 1) {
if (a[0] > -b[i])
cout << ans + a[0] + b[i];
else
cout << ans;
return 0;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int arr[30001];
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
int dp1 = arr[1];
int dp2 = 0;
bool fail = 0;
for (int i = 2; i < n; i++) {
arr[i] = arr[i] - dp2;
if (arr[i] < 0) {
fail = 1;
break;
}
if (arr[i] > dp1) {
arr[i] = arr[i] - dp1;
dp2 = dp2 + arr[i];
} else {
dp1 = arr[i];
}
}
if (dp2 > arr[n]) {
fail = 1;
}
if (fail) {
cout << "NO"
<< "\n";
} else {
cout << "YES"
<< "\n";
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
cout << i / 2 + 1;
} else {
cout << n - i / 2;
}
cout << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
long long power(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b % m, e / 2, m) % m;
return power(b * b % m, e / 2, m);
}
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e & 1) return b * power(b * b, e / 2);
return power(b * b, e / 2);
}
template <typename T, typename U>
static inline void setmin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void setmax(T &x, U y) {
if (x < y) x = y;
}
const int N = 500004;
long long a[N], n, r, k, temp[N];
bool check(long long m) {
long long val = k, i, j;
long long cnt = 0;
for (int i = 0; i <= n + 2; ++i) temp[i] = 0;
for (i = 0; i < n; ++i) {
cnt += temp[i];
if (a[i] + cnt < m) {
if (m - a[i] - cnt > val) return false;
val -= m - a[i] - cnt;
temp[min(i + 2 * r + 1, n)] -= m - a[i] - cnt;
cnt += m - a[i] - cnt;
}
}
return true;
}
int _runtimeTerror_() {
long long i;
cin >> n >> r >> k;
for (i = 0; i < n; ++i) cin >> a[i];
long long psum[n + 1];
psum[0] = 0;
for (i = 1; i <= n; ++i) psum[i] = psum[i - 1] + a[i - 1];
for (i = 0; i < n; ++i) {
long long up = i + r + 1, lo = i - r;
if (i + r + 1 > n) up = n;
if (lo < 0) lo = 0;
a[i] = psum[up] - psum[lo];
}
long long lo = 0, hi = 3000000000000000000;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (check(mid))
lo = mid + 1;
else
hi = mid - 1;
}
cout << lo - 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) _runtimeTerror_();
cerr << "\n" << 1.0 * clock() / CLOCKS_PER_SEC;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void fre() {
freopen("c://test//input.in", "r", stdin);
freopen("c://test//output.out", "w", stdout);
}
template <class T1, class T2>
inline void gmax(T1 &a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1 &a, T2 b) {
if (b < a) a = b;
}
const int N = 4040, M = 0, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
int n, m;
int y, x;
int ln[1010], ls[1010];
vector<int> a[N];
int p[N];
bool e[N];
int hungary(int x) {
e[x] = 1;
for (int i = a[x].size() - 1; ~i; i--) {
int y = a[x][i];
if (p[y] == -1) {
p[y] = x;
return 1;
}
}
for (int i = a[x].size() - 1; ~i; i--) {
int y = a[x][i];
if (!e[p[y]] && hungary(p[y])) {
p[y] = x;
return 1;
}
}
return 0;
}
void ins(int x, int y) { a[x].push_back(y); }
int main() {
while (~scanf("%d%d", &n, &m)) {
memset(ln, 1, sizeof(ln));
memset(ls, 1, sizeof(ls));
int n2 = n * 2;
int n3 = n * 3;
int n4 = n * 4;
for (int i = 1; i <= n4; ++i) a[i].clear();
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &y, &x);
ln[y] = 0;
ls[x] = 0;
}
for (int i = 2; i < n; ++i)
if (ln[i]) {
ins(i, i + n);
ins(i + n, i);
if (ls[i]) {
ins(i, i + n2);
ins(i + n2, i);
}
if (ls[n + 1 - i]) {
ins(i, i + n3);
ins(i + n3, i);
}
if (ls[n + 1 - i]) {
ins(i + n, i + n3);
ins(i + n3, i + n);
}
if (ls[n + 1 - i]) {
ins(i + n, n + 1 - i + n2);
ins(n + 1 - i + n2, i + n);
}
}
for (int j = 2; j < n; ++j)
if (ls[j]) {
ins(n + n + j, n + n + n + j);
ins(n + n + n + j, n + n + j);
}
memset(p, -1, sizeof(p));
int ans = 0;
for (int i = 1; i <= n4; i++) {
memset(e, 0, sizeof(e));
if (hungary(i)) ans++;
}
ans /= 2;
if (n & 1) {
if (ln[n / 2 + 1] && ls[n / 2 + 1]) --ans;
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int dx[] = {0, -1, 0, 1, -1, 1, -1, 1};
int dy[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const int MOD = 1e9 + 7, N = 2e5 + 5, oo = 2e9;
const double pi = acos(-1);
using namespace std;
long long day[N], h[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
long long ans = -1;
for (int i = 0; i < m; i++) {
cin >> day[i] >> h[i];
ans = max(ans, h[i]);
if (i and day[i] - day[i - 1] < abs(h[i] - h[i - 1]))
return cout << "IMPOSSIBLE", 0;
}
ans = max(ans, h[0] + day[0] - 1);
ans = max(ans, h[m - 1] + (n - day[m - 1]));
for (int i = 1; i < m; i++) {
long long dif = day[i] - day[i - 1], cur = h[i - 1];
if (h[i] > h[i - 1])
ans = max(ans, h[i] + (day[i] - day[i - 1] - abs(h[i] - h[i - 1])) / 2);
else
ans =
max(ans, h[i - 1] + (day[i] - day[i - 1] - abs(h[i] - h[i - 1])) / 2);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int BIT = 17;
const int D = 60;
bool has[N];
vector<int> fac[N];
int maxnum = 0;
struct Trie {
struct Node {
int data;
Node* nex[2];
Node() {
data = 1e9 + 10;
nex[0] = nex[1] = NULL;
}
};
Node* root = new Node();
void add(int x) {
Node* now = root;
for (int i = BIT - 1; i >= 0; --i) {
now->data = min(x, now->data);
int bit = (x >> i) & 1;
if (now->nex[bit] == NULL) now->nex[bit] = new Node();
now = now->nex[bit];
}
now->data = min(x, now->data);
}
int query_max(int x, int lim) {
Node* now = root;
int res = 0;
for (int i = BIT - 1; i >= 0; --i) {
int bit = !((x >> i) & 1);
if (now->nex[bit] == NULL || now->nex[bit]->data > lim) bit ^= 1;
now = now->nex[bit];
res = (res << 1) | bit;
}
return res;
}
} t[D + 5];
void init() {
for (int i = 1; i <= D; ++i)
for (int j = i; j <= 100000; j += i) fac[j].push_back(i);
}
int query(int x, int k, int s) {
if (x % k != 0) return -1;
if (k > D) {
int lim = min(maxnum, s - x);
int res = -1;
for (int i = k; i <= lim; i += k)
if (has[i]) res = max(res, x ^ i);
if (res == -1) return -1;
return res ^ x;
}
if (t[k].root->data > s - x) return -1;
return t[k].query_max(x, s - x);
}
int main() {
int Q, op, x, k, s;
init();
scanf("%d", &Q);
while (Q--) {
scanf("%d%d", &op, &x);
if (op == 1) {
if (has[x]) continue;
maxnum = max(maxnum, x);
has[x] = 1;
for (auto i : fac[x]) t[i].add(x);
} else {
scanf("%d%d", &k, &s);
printf("%d\n", query(x, k, s));
}
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.