solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 54;
int matr[MAX][MAX];
bool tryIn(int x, int y) {
int f = 0;
if (matr[y][x] == 1 && matr[y + 1][x - 1] == 1 && matr[y + 1][x] == 1 &&
matr[y + 1][x + 1] == 1 && matr[y + 2][x] == 1) {
matr[y][x] = 2;
matr[y + 1][x - 1] = 2;
matr[y + 1][x] = 2;
matr[y + 1][x + 1] = 2;
matr[y + 2][x] = 2;
return true;
} else {
return false;
}
}
void solve() {
int n;
cin >> n;
char c;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
cin >> c;
if (c == '.') {
matr[i][j] = 1;
} else if (c == '#') {
matr[i][j] = 2;
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (matr[i][j] == 1 && !tryIn(j, i)) {
cout << "NO" << endl;
return;
}
}
}
cout << "YES" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
int test = 1;
while (test-- > 0) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int b[n + 1];
int i, j;
for (int i = 1; i <= n; i++) cin >> b[i];
int a[2 * n + 1];
bool vis[2 * n + 1];
for (int i = 0; i <= 2 * n; i++) vis[i] = false;
for (int i = 1; i <= n; i++) {
a[2 * i - 1] = b[i];
vis[b[i]] = true;
}
bool flag = false;
for (int i = 1; i <= n; i++) {
flag = false;
for (j = b[i] + 1; j <= 2 * n; j++) {
if (!vis[j]) {
a[2 * i] = j;
vis[j] = true;
flag = true;
break;
}
}
if (!flag) {
break;
}
}
if (!flag) {
cout << "-1\n";
} else {
for (int i = 1; i <= 2 * n; i++) cout << a[i] << " ";
cout << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
long long dp[N];
long long aa[3 * N];
int main() {
int n;
long long L, v1, v2;
while (scanf("%d%lld%lld%lld", &n, &L, &v1, &v2) != EOF) {
L *= (v1 + v2);
long long len = L - L / (v1 + v2) * v1;
for (int i = 0; i < n; i++) {
scanf("%lld", &aa[i]);
aa[i] *= v1 + v2;
aa[i + n] = aa[i] + L * 2;
aa[i + 2 * n] = aa[i] + L * 4;
}
n *= 3;
long long ii = aa[0];
for (int j = 0; j < n; j++) aa[j] -= ii;
ii = 0;
memset(dp, 0, sizeof(dp));
while (ii < L * 2) {
int l = lower_bound(aa, aa + n, ii) - aa;
int r = lower_bound(aa, aa + n, ii + len) - aa;
long long x;
if (aa[l] != L * 2)
x = min(aa[l] - ii + 1, aa[r] - ii - len + 1);
else
x = min(aa[l] - ii, aa[r] - ii - len + 1);
dp[r - l] += x;
ii += x;
}
for (int i = 0; i <= n / 3; i++) printf("%.20lf\n", (double)dp[i] / L / 2);
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
const int N = 500005;
int H[N], id;
struct Edge {
int v, nt;
} e[N * 4];
int n, m;
int next[N];
std::vector<int> block[N];
int num, head;
int p[N];
void AddEdge(int u, int v) {
e[id].v = v;
e[id].nt = H[u];
H[u] = id++;
}
int main() {
scanf("%d%d", &n, &m);
id = 1;
num = 0;
int a, b;
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
AddEdge(a, b);
AddEdge(b, a);
}
for (int i = 1; i <= n; i++) next[i] = i + 1;
for (head = 1; head <= n; num++) {
block[num].push_back(head);
head = next[head];
int pre;
for (int i = 0; i < block[num].size(); i++) {
int u = block[num][i];
for (int j = H[u]; j; j = e[j].nt) p[e[j].v] = u;
for (int j = head; j <= n; j = next[j])
if (p[j] != u) {
block[num].push_back(j);
if (j == head)
head = next[head];
else
next[pre] = next[j];
} else
pre = j;
}
}
printf("%d\n", num);
for (int i = 0; i < num; i++) {
printf("%d", block[i].size());
for (int j = 0; j < block[i].size(); j++) printf(" %d", block[i][j]);
puts("");
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
char s[10005][10005];
int main() {
int n, v;
int i, j, k, l, h, r, cont;
cin >> n >> v;
for (i = 0; i < 4 * n; i++) cin >> &s[i][0];
char schm[5] = {"aaaa"};
char c[5][10005];
for (i = 0; i < 4 * n; i += 4) {
for (j = i, h = 0; j < i + 4; h++, j++) {
l = strlen(&s[j][0]);
cont = 0;
for (k = l - 1; k >= 0; k--) {
if (s[j][k] == 'a' || s[j][k] == 'o' || s[j][k] == 'e' ||
s[j][k] == 'i' || s[j][k] == 'u')
cont++;
if (cont == v) {
strcpy(&c[h][0], &s[j][k]);
goto zz;
}
}
cout << "NO" << endl;
return 0;
zz:;
}
if (!strcmp(&c[0][0], &c[1][0]) && !strcmp(&c[1][0], &c[2][0]) &&
!strcmp(&c[2][0], &c[3][0])) {
continue;
} else if (!strcmp(&c[0][0], &c[1][0]) && !strcmp(&c[2][0], &c[3][0])) {
if (!strcmp(schm, "aaaa"))
strcpy(schm, "aabb");
else if (!strcmp(schm, "aabb"))
continue;
else {
cout << "NO" << endl;
return 0;
}
} else if (!strcmp(&c[0][0], &c[2][0]) && !strcmp(&c[1][0], &c[3][0])) {
if (!strcmp(schm, "aaaa"))
strcpy(schm, "abab");
else if (!strcmp(schm, "abab"))
continue;
else {
cout << "NO" << endl;
return 0;
}
} else if (!strcmp(&c[0][0], &c[3][0]) && !strcmp(&c[1][0], &c[2][0])) {
if (!strcmp(schm, "aaaa"))
strcpy(schm, "abba");
else if (!strcmp(schm, "abba"))
continue;
else {
cout << "NO" << endl;
return 0;
}
} else {
cout << "NO" << endl;
return 0;
}
}
cout << schm << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, shots;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
cin >> shots;
int w[shots], o[shots];
for (int i = 0; i < shots; i++) {
cin >> w[i] >> o[i];
}
for (int i = 0; i < shots; i++) {
int temp = w[i] - 1;
if (temp > 0) arr[temp - 1] += abs(1 - o[i]);
if (temp < n - 1) arr[temp + 1] += arr[temp] - o[i];
arr[temp] = 0;
}
for (int i = 0; i < n; i++) {
cout << arr[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
const int NINF = -1e9;
int d[maxn];
int main() {
int n;
while (scanf("%d", &n) == 1) {
for (int i = 0; i < n; i++) scanf("%d", &d[i]);
int odd, even;
odd = even = NINF;
for (int i = 0; i < n; i++) {
if (d[i] % 2 == 0) {
odd = max(odd, odd + d[i]);
even = max({even, even + d[i], d[i]});
} else {
int odd2;
odd2 = max({odd, even + d[i], d[i]});
even = max({even, odd + d[i]});
odd = odd2;
}
}
printf("%d\n", odd);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ara[100005];
vector<int> st[100005], en[100005];
int l[100005], r[100005];
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
};
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> ara[i];
for (int i = 1; i <= m; i++) {
cin >> l[i] >> r[i];
st[l[i]].push_back(r[i]);
en[r[i]].push_back(l[i]);
}
int mx = 0;
int now_maximum = INT_MIN;
int idx;
for (int i = 1; i <= n; i++) {
for (int j : st[i]) {
for (int k = i; k <= j; k++) {
ara[k]--;
}
}
now_maximum = max(ara[i], now_maximum);
if (now_maximum - ara[i] >= mx) {
mx = now_maximum - ara[i];
idx = i;
}
for (int j : en[i]) {
for (int k = i; k >= j; k--) {
ara[k]++;
now_maximum = max(now_maximum, ara[k]);
}
}
}
now_maximum = INT_MIN;
for (int i = n; i >= 1; i--) {
for (int j : en[i]) {
for (int k = i; k >= j; k--) {
ara[k]--;
}
}
now_maximum = max(ara[i], now_maximum);
now_maximum = max(now_maximum, ara[i]);
if (now_maximum - ara[i] >= mx) {
mx = now_maximum - ara[i];
idx = i;
}
for (int j : st[i]) {
for (int k = i; k <= j; k++) {
ara[k]++;
now_maximum = max(now_maximum, ara[k]);
}
}
}
cout << mx << endl;
vector<int> ans;
for (int i = 1; i <= m; i++) {
if (l[i] <= idx && r[i] >= idx) ans.push_back(i);
}
cout << ans.size() << endl;
for (int i : ans) cout << i << ' ';
cout << endl;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int a[100] = {0};
int A, n;
scanf("%d%d", &n, &A);
A--;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int l = A, r = A, ans = 0;
if (a[A] == 1) ans++;
while (l >= 0 || r < n) {
l--;
r++;
if (l >= 0 && r < n)
if (a[l] == a[r] && a[l] == 1) ans += 2;
if (l < 0 && r < n) {
if (a[r] == 1) ans++;
}
if (l >= 0 && r >= n)
if (a[l] == 1) ans++;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 200 * 1000 + 100;
int n, a[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int test = 1;
while (test--) {
cin >> n;
set<int> ans;
set<int> P;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x;
set<int> S;
y = x;
ans.insert(x);
S.insert(x);
for (auto u : P) {
S.insert(x | u);
ans.insert(x | u);
}
P = S;
}
cout << ans.size() << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int f[200000], t[200000];
int nx[26][200000], ny[26][200000];
int main() {
string a, b;
cin >> a >> b;
for (int i = 0; i < (26); i++) {
nx[i][a.size()] = a.size();
for (int j = a.size() - 1; j >= 0; j--) {
if (a[j] - 'a' == i)
nx[i][j] = j;
else
nx[i][j] = nx[i][j + 1];
}
}
for (int i = 0; i < (26); i++) {
for (int j = 0; j < a.size(); j++) {
if (a[j] - 'a' == i)
ny[i][j] = j;
else
ny[i][j] = (j ? ny[i][j - 1] : -1);
}
}
for (int i = 0; i < (b.size()); i++) {
if (i == 0)
f[i] = nx[b[i] - 'a'][0];
else
f[i] =
(f[i - 1] >= a.size() - 1 ? a.size() : nx[b[i] - 'a'][f[i - 1] + 1]);
}
for (int i = b.size() - 1; i >= 0; i--) {
if (i == b.size() - 1)
t[i] = ny[b[i] - 'a'][a.size() - 1];
else
t[i] = (t[i + 1] <= 0 ? -1 : ny[b[i] - 'a'][t[i + 1] - 1]);
}
t[b.size()] = a.size();
int l = 0, r = INT_MAX;
for (int R = 0; R < (b.size() + 1); R++) {
if (t[R] == -1) continue;
int L = lower_bound(f, f + R, t[R]) - f;
if (r - l > R - L) l = L, r = R;
}
for (int i = 0; i < l; i++) cout << b[i];
for (int i = r; i < b.size(); i++) cout << b[i];
if (r - l >= b.size()) cout << "-";
cout << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> edge[505];
int c[505][505];
int main() {
cin >> n >> m;
string s;
for (int i = 0; i < n; i++) s += "a";
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
edge[a].push_back(b);
edge[b].push_back(a);
c[a][b] = c[b][a] = 1;
}
int flag = 1;
for (int i = 0; i < n; i++) {
c[i][i] = 1;
edge[i].push_back(i);
if (edge[i].size() == n)
s[i] = 'b';
else if (flag) {
flag = 0;
for (int j = 0; j < n; j++)
if (!c[i][j]) s[j] = 'c';
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((max(s[i], s[j]) - min(s[i], s[j]) <= 1 and !c[i][j]) or
(max(s[i], s[j]) - min(s[i], s[j]) > 1 and c[i][j])) {
cout << "No\n";
return 0;
}
}
}
cout << "Yes\n" << s << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
int n;
char str[10];
bool ok[8];
int main() {
scanf("%d %s", &n, str);
for (int i = 0; i < 8; i++) ok[i] = true;
for (int i = 0; i < n; i++) {
switch (str[i]) {
case '0':
ok[2] = ok[3] = ok[4] = ok[5] = ok[6] = false;
break;
case '1':
ok[5] = ok[6] = ok[7] = ok[0] = ok[1] = false;
break;
case '2':
ok[7] = ok[0] = ok[1] = false;
break;
case '3':
ok[7] = ok[0] = ok[1] = ok[2] = ok[3] = false;
break;
case '4':
ok[7] = ok[6] = ok[5] = false;
break;
case '5':
break;
case '6':
ok[1] = ok[2] = ok[3] = false;
break;
case '7':
ok[7] = ok[6] = ok[5] = ok[4] = ok[3] = false;
break;
case '8':
ok[5] = ok[3] = false;
break;
case '9':
ok[1] = ok[2] = ok[3] = ok[4] = ok[5] = false;
break;
}
}
for (int i = 0; i < 8; i++) {
if (ok[i]) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<long long int> v;
string a;
for (long long int i = 0; i < s.length(); i++) {
if (s[i] == 'a' || s[i] == 'b') a += s[i];
}
for (long long int i = 0; i < a.length(); i++) {
long long int count = 0;
if (a[i] == 'a') {
while (i < a.length() && a[i] == 'a') {
count++;
i++;
}
i--;
}
v.push_back(count);
}
long long int ans = 1;
long long int mod = pow(10, 9) + 7;
for (long long int i = 0; i < v.size(); i++) {
ans = (ans * (v[i] + 1)) % mod;
}
cout << ans - 1;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 12 + 5;
int main() {
int t, len = 6, ret[maxn], cnt;
char s[maxn], r[] = {1, 2, 3, 4, 6, 12};
while (scanf("%d", &t) == 1) {
while (t--) {
cnt = 0;
scanf("%s", s);
for (int i = len - 1; i >= 0; i--) {
int a = 12 / r[i];
int b = r[i];
for (int j = 0; j < b; j++) {
bool ok = true;
for (int k = 0; k < a; k++) {
if (s[k * b + j] == 'O') {
ok = false;
break;
}
}
if (ok) {
ret[cnt++] = a;
break;
}
}
}
printf("%d", cnt);
for (int i = 0; i < cnt; i++) printf(" %dx%d", ret[i], 12 / ret[i]);
puts("");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 1, 0, 0, -1, -1, 1, 1};
int dy[] = {0, 0, -1, 1, -1, 1, 1, -1};
const int maxn = 1000000 + 66;
const int maxm = 100000 + 66;
const long long mod = 1e9 + 7;
const long long inf = 0x3f3f3f3f3f3f3f3fLL;
const int INF = 99999999;
int du[maxn];
int f[maxn];
int vis[maxn];
int sum[maxn];
int finds(int x) { return x == f[x] ? x : f[x] = finds(f[x]); }
void unions(int x, int y) {
int fx = finds(x);
int fy = finds(y);
if (fx != fy) {
f[fx] = fy;
}
return;
}
int main() {
int n, m;
while (scanf("%d %d", &n, &m) != EOF) {
int u, v;
for (register int i = (1); i <= (n); i++) {
f[i] = i;
sum[i] = du[i] = 0;
}
vis[1] = 1;
for (register int i = (1); i <= (m); i++) {
int u, v;
scanf("%d %d", &u, &v);
if (u != v) {
du[u]++;
du[v]++;
vis[u]++;
vis[v]++;
unions(u, v);
} else {
vis[v]++;
}
}
int s1 = 0;
for (register int i = (1); i <= (n); i++) {
if (du[i] & 1) {
sum[finds(i)]++;
}
}
int s2 = 0;
int s3 = 0;
for (register int i = (1); i <= (n); i++) {
if (finds(i) == i && vis[i]) {
if (sum[i])
s2 += sum[i];
else
s3++;
s1++;
}
}
if (s1 == 1) {
printf("%d\n", s2 / 2);
} else {
printf("%d\n", s2 / 2 + s3);
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long N, Q;
long long even_above(long long row) {
if (N % 2 == 0) {
return row * N / 2;
} else {
long long even_rows = (row + 1) / 2;
long long odd_rows = row - even_rows;
return even_rows * ((N + 1) / 2) + odd_rows * (N / 2);
}
}
long long even_before(long long row, long long col) {
if (row % 2 == 0) {
return col / 2;
} else {
return (col + 1) / 2;
}
return (col + (row & 1)) / 2;
}
long long solve(long long r, long long c) {
long long v1 = even_above(r - 1);
long long v2 = even_before(r, c);
if ((r + c) % 2 == 0) {
return v1 + v2;
} else {
return (r - 1) * N + c - (v1 + v2) + (N * N + 1) / 2;
}
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
cin >> N >> Q;
while (Q--) {
long long r, c;
cin >> r >> c;
cout << solve(r, c) << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
inline int ReadIn() {
char ch = getchar();
int data = 0;
while (ch < '0' || ch > '9') ch = getchar();
do {
data = data * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return data;
}
char str[1001][7];
int main() {
int n;
n = ReadIn();
int max = 6;
for (int i = 0; i < n; i++) scanf("%s", str[i]);
if (n == 1) {
puts("6");
return 0;
}
for (int i = 0; i < n; i++) {
if (max == 1) break;
for (int j = i + 1; j < n; j++) {
int tep = 0;
for (int k = 0; k < 6; k++)
if (str[i][k] != str[j][k]) tep++;
if (tep < max) max = tep;
}
}
printf("%d\n", (max - 1) / 2);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, sum = 0, s = 0;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
if (sum + a[i] > m) {
sum = 0;
s++;
i--;
} else
sum += a[i];
}
if (sum != 0) s++;
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int n, m, f[N], L[N], R[N], id2q[N];
struct Query {
int t, x, y;
} q[N];
inline int get(int x) { return x == f[x] ? x : f[x] = get(f[x]); }
struct SegTree {
vector<int> id[N << 2];
void merge(int t, int l, int r, int P, int ID) {
for (int i = (0); i < (((int)(id[t]).size())); ++i) {
L[ID] = min(L[ID], L[id[t][i]]);
R[ID] = max(R[ID], R[id[t][i]]);
f[get(id[t][i])] = ID;
}
id[t].clear();
if (l < r) {
int z = (l + r) >> 1;
if (P <= z)
merge(((t) << 1), l, z, P, ID);
else
merge(((t) << 1 | 1), z + 1, r, P, ID);
}
}
void insert(int t, int l, int r, int L, int R, int ID) {
if (L <= l && r <= R) {
id[t].push_back(ID);
return;
}
int z = (l + r) >> 1;
if (L <= z) insert(((t) << 1), l, z, L, R, ID);
if (R > z) insert(((t) << 1 | 1), z + 1, r, L, R, ID);
}
} seg;
int main() {
scanf("%d", &n);
vector<int> V;
for (int i = (0); i < (n); ++i) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
q[i] = (Query){t, x, y};
if (t == 1) {
f[m] = m;
++m, V.push_back(x), V.push_back(y);
}
}
sort(V.begin(), V.end());
V.erase(unique(V.begin(), V.end()), V.end());
for (int i = (0); i < (n); ++i)
if (q[i].t == 1) {
q[i].x = lower_bound(V.begin(), V.end(), q[i].x) - V.begin() + 1;
q[i].y = lower_bound(V.begin(), V.end(), q[i].y) - V.begin() + 1;
}
m = 0;
for (int i = (0); i < (n); ++i) {
if (q[i].t == 1) {
int _l = q[i].x, _r = q[i].y;
L[m] = _l, R[m] = _r, id2q[m] = i;
seg.merge(1, 1, ((int)(V).size()), _l, m);
seg.merge(1, 1, ((int)(V).size()), _r, m);
if (L[m] + 1 <= R[m] - 1)
seg.insert(1, 1, ((int)(V).size()), L[m] + 1, R[m] - 1, m);
++m;
} else {
if (get(q[i].x - 1) == get(q[i].y - 1)) {
puts("YES");
} else {
int la = q[id2q[q[i].x - 1]].x;
int ra = q[id2q[q[i].x - 1]].y;
int fb = get(q[i].y - 1);
puts((L[fb] < la && la < R[fb]) || (L[fb] < ra && ra < R[fb]) ? "YES"
: "NO");
}
}
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const long long MOD = 1e9 + 7;
const long long mult = 15265731;
int n, m, p;
char s1[N], s2[N];
int dp[N][35];
long long h1[N], h2[N];
long long h[N];
long long geth(long long H[], int x, int y) {
long long dec = H[x - 1] * h[y - x + 1] % MOD;
return (H[y] - dec + MOD) % MOD;
}
int main() {
scanf("%d%s%d%s%d", &n, s1 + 1, &m, s2 + 1, &p);
h[0] = 1ll;
for (int i = 1; i < N; i++) h[i] = h[i - 1] * mult % MOD;
for (int i = 1; i <= n; i++)
h1[i] = (h1[i - 1] * mult % MOD + 1ll * s1[i]) % MOD;
for (int i = 1; i <= m; i++)
h2[i] = (h2[i - 1] * mult % MOD + 1ll * s2[i]) % MOD;
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j <= p; j++)
if (dp[i][j] != -1) {
dp[i + 1][j] = max(dp[i][j], dp[i + 1][j]);
if (j == p) continue;
int ii = i + 1, jj = dp[i][j] + 1;
int l = ii, r = n;
while (l <= r) {
int mid = (l + r) >> 1;
int len = mid - ii + 1;
int End = jj + len - 1;
if (End <= m && geth(h1, ii, mid) == geth(h2, jj, End))
l = mid + 1;
else
r = mid - 1;
}
l--;
int len = l - ii + 1;
if (len > 0) {
dp[l][j + 1] = max(jj + len - 1, dp[l][j + 1]);
}
}
for (int j = 0; j <= p; j++)
if (dp[n][j] == m) {
puts("YES");
return 0;
}
puts("NO");
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
const int M = 101000;
const int INF = 0x3f3f3f3f;
const int mod = 1000000007;
void MOD(long long &a) {
if (a >= mod) a -= mod;
}
void MOD(long long &a, long long c) {
if (a >= c) a -= c;
}
void ADD(long long &a, long long b) {
a += b;
MOD(a);
}
void ADD(long long &a, long long b, long long c) {
a += b;
MOD(a, c);
}
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b /= 2;
}
return ans;
}
long long qpow(long long a, long long b, long long c) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % c;
a = a * a % c;
b /= 2;
}
return ans;
}
long long c[N][N], k, dp[N][N];
int t, num[N], ans[N];
long long getsum(int n) {
if (n <= 0) return 1;
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= 16; i++) {
dp[i - 1][0] = 1;
for (int j = 1; j <= n; j++) {
for (int k = 0; k <= num[i - 1] && k <= j; k++) {
dp[i][j] += dp[i - 1][j - k] * c[j][k];
}
}
}
return dp[16][n];
}
long long get(int n) {
long long ans = 0;
for (int i = 1; i < 16; i++) {
if (num[i]) {
num[i]--;
ans += getsum(n - 1);
num[i]++;
}
}
return ans;
}
void init() {
for (int i = 1; i < 21; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
}
}
int main() {
init();
scanf("%lld%d", &k, &t);
int len = 0;
for (int i = 1;; i++) {
for (int j = 0; j < 16; j++) num[j] = t;
long long sum = get(i);
if (sum >= k)
break;
else {
k -= sum;
len = i;
}
}
len++;
for (int j = 0; j < 16; j++) num[j] = t;
for (int i = len; i >= 1; i--) {
int st = (i == len) ? 1 : 0;
for (int j = st; j < 16; j++) {
if (num[j]) {
num[j]--;
long long sum = getsum(i - 1);
if (sum >= k) {
ans[i] = j;
break;
} else {
k -= sum;
num[j]++;
}
}
}
}
for (int i = len; i >= 1; i--) {
if (ans[i] < 10)
printf("%d", ans[i]);
else
printf("%c", 'a' + ans[i] - 10);
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const long long int zero = 0L;
long long int prime_table[] = {1009L, 10007L, 100003L, 1000003L,
10000019L, 100000007L, 1000000007L};
const long long int maxn_1 = 3.1e1;
const long long int maxn_2 = 3.1e2;
const long long int maxn_3 = 3.1e3;
const long long int maxn_4 = 3.1e4;
const long long int maxn_5 = 3.1e5;
const long long int maxn_6 = 3.1e6;
signed main() {
{
ios::sync_with_stdio(0);
cin.tie(0);
};
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int ans = 0;
for (long long int i = 1; i < n / 2; i += 1) ans += i * (i + 1) * 8;
ans += 4 * (1 + n / 2) * (n / 2);
(cout << ans << endl);
}
return 0;
}
| 2 |
#include <iostream>
#include <iomanip>
using namespace std;
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <string>
#include <algorithm>
#include <cmath>
#include <cassert>
#include <utility>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <climits>
#define ll long long
#define nwln '\n'
template<typename T>
T floor_div(T a, T b) {
return a / b - ((a ^ b) < 0 && a % b != 0);
}
template<typename T>
T ceil_div(T a, T b) {
return a / b + ((a ^ b) > 0 && a % b != 0);
}
#define yes cout<<"YES"<<endl
#define no cout<<"NO"<<endl
#define TST_CASES 1
#define CASE_NUM 0
void Solve() {
int n,m;
cin>>n>>m;
int x[1+n];
int dir[1+n];
int ans[1+n];
vector<int> evens;
vector<int> odds;
map<int,int> ind;
for(int i=1;i<=n;i++) {
cin>>x[i];
if(x[i]%2==0) {
evens.push_back(x[i]);
ind[x[i]]=i;
}
else {
odds.push_back(x[i]);
ind[x[i]]=i;
}
}
for(int i=1;i<=n;i++) {
char ch;
cin>>ch;
if(ch=='L')
dir[i]=0;
else
dir[i]=1;
}
sort(evens.begin(),evens.end());
sort(odds.begin(),odds.end());
vector<int> lefts;
vector<int> rights;
for(auto e: evens) {
if(dir[ind[e]]==1)
rights.push_back(e);
else if(!rights.empty()) {
int y=rights.back();
rights.pop_back();
ans[ind[y]]=(e-y)/2;
ans[ind[e]]=(e-y)/2;
}
else {
lefts.push_back(e);
}
}
while(rights.size()>=2) {
int e=rights.back();
rights.pop_back();
int y=rights.back();
rights.pop_back();
ans[ind[y]]=(m-e) + (e-y)/2;
ans[ind[e]]=(m-e) + (e-y)/2;
}
reverse(lefts.begin(),lefts.end());
while(lefts.size()>=2) {
int e=lefts.back();
lefts.pop_back();
int y=lefts.back();
lefts.pop_back();
ans[ind[y]]=(e) + (y-e)/2;
ans[ind[e]]=(e) + (y-e)/2;
}
if(lefts.size()==1 && rights.size()==1) {
int e=lefts.back();
lefts.pop_back();
int y=rights.back();
rights.pop_back();
ans[ind[y]]=(m) - (y-e)/2;
ans[ind[e]]=(m) - (y-e)/2;
}
else {
if(!rights.empty()) {
int y=rights.back();
rights.pop_back();
ans[ind[y]]=-1;
}
if(!lefts.empty()) {
int e=lefts.back();
lefts.pop_back();
ans[ind[e]]=-1;
}
}
lefts.clear();
rights.clear();
for(auto e: odds) {
if(dir[ind[e]]==1)
rights.push_back(e);
else if(!rights.empty()) {
int y=rights.back();
rights.pop_back();
ans[ind[y]]=(e-y)/2;
ans[ind[e]]=(e-y)/2;
}
else {
lefts.push_back(e);
}
}
while(rights.size()>=2) {
int e=rights.back();
rights.pop_back();
int y=rights.back();
rights.pop_back();
ans[ind[y]]=(m-e) + (e-y)/2;
ans[ind[e]]=(m-e) + (e-y)/2;
}
reverse(lefts.begin(),lefts.end());
while(lefts.size()>=2) {
int e=lefts.back();
lefts.pop_back();
int y=lefts.back();
lefts.pop_back();
ans[ind[y]]=(e) + (y-e)/2;
ans[ind[e]]=(e) + (y-e)/2;
}
if(lefts.size()==1 && rights.size()==1) {
int e=lefts.back();
lefts.pop_back();
int y=rights.back();
rights.pop_back();
ans[ind[y]]=(m) - (y-e)/2;
ans[ind[e]]=(m) - (y-e)/2;
}
else {
if(!rights.empty()) {
int y=rights.back();
rights.pop_back();
ans[ind[y]]=-1;
}
if(!lefts.empty()) {
int e=lefts.back();
lefts.pop_back();
ans[ind[e]]=-1;
}
}
for(int i=1;i<=n;i++) cout<<ans[i]<<" ";
cout<<endl;
}
int main() {
cout<<fixed<<setprecision(15);
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
int t=1;
#if TST_CASES
cin>>t;
#endif
for(int i=1;i<=t;i++) {
#if CASE_NUM
cout<<"Case #"<<i<<": ";
#endif
Solve();
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
struct operate {
int l, r, id;
} a[N + 5];
int n, m, b[N * 2 + 5], id[N * 2 + 5], cost[N * 4 + 5], tot, pos;
struct Segment_tree {
int sgm[N * 16 + 5], sum[N * 16 + 5], lazy[N * 16 + 5];
void build(int o, int l, int r) {
if (l == r) {
sgm[o] = sum[o] = cost[l];
return;
}
int mid = (l + r) >> 1;
build((o << 1), l, mid);
build((o << 1 | 1), mid + 1, r);
sum[o] = sum[(o << 1)] + sum[(o << 1 | 1)];
sgm[o] = sgm[(o << 1)] + sgm[(o << 1 | 1)];
}
void pushdown(int o) {
if (lazy[o] == -1)
sgm[(o << 1)] = sgm[(o << 1 | 1)] = 0,
lazy[(o << 1)] = lazy[(o << 1 | 1)] = -1;
else
sgm[(o << 1)] = sum[(o << 1)], sgm[(o << 1 | 1)] = sum[(o << 1 | 1)],
lazy[(o << 1)] = lazy[(o << 1 | 1)] = 1;
lazy[o] = 0;
}
void update(int o, int l, int r, int a, int b, int val) {
if (a <= l && r <= b) {
if (val == 1)
sgm[o] = 0, lazy[o] = -1;
else
sgm[o] = sum[o], lazy[o] = 1;
return;
}
if (lazy[o]) pushdown(o);
int mid = (l + r) >> 1;
if (a <= mid) update((o << 1), l, mid, a, b, val);
if (b > mid) update((o << 1 | 1), mid + 1, r, a, b, val);
sgm[o] = sgm[(o << 1)] + sgm[(o << 1 | 1)];
}
} T;
void work() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &a[i].l, &a[i].r, &a[i].id);
b[++tot] = a[i].l, b[++tot] = a[i].r;
}
sort(b + 1, b + tot + 1);
tot = unique(b + 1, b + tot + 1) - b - 1;
if (b[1] != 1) ++pos, cost[pos] = b[1] - 1;
for (int i = 1; i < tot; i++) {
id[i] = ++pos, cost[pos] = 1;
if (b[i] + 1 != b[i + 1]) ++pos, cost[pos] = b[i + 1] - b[i] - 1;
}
id[tot] = ++pos, cost[pos] = 1;
if (b[tot] != n) ++pos, cost[pos] = n - b[tot];
T.build(1, 1, pos);
for (int i = 1; i <= m; i++) {
int l = id[lower_bound(b + 1, b + tot + 1, a[i].l) - b],
r = id[lower_bound(b + 1, b + tot + 1, a[i].r) - b];
T.update(1, 1, pos, l, r, a[i].id);
printf("%d\n", T.sgm[1]);
}
}
int main() {
work();
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 304;
char mapka[nax][nax];
bool check(int x, int y, int radius) {
if (mapka[x][y] == '*' && mapka[x + radius][y] == '*' &&
mapka[x - radius][y] == '*' && mapka[x][y + radius] == '*' &&
mapka[x][y - radius] == '*') {
return true;
} else {
return false;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> mapka[i][j];
}
}
for (int radius = 1; k > 0 && radius <= 150; radius++) {
for (int x = radius; k > 0 && x + radius < n; x++) {
for (int y = radius; k > 0 && y + radius < m; y++) {
if (check(x, y, radius)) {
k--;
}
if (k == 0) {
cout << x + 1 << " " << y + 1 << "\n";
cout << x - radius + 1 << " " << y + 1 << "\n";
cout << x + radius + 1 << " " << y + 1 << "\n";
cout << x + 1 << " " << y - radius + 1 << "\n";
cout << x + 1 << " " << y + radius + 1 << "\n";
return 0;
}
}
}
}
cout << "-1\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int c[1000001];
int main(void) {
stack<int> s;
int max = 0;
int cnt = 0;
int n = 0;
char cha;
int i = -1;
while (cin >> cha) {
i++;
if (cha == '(') {
s.push(i);
c[i] = -1;
} else {
if (s.empty()) {
c[i] = -1;
} else {
int d = s.top();
s.pop();
if (d - 1 >= 0 && c[d - 1] >= 0) {
c[i] = c[d - 1];
} else {
c[i] = d;
}
if (i - c[i] + 1 > max) {
max = i - c[i] + 1;
cnt = 1;
} else if (i - c[i] + 1 == max) {
cnt++;
}
}
}
}
if (max > 0)
cout << max << " " << cnt << endl;
else
cout << 0 << " " << 1 << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int v, id, next;
} edge[100050 * 2];
int e, ft[10050];
int n, m;
int cnt, dfn[10050], low[10050];
int dsu[100050], col[100050], size[100050];
bool flag[100050];
int find(int k) { return dsu[k] ^ k ? dsu[k] = find(dsu[k]) : k; }
void merge(int u, int v) {
u = find(col[u]);
v = find(col[v]);
if (u == v)
flag[u] = true;
else {
flag[u] |= flag[v];
dsu[v] = u;
}
}
void add(int u, int v, int id) {
edge[e].v = v;
edge[e].id = id;
edge[e].next = ft[u];
ft[u] = e++;
}
void dfs(int u, int from) {
low[u] = dfn[u] = ++cnt;
for (int i = ft[u]; i != -1; i = edge[i].next) {
if (edge[i].id == from) continue;
int v = edge[i].v;
if (dfn[v] == -1) {
dfs(v, edge[i].id);
if (low[v] < dfn[u]) {
low[u] = min(low[u], low[v]);
merge(from, edge[i].id);
} else if (low[v] == dfn[v]) {
flag[find(col[edge[i].id])] = true;
}
} else if (dfn[v] < dfn[u]) {
low[u] = min(low[u], dfn[v]);
merge(edge[i].id, from);
}
}
}
int main() {
while (scanf("%d%d", &n, &m) == 2) {
e = 0;
memset(ft, -1, sizeof(ft));
int u, v, c;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &c);
add(u, v, i);
add(v, u, i);
col[i] = c;
flag[i] = false;
dsu[i] = i;
size[c] = 1;
}
cnt = 0;
memset(dfn, -1, sizeof(dfn));
dfs(1, -1);
for (int i = 1; i <= m; i++)
if (size[i] && i != find(i)) size[find(i)] += size[i];
int ans = 0;
for (int i = 1; i <= m; i++)
if (size[i] && find(i) == i) ans += size[i] - (!flag[i]);
printf("%d\n", ans);
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 20;
int t, n, x, ps[N];
string s;
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> t;
while (t--) {
int ans = 0;
bool flag = false;
cin >> n >> x >> s;
ps[0] = (s[0] == '0' ? 1 : -1);
for (int i = 1; i < n; i++) ps[i] = ps[i - 1] + (s[i] == '0' ? 1 : -1);
if (ps[n - 1]) {
for (int i = 0; i < n; i++)
if ((x - ps[i]) % ps[n - 1] == 0 && (x - ps[i]) / ps[n - 1] > -1) ans++;
if (!x) ans++;
} else
for (int i = 0; i < n; i++)
if (ps[i] == x) flag = true;
cout << (flag ? -1 : ans) << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
const long long INF = 1e18;
long long biex(long long a, long long b) {
if (b == 0) return 1;
long long ans = biex(a, b / 2);
ans = ans * ans;
if (b & 1)
return ans * a;
else
return ans;
}
const int N = 1e5;
long long fact[N] = {0};
vector<int> divs(int n) {
vector<int> v;
v.push_back(1);
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
v.push_back(i);
v.push_back(n / i);
}
}
if ((int)v.size() > 1 && v[(int)v.size() - 1] == v[(int)v.size() - 2]) {
v[(int)v.size() - 1] = n;
} else {
v.push_back(n);
}
sort(v.begin(), v.end());
return v;
}
void solve() {
int n;
cin >> n;
int a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
int z = i;
while (z > 0 && a[i] % (z + 1) == 0) z--;
if (z == 0) {
cout << "NO\n";
return;
}
}
cout << "YES\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
fact[0] = 1;
fact[1] = 1;
for (int i = 2; i <= 100; i++) {
long long x = (long long)i * fact[i - 1];
if (x > 1e9) break;
fact[i] = x;
}
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sp = 0, t = 0;
bool lock = false, L = false;
cin >> n;
char s[n];
for (int i = 0; i < n; ++i) cin >> s[i];
for (int i = 0; i < n; ++i) {
if (s[i] == '.')
continue;
else if (s[i] == 'R' && (!lock)) {
sp = i + 1;
lock = true;
} else if (s[i] == 'L' && (!L)) {
t = i + 1;
L = true;
break;
}
}
if (!lock) {
cout << t << " " << t - 1;
return 0;
} else if (!L) {
for (int i = sp - 1; i < n; ++i) {
if (s[i] == 'R') continue;
t = i;
break;
}
cout << sp << " " << t + 1;
return 0;
}
cout << sp << " " << t;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline long long int modadd(long long int n, long long int m,
long long int p = 1000000007) {
return ((n + m) % p + p) % p;
}
inline long long int modsub(long long int n, long long int m,
long long int p = 1000000007) {
return ((n - m + p) % p + p) % p;
}
inline long long int modpro(long long int n, long long int m,
long long int p = 1000000007) {
return (((n % p) * (m % p)) % p + p) % p;
}
unsigned long long int powe(long long int first, long long int second) {
unsigned long long int res = 1;
while (second > 0) {
if (second & 1) res = res * first;
second = second >> 1;
first = first * first;
}
return res;
}
long long int modpow(long long int first, long long int second,
long long int p = 1000000007) {
long long int res = 1;
while (second > 0) {
if (second & 1) res = modpro(res, first, p);
second = second >> 1;
first = modpro(first, first, p);
}
return res;
}
inline long long int modInverse(long long int n, long long int p = 1000000007) {
if (n == 1) return 1;
return modpow(n, p - 2, p);
}
inline long long int moddiv(long long int n, long long int m,
long long int p = 1000000007) {
return modpro(n, modInverse(m, p), p);
}
inline long long int modadd3(long long int first, long long int second,
long long int z, long long int p = 1000000007) {
return modadd(modadd(first, second, p), z, p);
}
inline long long int modadd4(long long int first, long long int second,
long long int z, long long int w,
long long int p = 1000000007) {
return modadd(modadd(first, second, p), modadd(z, w, p), p);
}
inline long long int modnCr(long long int fac[], int n, int r,
long long int p = 1000000007) {
if (r == 0) return 1;
return modpro(fac[n], modInverse(modpro(fac[r], fac[n - r], p), p), p);
}
template <typename T>
inline T max3(T first, T second, T z) {
return max(max(first, second), z);
}
template <typename T>
inline T max4(T first, T second, T z, T w) {
return max(max3(first, second, w), z);
}
template <typename T>
inline T min3(T first, T second, T z) {
return min(min(first, second), z);
}
template <typename T>
inline T min4(T first, T second, T z, T w) {
return min(min3(first, second, w), z);
}
template <typename T>
void printArr(T *arr, int s, int n) {
for (int i = s; i <= n; i++) {
cout << arr[i] << " ";
}
cout << endl;
}
vector<int> parent, rank_, size_;
set<int> reps;
void makeSet(int first) {
parent[first] = first;
rank_[first] = 0;
size_[first] = 1;
reps.insert(first);
}
int findSet(int first) {
if (first != parent[first]) parent[first] = findSet(parent[first]);
return parent[first];
}
void unionSets(int first, int second) {
int px = findSet(first);
int py = findSet(second);
if (px == py) return;
if (rank_[px] < rank_[py]) {
parent[px] = py;
reps.erase(px);
size_[py] += size_[px];
} else if (rank_[py] < rank_[px]) {
parent[py] = px;
reps.erase(py);
size_[px] += size_[py];
} else {
parent[py] = px;
rank_[px]++;
reps.erase(py);
size_[px] += size_[py];
}
}
string s[2005][2];
bool vis[2005];
string ans[2005];
bool wn[2005];
vector<int> mem[2005];
int n;
bool f(int rep) {
for (int team : mem[rep]) {
if (wn[team]) cout << (rep) << " " << (team) << " " << ("FUK") << endl;
wn[team] = 1;
ans[team] = s[team][0].substr(0, 2) + s[team][1][0];
}
for (int team : mem[rep]) {
for (int i = (0); i < (n); i++)
if (i != team) {
if (ans[i] == ans[team]) {
if (wn[i] || findSet(i) == rep || (!f(findSet(i)))) return 0;
}
}
}
return 1;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
int erer = 1;
for (int erer2 = (1); erer2 < (erer + 1); erer2++) {
cin >> n;
parent.resize(n + 2);
rank_.resize(n + 2);
size_.resize(n + 2);
for (int i = (0); i < (n); i++) makeSet(i);
for (int i = (0); i < (n); i++) {
cin >> s[i][0] >> s[i][1];
ans[i] = s[i][0].substr(0, 3);
}
for (int i = (0); i < (n); i++)
for (int j = (i + 1); j < (n); j++)
if (ans[i] == ans[j]) unionSets(i, j);
for (int i = (0); i < (n); i++) mem[findSet(i)].push_back(i);
for (int i = (0); i < (n); i++) {
if (((long long int)(mem[i]).size()) == 1) continue;
if (!f(i)) {
cout << "NO";
return 0;
}
}
cout << "YES" << endl;
for (int i = (0); i < (n); i++) cout << ans[i] << "\n";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int openwindows = 0;
for (int i = 0; i < (n); i++) {
for (int j = 0; j < (m); j++) {
int x, y;
cin >> x >> y;
if (x or y) openwindows++;
}
}
cout << openwindows << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, b[309], bst[1009], sol[309][2009];
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", &b[i]);
sol[0][0] = 1;
for (int i = 1; i <= N; i++) {
bool ok = 1;
for (int j = 0; j <= sol[i - 1][0]; j++) {
sol[i][j] = sol[i - 1][j];
if (sol[i][j] != 9 && j != 0) ok = 0;
}
if (ok) {
sol[i][0]++;
for (int j = 1; j <= sol[i][0]; j++) sol[i][j] = (j == 1);
} else {
sol[i][sol[i][0]]++;
int j = sol[i][0];
while (sol[i][j] == 10) sol[i][j--] = 0, sol[i][j]++;
}
int L = b[i] / 9;
if (b[i] % 9 != 0) L++;
if (L > sol[i][0]) {
sol[i][0] = L;
for (int j = 2; j <= L; j++) sol[i][j] = 9;
if (b[i] % 9)
sol[i][1] = b[i] % 9;
else
sol[i][1] = 9;
continue;
}
int sum = b[i];
for (int j = 1; j <= sol[i][0]; j++) {
if (sum <= 9)
bst[j] = sum, sum = 0;
else
bst[j] = 9, sum -= 9;
}
ok = 1;
for (int j = 1; j <= sol[i][0]; j++)
if (bst[j] != sol[i][j]) {
if (bst[j] < sol[i][j]) ok = 0;
break;
}
if (ok) {
int S = 0;
for (int j = 1; j <= sol[i][0]; j++) S += sol[i][j];
if (S == b[i]) continue;
S = 0;
int last_cor_pref = 0;
for (int j = 1; j <= sol[i][0]; j++) {
if (S + sol[i][j] + 1 <= b[i] && S + 9 * (sol[i][0] - j + 1) >= b[i] &&
sol[i][j] < 9)
last_cor_pref = j - 1;
S += sol[i][j];
}
int sum = b[i];
for (int j = 1; j <= last_cor_pref; j++) sum -= sol[i][j];
for (int v = sol[i][last_cor_pref + 1] + 1; v < 10; v++)
if (v + 9 * (sol[i][0] - last_cor_pref - 1) >= sum) {
sum -= v;
sol[i][last_cor_pref + 1] = v;
break;
}
for (int j = sol[i][0]; j > last_cor_pref + 1; j--) {
if (sum <= 9)
sol[i][j] = sum, sum = 0;
else
sol[i][j] = 9, sum -= 9;
}
continue;
}
sol[i][0]++;
sol[i][1] = 1;
sum = b[i] - 1;
for (int j = sol[i][0]; j >= 2; j--) {
if (sum <= 9)
sol[i][j] = sum, sum = 0;
else
sol[i][j] = 9, sum -= 9;
}
}
for (int i = 1; i <= N; i++, printf("\n"))
for (int j = 1; j <= sol[i][0]; j++) printf("%d", sol[i][j]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f2f1f0f;
const long long LINF = 1ll * INF * INF;
int main() {
int Q;
cin >> Q;
while (Q--) {
int n;
scanf("%d", &n);
if (n % 4 == 0)
printf("%d\n", n / 4);
else if (n % 4 == 1) {
if (n < 9)
printf("-1\n");
else
printf("%d\n", n / 4 - 1);
} else if (n % 4 == 2) {
if (n < 6)
printf("-1\n");
else
printf("%d\n", n / 4);
} else if (n % 4 == 3) {
if (n < 15)
printf("-1\n");
else
printf("%d\n", n / 4 - 1);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m, v;
vector<int> boys;
vector<int> girls;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> v;
boys.push_back(v);
}
sort(boys.begin(), boys.end());
cin >> m;
for (int i = 0; i < m; i++) {
cin >> v;
girls.push_back(v);
}
sort(girls.begin(), girls.end());
int matches = 0;
int j = 0;
for (int i = 0; i < n; i++) {
while (girls[j] < boys[i] - 1) {
j++;
}
if (abs(girls[j] - boys[i]) <= 1) {
j++;
matches++;
}
}
cout << matches << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int A[300005];
int P[300005];
struct data {
bool endmark;
data* next[5];
int tot[5];
data() {
for (int i = 0; i < 2; i++) {
next[i] = NULL;
tot[i] = 0;
}
endmark = false;
}
} * root;
void INSERT(int val) {
data* now = root;
for (int i = 30; i >= 0; i--) {
int bt = (bool)(val & (1 << i));
if (now->next[bt] == NULL) {
now->next[bt] = new data();
}
now->tot[bt]++;
now = now->next[bt];
}
now->endmark = true;
}
int SEARCH(int val) {
data* now = root;
int tot = 0;
for (int i = 30; i >= 0; i--) {
int bt = (val & (1 << i));
if (bt == 0) {
if (now->next[0] != NULL && now->tot[0] > 0) {
now->tot[0]--;
now = now->next[0];
} else {
tot = tot | (1 << i);
now = now->next[1];
}
} else {
if (now->next[1] != NULL && now->tot[1] > 0) {
now->tot[1]--;
now = now->next[1];
} else {
tot = tot | (1 << i);
now = now->next[0];
}
}
}
return tot;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", A + i);
}
root = new data();
for (int i = 1; i <= n; i++) {
scanf("%d", P + i);
INSERT(P[i]);
}
for (int i = 1; i <= n; i++) {
printf("%d ", SEARCH(A[i]));
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2020;
char all[MAX][MAX];
bool safe[MAX][MAX];
int n, m;
int dx[8] = {0, -1, -1, -1, 0, 1, 1, 1};
int dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int ma(int x, int y) {
int an = 0;
for (int i = 0; i < 8; i += 2) {
int tmp = 0;
for (int j = 0; j < 3; ++j) {
tmp += (all[x + dx[(i + j) % 8]][y + dy[(i + j) % 8]] == '.');
}
an = max(an, tmp);
}
return an;
}
int main(int argc, char const *argv[]) {
memset(all, '*', sizeof all);
memset(safe, 1, sizeof safe);
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
char si[m];
scanf("%s", si);
for (int j = 1; j <= m; ++j) all[i][j] = si[j - 1];
}
queue<pair<int, int> > bf;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
safe[i][j] = 0;
if (all[i][j] == '*' && ma(i, j) == 3)
bf.push(make_pair(i, j)), safe[i][j] = 1;
}
}
while (!bf.empty()) {
pair<int, int> s = bf.front();
bf.pop();
int x = s.first, y = s.second;
all[x][y] = '.';
for (int i = 0; i < 8; ++i) {
if (safe[x + dx[i]][y + dy[i]]) continue;
if (all[x + dx[i]][y + dy[i]] == '*' && ma(x + dx[i], y + dy[i]) == 3) {
bf.push(make_pair(x + dx[i], y + dy[i]));
safe[x + dx[i]][y + dy[i]] = 1;
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
printf("%c", all[i][j]);
}
printf("\n");
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, r, a;
cin >> l >> r >> a;
while (a--) l <= r ? l++ : r++;
cout << 2 * min(l, r) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
int _MAX(int a, int b) { return a > b ? a : b; }
int _MIN(int a, int b) { return a > b ? b : a; }
int Scan() {
int res = 0, flag = 0;
char ch;
if ((ch = getchar()) == '-')
flag = 1;
else if (ch >= '0' && ch <= '9')
res = ch - '0';
while ((ch = getchar()) >= '0' && ch <= '9') res = res * 10 + (ch - '0');
return flag ? -res : res;
}
void Out(int a) {
if (a < 0) {
putchar('-');
a = -a;
}
if (a >= 10) Out(a / 10);
putchar(a % 10 + '0');
}
const int N = 105;
int a[N], ans[N][2], tot = 0;
int main() {
int n, cnt = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
if (a[i] == 0) cnt++;
}
if (cnt == n) {
puts("NO");
return 0;
} else {
int q = 0;
for (int i = 1; i <= n; ++i) {
if (a[i]) {
int p = i;
for (int j = i - 1; j > q; --j) {
if (a[j] == 0)
p = j;
else
break;
}
ans[i][0] = p;
p = i;
for (int j = i + 1; j <= n; ++j) {
if (a[j] == 0)
p = j;
else
break;
}
ans[i][1] = p;
q = p;
}
}
}
printf("YES\n%d\n", n - cnt);
for (int i = 1; i <= n; ++i) {
if (a[i]) printf("%d %d\n", ans[i][0], ans[i][1]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int t, n, k;
string s1, s;
char c[200010];
int main() {
cin >> n >> k;
s = "v";
string a;
cin >> s1;
s += s1;
a = s;
int len = n - k;
for (int i = 1; i <= len; i++) {
a[i + k] = a[i];
}
while (a < s) {
if (a[k] < '9')
a[k]++;
else {
int f = k;
while (a[f] == '9' && f > 1) --f;
a[f]++;
for (int i = f + 1; i <= k; i++) a[i] = '0';
for (int i = 1; i <= len; i++) a[i + k] = a[i];
}
for (int i = 1; i <= len; i++) a[i + k] = a[i];
}
cout << n << endl;
a.erase(0, 1);
cout << a << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
vector<long long int> v;
long long int i = 5;
while (i <= 1000000000) {
v.push_back(i);
i *= 2;
}
int k = 0;
while (n > 0) {
n -= v[k];
k++;
}
k--;
n += v[k];
long long int x = v[k];
x = x / 5;
int op = ceil((double)n / x);
if (op == 1) {
cout << "Sheldon";
} else if (op == 2) {
cout << "Leonard";
} else if (op == 3) {
cout << "Penny";
} else if (op == 4) {
cout << "Rajesh";
} else {
cout << "Howard";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int oo = 0x3f3f3f3f;
const int Mod = 1e9 + 7;
const int maxn = 500;
struct data {
int cnt[65536];
data() { memset(cnt, 0, sizeof cnt); }
friend data operator+(const data &first, const data &second) {
data ans;
for (int i = (0), _end_ = (65536); i < _end_; ++i)
ans.cnt[i] = (first.cnt[i] + second.cnt[i]) % Mod;
return ans;
}
};
data I[256];
int n;
char s[maxn + 5];
data combine(const data &first, const data &second, const char &ty) {
data ans;
vector<int> A, B;
for (int i = (0), _end_ = (65536); i < _end_; ++i)
if (first.cnt[i]) A.push_back(i);
for (int i = (0), _end_ = (65536); i < _end_; ++i)
if (second.cnt[i]) B.push_back(i);
if ((long long)(int((A).size())) * (int((B).size())) <= 16 * 65536) {
for (auto u : A)
for (auto v : B)
(ans.cnt[(ty == '|' ? (u | v) : (u & v))] +=
(long long)first.cnt[u] * second.cnt[v] % Mod) %= Mod;
}
static int a[65537], b[65537], c[65537];
for (int i = (0), _end_ = (65536); i < _end_; ++i) a[i] = first.cnt[i];
for (int i = (0), _end_ = (65536); i < _end_; ++i) b[i] = second.cnt[i];
for (int i = (0), _end_ = (16); i < _end_; ++i)
for (int j = (0), _end_ = (65536); j < _end_; ++j) {
if ((j >> i & 1) ^ (ty == '|')) {
(a[j ^ (1 << i)] += a[j]) %= Mod;
(b[j ^ (1 << i)] += b[j]) %= Mod;
}
}
for (int i = (0), _end_ = (65536); i < _end_; ++i)
c[i] = (long long)a[i] * b[i] % Mod;
for (int i = (0), _end_ = (16); i < _end_; ++i)
for (int j = (0), _end_ = (65536); j < _end_; ++j) {
if ((j >> i & 1) ^ (ty == '|')) {
(c[j ^ (1 << i)] -= c[j]) %= Mod;
}
}
for (int i = (0), _end_ = (65536); i < _end_; ++i) ans.cnt[i] = c[i];
return ans;
}
inline data work(const int &l, const int &r) {
int now = 1;
data ret;
bool flag = 0;
for (int i = l; i < r; ++i) {
if (!now) {
if (s[i] != '?' && s[i] != '&' && s[i] != '|') return data();
flag = 1;
} else {
data lyc;
int st = i;
if (s[i] == '(') {
if (!now) return data();
int tmp = 0;
while (i < r) {
if (s[i] == '(')
++tmp;
else if (s[i] == ')')
--tmp;
if (!tmp) break;
++i;
}
lyc = work(st + 1, i);
} else
lyc = I[(int)s[i]];
if (!flag)
ret = lyc;
else {
if (s[st - 1] != '?')
ret = combine(ret, lyc, s[st - 1]);
else
ret = combine(ret, lyc, '|') + combine(ret, lyc, '&');
}
}
now = !now;
}
if (now) return data();
return ret;
}
int main() {
scanf("%s", s);
n = strlen(s);
static int val[256] = {0};
for (int i = 15; i >= 0; --i) {
for (int j = (0), _end_ = (256); j < _end_; ++j) val[j] <<= 1;
val['A'] |= (i & 1);
val['a'] |= !(i & 1);
val['B'] |= (i >> 1 & 1);
val['b'] |= !(i >> 1 & 1);
val['C'] |= (i >> 2 & 1);
val['c'] |= !(i >> 2 & 1);
val['D'] |= (i >> 3 & 1);
val['d'] |= !(i >> 3 & 1);
}
I['A'].cnt[val['A']] = 1;
I['a'].cnt[val['a']] = 1;
I['B'].cnt[val['B']] = 1;
I['b'].cnt[val['b']] = 1;
I['C'].cnt[val['C']] = 1;
I['c'].cnt[val['c']] = 1;
I['D'].cnt[val['D']] = 1;
I['d'].cnt[val['d']] = 1;
I['?'] =
I['A'] + I['a'] + I['B'] + I['b'] + I['C'] + I['c'] + I['D'] + I['d'];
data tmp = work(0, n);
int m;
vector<pair<int, int> > all;
scanf("%d", &m);
for (int i = (0), _end_ = (m); i < _end_; ++i) {
int a, b, c, d, e;
scanf("%d%d%d%d%d", &a, &b, &c, &d, &e);
all.push_back(make_pair(a | (b << 1) | (c << 2) | (d << 3), e));
}
int ret = 0;
for (int i = (0), _end_ = (65536); i < _end_; ++i) {
bool flag = 1;
for (auto it : all)
if ((i >> it.first & 1) != it.second) {
flag = 0;
break;
}
if (flag) (ret += tmp.cnt[i]) %= Mod;
}
(ret += Mod) %= Mod;
printf("%d\n", ret);
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int a[500100];
int b[500100];
set<pair<int, int>> s;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", a + i);
sort(a, a + n);
for (int i = 0; i < n; i++) {
s.insert({a[i], i});
}
int ans = n;
for (int i = 0; i < n; i++) {
auto itr = s.lower_bound({2 * a[i], 0});
if (itr != s.end()) {
if (b[i] == 0) {
int x = itr->first, y = itr->second;
b[y] = a[i];
ans--;
s.erase(itr);
} else {
auto itr2 = s.lower_bound({2 * b[i], -1});
if (itr2 == s.end()) break;
int x = itr2->first, y = itr2->second;
b[y] = b[i];
b[i] = 0;
s.erase(itr2);
i--;
}
} else {
break;
}
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int sup(int c, int n) {
int x = 0;
for (int i = 0; i < n; i++) {
if (a[i] > c) ++x;
}
return x;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int f;
cin >> f;
a.push_back(f);
}
for (int i = 0; i < n; i++) cout << 1 + sup(a[i], n) << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int maxDiff(int arr[], int arr_size) {
int max_diff = arr[0] - arr[1];
int max_element = arr[0];
for (int i = 1; i < arr_size; ++i) {
if (max_element - arr[i] > max_diff) max_diff = max_element - arr[i];
if (arr[i] > max_element) max_element = arr[i];
}
return max_diff;
}
int a[100000];
void doIt() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
if (n == 1) {
cout << "0" << endl;
return;
}
int k = maxDiff(a, n);
if (k < 1) {
cout << "0" << endl;
} else {
cout << 1 + floor(log2(k)) << endl;
}
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
doIt();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
namespace SA {
char s[100005];
int n, lcp[200005], cnt[200005], vy[200005], rk[200005], tmp[200005],
ls[200005];
void bsort() {
int i;
memset(cnt, 0, sizeof(cnt));
for (i = 0; i < n; ++i) ++cnt[vy[i]];
for (i = 1; i <= n + 3 || i <= 30; ++i) cnt[i] += cnt[i - 1];
for (i = n - 1; i >= 0; --i) tmp[--cnt[vy[i]]] = i;
memset(cnt, 0, sizeof(cnt));
for (i = 0; i < n; ++i) ++cnt[rk[tmp[i]]];
for (i = 1; i <= n + 3 || i <= 30; ++i) cnt[i] += cnt[i - 1];
for (i = n - 1; i >= 0; --i) ls[--cnt[rk[tmp[i]]]] = tmp[i];
memset(tmp, 0, sizeof(tmp));
}
void getsa() {
int i, j, cv;
memset(rk, 0, sizeof(rk));
memset(vy, 0, sizeof(vy));
for (i = 0; i < n; ++i) {
rk[i] = s[i] - 'a' + 1;
}
for (i = 2; i <= n * 2; i <<= 1) {
for (j = 0; j < n; ++j) {
vy[j] = rk[j + (i >> 1)];
}
bsort();
cv = 1;
for (j = 0; j < n; ++j) {
if (j && (rk[ls[j - 1]] != rk[ls[j]] || vy[ls[j - 1]] != vy[ls[j]])) ++cv;
tmp[ls[j]] = cv;
}
memcpy(rk, tmp, sizeof(tmp));
}
}
void getlcp() {
int i, j, lv = 0;
for (i = 0; i < n; ++i) {
if (rk[i] == 1) continue;
int la = ls[rk[i] - 2];
for (j = max(0, lv - 2); la + j < n && i + j < n; ++j) {
if (s[la + j] != s[i + j]) break;
}
lcp[i] = lv = j;
}
}
}; // namespace SA
char s[100005], t[100005];
int ls, lt, app[100005], nx[100005];
int main() {
int i, j, k;
scanf("%s", s);
scanf("%s", t);
ls = strlen(s);
lt = strlen(t);
SA::n = ls;
memcpy(SA::s, s, sizeof(s));
SA::getsa();
SA::getlcp();
int lb = 0, rb = ls - 1, zp = -1;
for (i = 0; i < ls; ++i) {
if (SA::ls[i] == 0) zp = i;
}
for (i = 0; i < lt; ++i) {
while (lb <= rb) {
if (ls - SA::ls[lb] >= i + 1 && s[SA::ls[lb] + i] == t[i]) break;
++lb;
}
while (lb <= rb) {
if (ls - SA::ls[rb] >= i + 1 && s[SA::ls[rb] + i] == t[i]) break;
--rb;
}
if (lb > rb) break;
app[i] = rb - lb + 1;
if (rb >= zp && lb <= zp) --app[i];
}
j = 0;
for (i = 1; i < lt; ++i) {
while (j && t[j] != t[i]) j = nx[j - 1];
if (t[j] == t[i]) nx[i] = ++j;
}
long long res = (long long)ls * (long long)lt;
for (i = 0; i < lt; ++i) {
if (nx[i]) {
res -= (long long)app[i - nx[i]];
}
}
printf("%I64d\n", res);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
long k, n;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
}
if (sum % k != 0)
cout << "No" << endl;
else {
long j = 0;
long x = 0;
long cnt[100005] = {0};
long l = 0;
int flag = 1;
while (j < n) {
if (x < sum / k) {
x += a[j];
if (x > sum / k) {
cout << "No" << endl;
flag = 0;
break;
}
j++;
cnt[l]++;
continue;
}
l++;
x = 0;
}
if (flag) {
cout << "Yes" << endl;
for (int i = 0; i < k; i++) {
cout << cnt[i] << " ";
}
cout << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
map<int, int> a;
int aux = 0;
for (int i = 0; i < int(n); i++) {
int v;
cin >> v;
a[v]++;
aux = max(aux, a[v]);
}
cout << n - aux << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int gg = 3;
const int maxn = 2520210;
int mp[maxn], a[maxn], f[maxn];
int n, m;
int ord[maxn];
int fast_pow(int now, int p) {
if (p == 0) return 1;
if (p == 1) return now;
int z = fast_pow(now, p / 2);
z = (1ll * z * z) % mod;
if (p & 1) {
z = (1ll * z * now) % mod;
}
return z;
}
void fft(int *d, int len, int kind) {
for (int i = 0; i < len; i++)
if (ord[i] > i) swap(d[i], d[ord[i]]);
for (int i = 1; i < len; i <<= 1) {
int wn = fast_pow(gg, (mod - 1) / (i << 1));
if (kind == -1) wn = fast_pow(wn, mod - 2);
for (int j = 0; j < len; j += (i << 1)) {
int w = 1;
for (int k = 0; k < i; k++, w = (1ll * w * wn) % mod) {
long long x = d[j + k], y = (1ll * w * d[j + k + i]) % mod;
d[j + k] = (x + y) % mod;
d[j + k + i] = (x - y + mod) % mod;
}
}
}
if (kind == -1) {
int inv = fast_pow(len, mod - 2);
for (int i = 0; i < len; i++) d[i] = (1ll * d[i] * inv) % mod;
}
}
void read() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), mp[a[i]] = f[a[i]] = 1;
}
void work() {
int bit = 0, len = 1;
while (len < m * 2) bit++, len <<= 1;
for (int i = 1; i < len; i++)
ord[i] = (ord[i >> 1] >> 1) + ((i & 1) << bit - 1);
fft(f, len, 1);
for (int i = 0; i < len; i++) f[i] = (1ll * f[i] * f[i]) % mod;
fft(f, len, -1);
int ans = 0;
for (int i = 0; i <= m; i++) {
if (f[i] && mp[i]) {
mp[i] = 0;
continue;
}
if (f[i]) {
puts("NO");
return;
}
if (mp[i]) ans++;
}
puts("YES");
printf("%d\n", ans);
for (int i = 0; i <= m; i++)
if (mp[i]) printf("%d ", i);
}
int main() {
read();
work();
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
inline int Gcd(int X, int Y) { return Y ? Gcd(Y, X % Y) : X; }
inline long long Gcd(long long X, long long Y) { return Y ? Gcd(Y, X % Y) : X; }
inline int Max(int X, int Y) { return X < Y ? Y : X; }
inline int Min(int X, int Y) { return X < Y ? X : Y; }
inline long long Max(long long X, long long Y) { return X < Y ? Y : X; }
inline long long Min(long long X, long long Y) { return X < Y ? X : Y; }
inline int Pow(int base, long long exp, int _mod) {
int _ans = 1;
for (; exp; exp >>= 1, base = (long long)base * base % _mod)
exp& 1 ? _ans = (long long)_ans * base % _mod : 0;
return _ans;
}
inline long long Pow(long long base, long long exp, long long _mod) {
long long _ans = 1;
for (; exp; exp >>= 1, base = base * base % _mod)
exp& 1 ? _ans = _ans * base % _mod : 0;
return _ans;
}
int n, k, v;
int a[5001], b[5001], sum, s2;
int f[5001][5001];
int Ans[5001];
int main() {
scanf("%d%d%d", &n, &k, &v);
for (int i = (1); i <= (n); ++i)
scanf("%d", a + i), sum += a[i], b[i] = a[i], a[i] %= k;
if (sum < v) {
puts("NO");
return 0;
}
f[0][0] = 1;
for (int i = (1); i <= (n); ++i) {
for (int j = (0); j < (k); ++j) {
if (f[i - 1][j]) {
f[i][j] = 1;
if (j + a[i] < k)
f[i][j + a[i]] = 2;
else
f[i][j + a[i] - k] = 2;
}
}
}
if (f[n][v % k] == 0)
puts("NO");
else {
puts("YES");
int now = v % k;
int u = -1, unu = -1;
for (int i = (n); i >= (1); --i) {
if (f[i][now] == 2) Ans[i] = 1, now = (now - a[i] + k) % k;
}
for (int i = (1); i <= (n); ++i)
if (!Ans[i])
unu = i;
else
u = i;
if (u == -1) {
for (int i = (2); i <= (n); ++i)
if (b[i] > 0) printf("%d %d 1\n", (b[i] - 1) / k + 1, i);
if (v > 0) printf("%d 1 2\n", v / k);
} else if (unu == -1) {
for (int i = (2); i <= (n); ++i)
if (b[i] > 0) printf("%d %d 1\n", (b[i] - 1) / k + 1, i);
if (sum - v > 0) printf("%d 1 2\n", (sum - v) / k);
} else {
int s1 = b[u], s2 = b[unu];
for (int i = (1); i <= (n); ++i) {
if (Ans[i] == 1 && i != u && b[i] > 0)
printf("%d %d %d\n", (b[i] - 1) / k + 1, i, u), s1 += b[i];
if (Ans[i] == 0 && i != unu && b[i] > 0)
printf("%d %d %d\n", (b[i] - 1) / k + 1, i, unu), s2 += b[i];
}
if (s2 >= k) printf("%d %d %d\n", s2 / k, unu, u);
s1 += s2 / k * k;
if (s1 - v >= k) printf("%d %d %d\n", (s1 - v) / k, u, unu);
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long ispalindrome(string ss) {
long long n = ss.size();
for (long long i = 0; i < (n + 1) / 2; i++) {
if (ss[i] != ss[n - i - 1]) return 0;
}
return 1;
}
long long mod = 1e14 + 7;
long long ksm(long long a, long long b) {
long long S = 1;
while (b) {
if (b & 1) S = S * a % mod;
b >>= 1;
a = a * a % mod;
}
return S;
}
long long digit(long long n) {
long long res = 0;
while (n) {
res++;
n = n / 10;
}
return res;
}
long long fact(long long n) {
long long ans = 1;
for (long long i = 1; i < n + 1; i++) ans = (ans * i) % mod;
return ans;
}
vector<long long> arr[110];
void addedge(long long a, long long b) {
arr[a].push_back(b);
arr[b].push_back(a);
}
long long vis[100], cc;
void dfs(long long node) {
vis[node] = 1;
cc++;
for (int child : arr[node]) {
if (vis[child] == 0) {
dfs(child);
}
}
}
void solve() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
addedge(a, b);
}
for (long long i = 0; i < 101; i++) {
vis[i] = 0;
}
long long c = 0;
for (long long i = 1; i < n + 1; i++) {
cc = 0;
if (vis[i] == 0) {
dfs(i);
if (cc > 1) c++;
if (cc > 3) {
cout << -1;
return;
}
}
}
if (c > n / 3) {
cout << -1;
return;
}
vector<long long> st;
for (long long i = 1; i < n + 1; i++) {
if (arr[i].size() == 0) {
st.push_back(i);
}
}
map<long long, long long> mp;
mp.clear();
for (long long i = 1; i < n + 1; i++) {
if (arr[i].size() == 2 && mp[i] == 0) {
cout << i << " " << arr[i][0] << " " << arr[i][1] << endl;
mp[i] = 1;
mp[arr[i][0]] = 1;
mp[arr[i][1]] = 1;
}
if (arr[i].size() == 1 && mp[i] == 0) {
cout << i << " " << arr[i][0] << " ";
mp[i] = 1;
mp[arr[i][0]] = 1;
long long pp = 0;
if (arr[arr[i][0]].size() > 1) {
for (long long k = 0; k < arr[arr[i][0]].size(); k++) {
if (mp[arr[arr[i][0]][k]] == 0) {
cout << arr[arr[i][0]][k] << endl;
mp[arr[arr[i][0]][k]] = 1;
pp = 1;
break;
}
}
}
if (pp == 0) {
cout << st[st.size() - 1] << endl;
mp[st[st.size() - 1]] = 1;
st.pop_back();
}
}
}
for (long long i = 0; i < st.size(); i += 3) {
cout << st[i] << " " << st[i + 1] << " " << st[i + 2] << endl;
}
}
int main() {
long long t;
t = 1;
while (t--) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
const int N = 1e6 + 10;
const int M = 1 << 21;
const long long mod = 1e9 + 7;
const double PI = acos(-1);
int v[N];
int node[N << 2];
int gg[N];
void add(int v, int x, int l, int r, int o) {
node[o]++;
if (l == r) {
gg[l] = x;
return;
}
int mid = (l + r) >> 1;
if (v <= mid)
add(v, x, l, mid, o << 1);
else
add(v, x, mid + 1, r, o << 1 | 1);
}
void dd(int v, int l, int r, int o) {
node[o]--;
if (l == r) {
gg[l] = -1;
return;
}
int mid = (l + r) >> 1;
if (v <= node[o << 1])
dd(v, l, mid, o << 1);
else
dd(v - node[o << 1], mid + 1, r, o << 1 | 1);
}
int main() {
int n, m;
scanf("%d%d\n", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d", &v[i]);
v[i] -= i;
}
int tot = 0, op;
for (int i = 1; i <= n; ++i) {
scanf("%d", &op);
if (op != -1) {
add(++tot, op, 1, n, 1);
} else {
for (int j = 0; j < m; ++j) {
if (v[j] > node[1]) break;
dd(v[j], 1, n, 1);
}
}
}
if (node[1] == 0) {
puts("Poor stack!");
return 0;
}
for (int i = 1; i <= tot; ++i) {
if (gg[i] == -1)
continue;
else
printf("%c", '0' + gg[i]);
}
puts("");
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 10;
unordered_map<string, int> tok;
map<tuple<int, char, int>, int> op;
struct node {
string nem;
tuple<int, char, int> dep;
bool leaf;
} T[4 * N];
bool seen[4 * N];
int lcnt;
ostringstream os;
void dfs(int at) {
if (seen[at] || T[at].leaf) return;
seen[at] = 1;
int l, r;
char o;
tie(l, o, r) = T[at].dep;
dfs(l);
dfs(r);
lcnt++;
os << T[at].nem << '=' << T[l].nem << o << T[r].nem << '\n';
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
int tokcnt = 1;
tok["res"] = 0;
T[0].nem = "res";
T[0].leaf = 1;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int d1 = s.find('=');
int d2 = s.find_first_of("&^#$");
if (d2 == string::npos) {
string rhS = s.substr(d1 + 1);
int rhs;
if (tok.count(rhS))
rhs = tok[rhS];
else {
rhs = tok[rhS] = tokcnt++;
T[rhs].nem = rhS;
T[rhs].leaf = 1;
}
string lhS = s.substr(0, d1);
tok[lhS] = rhs;
} else {
string s1 = s.substr(d1 + 1, d2 - d1 - 1);
string s2 = s.substr(d2 + 1);
int i1, i2;
if (tok.count(s1))
i1 = tok[s1];
else {
i1 = tok[s1] = tokcnt++;
T[i1].nem = s1;
T[i1].leaf = 1;
}
if (tok.count(s2))
i2 = tok[s2];
else {
i2 = tok[s2] = tokcnt++;
T[i2].nem = s2;
T[i2].leaf = 1;
}
tuple<int, char, int> o = {i1, s[d2], i2};
int rhs;
if (op.count(o))
rhs = op[o];
else {
rhs = op[o] = tokcnt++;
T[rhs].dep = o;
T[rhs].leaf = 0;
}
string lhS = s.substr(0, d1);
tok[lhS] = rhs;
}
}
{
char c1 = 'a';
int cat = 100;
for (int i = 0; i < tokcnt; i++) {
if (T[i].nem.size()) continue;
while (1) {
string s = string(1, c1) + to_string(cat);
if (++cat > 999) {
c1++;
cat = 100;
}
if (!tok.count(s)) {
T[i].nem = s;
break;
}
}
}
}
int root = tok["res"];
if (T[root].leaf) {
if (T[root].nem == "res")
cout << "0\n";
else
cout << "1\nres=" << T[root].nem << '\n';
return 0;
}
T[root].nem = "res";
dfs(root);
cout << lcnt << '\n' << os.str();
}
| 19 |
#include <bits/stdc++.h>
int get() {
int x = 0;
char s = getchar();
while (s < '0' || s > '9') s = getchar();
while (s >= '0' && s <= '9')
x = (x << 3) + (x << 1) + (s ^ 48), s = getchar();
return x;
}
int has(const char c) {
if (c == 'A') return 0;
if (c == 'T') return 1;
if (c == 'G') return 2;
return 3;
}
const int M = 1e5 + 5;
int n, f[11][4][M];
char s[M], tmp[15];
int lowbit(const int x) { return x & -x; }
void modify(const int m, const int t, const int i, const int k) {
int p = i / m + 1, q = i % m;
for (; (p - 1) * m + q <= n; p += lowbit(p)) f[m][t][(p - 1) * m + q] += k;
}
int query(const int m, const int t, const int i) {
int res = 0, p = i / m + 1, q = i % m;
for (; p; p -= lowbit(p)) res += f[m][t][(p - 1) * m + q];
return res;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) {
s[i] = has(s[i]);
for (int j = 1; j < 11; ++j) modify(j, s[i], i, 1);
}
for (int q = get(), op, x, l, r; q--;) {
op = get();
if (op < 2) {
x = get();
scanf("%s", tmp);
tmp[0] = has(tmp[0]);
for (int i = 1; i < 11; ++i) {
modify(i, tmp[0], x, 1);
modify(i, s[x], x, -1);
}
s[x] = tmp[0];
} else {
l = get(), r = get();
scanf("%s", tmp);
int m = strlen(tmp), ans = 0;
for (int i = 0; i < m; ++i) {
tmp[i] = has(tmp[i]);
x = l + i - m;
if (x > 0) ans -= query(m, tmp[i], x);
x = r / m * m + (l + i) % m;
if (x > r) x -= m;
if (x > 0) ans += query(m, tmp[i], x);
}
printf("%d\n", ans);
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
inline void in(long long &now) {
char Cget = getchar();
now = 0;
while (Cget > '9' || Cget < '0') Cget = getchar();
while (Cget >= '0' && Cget <= '9') {
now = now * 10 + Cget - '0';
Cget = getchar();
}
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
long long t, x, y, p, q;
in(t);
for (; t--;) {
in(x), in(y), in(p), in(q);
p /= gcd(p, q), q /= gcd(p, q);
if (q == p) {
if (x != y) {
printf("-1\n");
continue;
}
}
if (p == 0) {
if (x != 0) {
printf("-1\n");
continue;
}
}
long long pos = (q - y % q) % q;
double ki = (double)p / (double)q, li, ri;
long long l = 0, r = 1000000000, ans;
while (l <= r) {
int mid = l + r >> 1;
li = (double)x / (double)(y + pos + (mid * q));
ri = (double)(x + pos + mid * q) / (double)(y + pos + mid * q);
if (ki >= li && ki <= ri)
ans = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%lld\n", pos + ans * q);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int dig[20];
const int M = 262145;
long long dp[262145][101];
int m;
int pos;
long long dfs(int state, int x) {
long long ans = 0;
if (state == (1 << pos) - 1) return x == 0;
long long &dpAns = dp[state][x];
if (dpAns != -1) return dpAns;
int vis[10] = {0};
for (int i = pos - 1; i >= 0; i--) {
if ((1 << i) & state) continue;
if (vis[dig[i]]) continue;
vis[dig[i]] = 1;
ans += dfs(state | 1 << i, (x * 10 + dig[i]) % m);
}
dpAns = ans;
return ans;
}
long long solve(long long n) {
pos = 0;
while (n) {
dig[pos++] = n % 10;
n /= 10;
}
long long ans = 0;
int vis[10] = {0};
for (int i = pos - 1; i >= 0; i--)
if (dig[i] && !vis[dig[i]]) {
vis[dig[i]] = 1;
ans += dfs(1 << i, dig[i] % m);
}
return ans;
}
int main(void) {
long long a;
while (cin >> a >> m) {
memset(dp, -1, sizeof(dp));
cout << solve(a) << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n;
vector<int> vis(n, 0);
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
vis[x - 1]++;
vis[y - 1]++;
}
int flag = 0;
for (int i = 0; i < n; i++) {
if (vis[i] == 2) {
flag = 1;
break;
}
}
if (flag)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string f(char c) {
switch (toupper(c)) {
case '0':
return "0000";
case '1':
return "0001";
case '2':
return "0010";
case '3':
return "0011";
case '4':
return "0100";
case '5':
return "0101";
case '6':
return "0110";
case '7':
return "0111";
case '8':
return "1000";
case '9':
return "1001";
case 'A':
return "1010";
case 'B':
return "1011";
case 'C':
return "1100";
case 'D':
return "1101";
case 'E':
return "1110";
case 'F':
return "1111";
}
}
string f1(string c) {
if (c == "0000") return "0";
if (c == "0001") return "1";
if (c == "0010") return "2";
if (c == "0011") return "3";
if (c == "0100") return "4";
if (c == "0101") return "5";
if (c == "0110") return "6";
if (c == "0111") return "7";
if (c == "1000") return "8";
if (c == "1001") return "9";
if (c == "1010") return "A";
if (c == "1011") return "B";
if (c == "1100") return "C";
if (c == "1101") return "D";
if (c == "1110") return "E";
if (c == "1111") return "F";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
vector<string> v1(n);
for (long long i = 0; i < n; i++) cin >> v1[i];
vector<string> v2;
for (long long i = 0; i < n / 4; i++) {
vector<string> w;
for (long long j = 0; j < n; j++) {
w.push_back(f(v1[j][i]));
}
for (long long j = 0; j < 4; j++) {
string val;
for (long long k = 0; k < n; k += 4) {
string tmp;
for (long long a = k; a < k + 4; a++) tmp += w[a].substr(j, 1);
val += f1(tmp);
}
v2.push_back(val);
}
}
vector<long long> div;
long long ans = 1;
for (long long i = 1; i <= n; i++) {
if (n % i == 0) {
long long check1 = 0, check2 = 0;
for (long long j = 0; j < n; j += i) {
long long flag = 0;
for (long long k = j + 1; k < j + i; k++) {
if (v1[k] != v1[j]) {
flag = 1;
break;
}
}
if (flag == 1) {
check1 = 1;
break;
}
}
for (long long j = 0; j < n; j += i) {
long long flag = 0;
for (long long k = j + 1; k < j + i; k++) {
if (v2[k] != v2[j]) {
flag = 1;
break;
}
}
if (flag == 1) {
check2 = 1;
break;
}
}
if (check1 == 0 && check2 == 0) {
ans = i;
}
}
}
cout << ans;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 100;
int n, m, p;
int xx[N], yy[N];
int dp1[2][N], dp2[2][N];
int fun(int i, int j) { return (xx[i] + yy[j]) % p; }
void getdp1(int a, int b, int c, int d, int dp[2][N]) {
for (int i = a; i <= c; i++) {
int x = i % 2;
for (int j = b; j <= d; j++) {
if (i > a && j > b) {
dp[x][j] = max(dp[x ^ 1][j], dp[x][j - 1]) + fun(i, j);
} else if (i > a) {
dp[x][j] = dp[x ^ 1][j] + fun(i, j);
} else if (j > b) {
dp[x][j] = dp[x][j - 1] + fun(i, j);
} else
dp[x][j] = fun(i, j);
}
}
}
void getdp2(int a, int b, int c, int d, int dp[2][N]) {
for (int i = c; i >= a; i--) {
int x = i % 2;
for (int j = d; j >= b; j--) {
if (i < c && j < d) {
dp[x][j] = max(dp[x ^ 1][j], dp[x][j + 1]) + fun(i, j);
} else if (i < c) {
dp[x][j] = dp[x ^ 1][j] + fun(i, j);
} else if (j < d) {
dp[x][j] = dp[x][j + 1] + fun(i, j);
} else
dp[x][j] = fun(i, j);
}
}
}
void fenzhi(int a, int b, int c, int d, int sum) {
if (a == c) {
for (int i = b; i < d; i++) printf("S");
return;
}
int xx = (a + c) / 2;
getdp1(a, b, xx, d, dp1);
getdp2(xx + 1, b, c, d, dp2);
int x = xx % 2, y = (xx + 1) % 2;
int id = -1;
int sum1, sum2;
for (int i = b; i <= d; i++) {
if (dp1[x][i] + dp2[y][i] == sum) {
id = i;
sum1 = dp1[x][i];
sum2 = dp2[y][i];
break;
}
}
fenzhi(a, b, xx, id, sum1);
printf("C");
fenzhi(xx + 1, id, c, d, sum2);
}
int main() {
while (scanf("%d%d%d", &n, &m, &p) != EOF) {
for (int i = 0; i < n; i++) scanf("%d", &xx[i]);
for (int i = 0; i < m; i++) scanf("%d", &yy[i]);
getdp1(0, 0, n - 1, m - 1, dp1);
int ans = dp1[(n - 1) % 2][m - 1];
printf("%d\n", ans);
fenzhi(0, 0, n - 1, m - 1, ans);
printf("\n");
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int b, k;
cin >> b >> k;
int A[k];
for (int i = 0; i < k; i++) {
cin >> A[i];
}
if (b % 2 == 0) {
if (A[k - 1] % 2 == 0)
cout << "even";
else
cout << "odd";
} else {
int count = 0;
for (int i = 0; i < k; i++) {
if (A[i] % 2 != 0) {
count++;
}
}
if (count % 2 == 0)
cout << "even";
else
cout << "odd";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Ahri {
int x, y, z;
Ahri(int a = 0, int b = 0, int c = 0) : x(a), y(b), z(c) {}
void read() { scanf("%d%d", &x, &y); }
bool operator<(const Ahri &A) const { return x < A.x; }
} p[101000 << 1];
long long ans[101000];
map<int, int> l;
int n, m, s[30001000], t[30001000];
int main() {
int i, j, k;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) p[i].read();
sort(p, p + n);
l[p[0].x] = k = 1;
for (i = 1; i < n; i++) {
k += min(m, p[i].x - p[i - 1].x);
if (p[i].x != p[i - 1].x) l[p[i].x] = k;
}
for (i = n - 1; i + 1; i--) {
p[i << 1 | 1] = Ahri(p[i].y, l[p[i].x], 1);
p[i << 1] = Ahri(p[i].y + m, l[p[i].x], -1);
}
sort(p, p + 2 * n);
for (i = 0; i < 2 * n; i++) {
for (j = p[i].y; j < p[i].y + m; j++) {
if (s[j]) ans[s[j]] += p[i].x - t[j];
s[j] += p[i].z;
t[j] = p[i].x;
}
}
for (i = 1; i <= n; i++) cout << ans[i] << ' ';
puts("");
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 10;
const int MAXM = 2e6 + 10;
const long long MOD = 1e9 + 7;
const long long INF = 0x3f3f3f3f;
const unsigned long long BASE = 233;
const int base = 5;
char rubbish[110];
bool GETDATA;
inline long long read() {
long long x = 0, f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - 48;
ch = getchar();
} while (ch >= '0' && ch <= '9');
return x * f;
}
inline void write(long long x, char con = '\n') {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10, 0);
putchar(x % 10 + '0');
if (con) {
printf("%c", con);
}
}
long long N, M, K;
long long a[MAXN];
vector<pair<int, int> > es[MAXN];
int dis[MAXN];
int col[MAXN];
queue<int> q;
void init() {
for (int i = 1; i <= N; i++) {
es[i].clear();
dis[i] = INF;
col[i] = -1;
}
while (!q.empty()) {
q.pop();
}
col[N] = 0;
dis[N] = 0;
q.push(N);
}
void solve() {
long long ans = 0;
int u, v, con;
N = read();
M = read();
init();
for (int i = 1; i <= M; i++) {
u = read();
v = read();
con = read();
es[v].push_back({u, con});
}
while (!q.empty()) {
u = q.front();
q.pop();
for (pair<int, int> now : es[u]) {
v = now.first;
con = now.second;
if (!~col[v]) {
col[v] = con ^ 1;
} else if (col[v] == con && dis[v] > dis[u] + 1) {
dis[v] = dis[u] + 1;
q.push(v);
}
}
}
write(dis[1] == INF ? -1 : dis[1]);
for (int i = 1; i <= N; i++) {
write(max(col[i], 0), i == N ? '\n' : 0);
}
}
int main() {
int T;
T = 1;
for (int t = 1; t <= T; t++) {
GETDATA = false;
solve();
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int n, k, a[1005], dem[1005], cnt, ans;
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
dem[a[i]]++;
}
cnt = (n + 1) / 2;
for (int i = 1; i <= k; i++) {
if (cnt >= dem[i] / 2) {
ans += (dem[i] / 2) * 2;
cnt -= dem[i] / 2;
dem[i] %= 2;
} else {
ans += cnt * 2;
printf("%d", ans);
return 0;
}
}
printf("%d", ans + cnt);
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const double PI = acos(-1.0);
const int INF = 1e9;
const int MOD = INF + 7;
const double EPS = 1e-9;
const long long BIGINF = 1e17;
mt19937 rng(time(0));
uniform_int_distribution<int> uid(0, INF / 2);
vector<int> v;
vector<int> used;
bool ok(int x) {
for (auto& i : v) {
if (((i ^ x) >= 1025) || (!used[(i ^ x)])) return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, ne_ok = 1;
cin >> n;
v.resize(n);
used.assign(1030, 0);
for (auto& i : v) cin >> i, used[i] = 1;
for (int i = 1; i < 1024; ++i) {
if (ok(i)) {
cout << i << '\n';
ne_ok = 0;
break;
}
}
if (ne_ok) cout << -1 << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7LL;
const int MXN = 2e5 + 1;
long long N, A[MXN], CMB[MXN];
inline long long solve(int i) {
long long ans = 0;
for (int j = i, cnt = 0; j < N; j += 2, cnt++) {
ans = ((A[j] * CMB[cnt]) % MOD + ans) % MOD;
}
return ans;
}
inline long long fE(long long b, long long e) {
long long r = 1;
while (e) {
if (e & 1)
r = (b * r) % MOD, e--;
else
b = (b * b) % MOD, e /= 2;
}
return r;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N;
for (int x = 0; x < N; x++) cin >> A[x];
if (N == 1) cout << A[0] << "\n";
int sign = 0, c = (N % 4 == 0) || (N % 4 == 1);
while (N > 1) {
if (N % 2 == 0) {
long long n = N / 2LL - 1LL;
CMB[0] = 1LL;
for (long long i = 1; i <= n; i++)
CMB[i] = (((CMB[i - 1] * (n - i + 1LL)) % MOD) * fE(i, MOD - 2)) % MOD;
long long ans = solve(0) + (c ? -1LL : 1LL) * solve(1);
ans = ((ans % MOD) + MOD) % MOD;
cout << ans << "\n";
N = 1;
} else {
for (int x = 0; x + 1 < N; x++)
A[x] = (A[x] + (sign ? -1LL : 1LL) * A[x + 1]) % MOD, sign = !sign;
N--;
}
}
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int c[550000];
int fa[550000 * 2];
int rk[550000 * 2];
struct Pair {
int l, r;
} p[550000];
int cnt;
bool vis[550000];
bool cmp(Pair x, Pair y) {
return c[x.l] == c[y.l] ? c[x.r] < c[y.r] : c[x.l] < c[y.l];
}
pair<int, int> rkstk[550000 * 4], fastk[550000 * 4];
int sum;
int anti(int x) { return x <= n ? x + n : x - n; }
int find(int x) { return x == fa[x] ? x : find(fa[x]); }
void merge_node(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (rk[x] > rk[y]) swap(x, y);
++sum;
rkstk[sum] = make_pair(y, rk[y]);
fastk[sum] = make_pair(x, fa[x]);
rk[y] = max(rk[y], rk[x] + 1);
fa[x] = y;
}
bool edge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return 0;
merge_node(x, anti(y));
merge_node(y, anti(x));
return 1;
}
void Undo() {
while (sum) {
fa[fastk[sum].first] = fastk[sum].second;
rk[rkstk[sum].first] = rkstk[sum].second;
sum--;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= 2 * n; i++) {
fa[i] = i;
rk[i] = 1;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (c[x] == c[y]) {
if (!edge(x, y)) vis[c[x]] = 1;
} else {
p[++cnt].l = x;
p[cnt].r = y;
if (c[p[cnt].l] > c[p[cnt].r]) swap(p[cnt].l, p[cnt].r);
}
}
sum = 0;
sort(p + 1, p + cnt + 1, cmp);
long long ans = 0;
for (int i = 1; i <= cnt; i++) {
int x = p[i].l, y = p[i].r;
if (vis[c[x]] || vis[c[y]]) continue;
int j = i;
bool flag = 0;
for (j = i; j <= cnt && c[p[j].l] == c[p[i].l] && c[p[j].r] == c[p[i].r];
j++) {
if (flag) continue;
if (!edge(p[j].l, p[j].r)) {
flag = 1;
ans--;
}
}
Undo();
i = j - 1;
}
int nsh = 0;
for (int i = 1; i <= k; i++) {
if (!vis[i]) nsh++;
}
ans += 1ll * nsh * (nsh - 1) / 2;
printf("%lld\n", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int far[maxn][2];
int cnt[maxn][2];
void init() {
for (int i = 0; i < maxn; i++)
far[i][0] = far[i][1] = i, cnt[i][0] = cnt[i][1] = 1;
}
int Find(int x, int type) {
return far[x][type] == x ? x : far[x][type] = Find(far[x][type], type);
}
void Union(int x, int y, int type) {
x = Find(x, type), y = Find(y, type);
if (x == y) return;
cnt[x][type] += cnt[y][type];
far[y][type] = far[x][type];
}
int main() {
init();
int n;
long long ans = 0;
scanf("%d", &n);
for (int i = 1, u, v, ty; i < n; i++) {
scanf("%d%d%d", &u, &v, &ty);
Union(u, v, ty);
}
for (int i = 1; i <= n; i++) {
int far0 = Find(i, 0), far1 = Find(i, 1);
if (far0 == i) ans += 1LL * cnt[i][0] * (cnt[i][0] - 1);
if (far1 == i) ans += 1LL * cnt[i][1] * (cnt[i][1] - 1);
ans += 1LL * (cnt[far0][0] - 1) * (cnt[far1][1] - 1);
}
printf("%lld\n", ans);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<string> a;
bool comp(string p, string t) {
string s1 = p, s2 = t;
s1.append(t), s2.append(p);
return (s1 < s2);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
a.resize(n);
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a.begin(), a.end(), comp);
for (int i = 0; i < n; ++i) cout << a[i];
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, h, a, sum = 0;
cin >> n >> h;
while (n--) {
cin >> a;
if (a > h)
sum = sum + 2;
else
sum++;
}
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1e9 + 7;
const int N = 105;
long long inv[N], n, ans[N][N], nex[N];
long long p[N], pc[N][N], sum;
int cnt, K;
int c[N], cc[N];
void dfs(int x) {
if (x > cnt) {
long long now = 1;
for (int i = 1; i <= cnt; i++) {
now = pc[i][cc[i]] % mo * ans[i][cc[i]] % mo * now % mo;
}
sum = (sum + now) % mo;
return;
}
for (int i = 0; i <= c[x]; i++) cc[x] = i, dfs(x + 1);
}
int main() {
inv[0] = inv[1] = 1;
for (int i = 2; i < N; i++) inv[i] = (mo - inv[mo % i] * (mo / i) % mo) % mo;
scanf("%lld%lld", &n, &K);
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) {
p[++cnt] = i;
pc[cnt][0] = 1;
while (n % i == 0)
c[cnt]++, pc[cnt][c[cnt]] = pc[cnt][c[cnt] - 1] * i, n /= i;
}
if (n > 1) p[++cnt] = n, c[cnt] = 1, pc[cnt][0] = 1, pc[cnt][1] = n;
for (int i = 1; i <= cnt; i++) {
ans[i][c[i]] = 1;
for (int j = 1; j <= K; j++) {
for (int k = 0; k <= c[i]; k++) ans[i][k] = ans[i][k] * inv[k + 1] % mo;
for (int k = c[i]; k; k--)
ans[i][k - 1] = (ans[i][k - 1] + ans[i][k]) % mo;
}
}
dfs(1);
printf("%lld\n", sum);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<char> myset;
string s;
getline(cin, s);
for (int i = 0; i < s.size(); i++) {
if (s[i] >= 97 && s[i] <= 122) {
myset.insert(s[i]);
}
}
cout << myset.size() << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int team_number, strenght;
cin >> team_number;
vector<tuple<int, int, int> > v;
for (int j = 2; j <= team_number * 2; j++) {
for (int i = 1; i <= j - 1; i++) {
cin >> strenght;
v.push_back(make_tuple(strenght, i, j));
}
}
sort(v.begin(), v.end());
vector<int> result;
result.resize(2 * team_number, 0);
for (auto e = v.rbegin(); e != v.rend() && team_number != 0; e++) {
int p1 = get<1>(*e), p2 = get<2>(*e), s = get<0>(*e);
if (result[p1 - 1] == 0 && result[p2 - 1] == 0) {
result[p1 - 1] = p2;
result[p2 - 1] = p1;
team_number--;
}
}
for (auto p = result.begin(); p != result.end(); p++) cout << *p << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
long long n, k;
long long f(long long mid) {
long long s = 0, maxi = INT_MIN, additions = INT_MAX;
for (long long i = 0; i < mid; i++) s += a[i];
additions = mid * a[mid - 1] - s;
if (additions <= k) return a[mid - 1];
for (long long i = mid; i < n; i++) {
s -= a[i - mid];
s += a[i];
if (additions > mid * a[i] - s) additions = mid * a[i] - s;
if (additions <= k) return a[i];
}
return INT_MAX;
}
int main() {
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long l = 0, r = n, ans, no;
while (l <= r) {
long long mid = (l + r) / 2;
if (f(mid) < INT_MAX) {
no = f(mid);
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
cout << ans << " " << no << endl;
}
| 8 |
#include <bits/stdc++.h>
const int maxp = 500, maxe = 20000;
using namespace std;
vector<int> as[300], bs[300];
int da[300], db[300];
int n, m, k, t;
int p[maxp], ne[maxe], e[maxe], ev[maxe], ew[maxe], ec;
int S = 1, T = 2;
int nowchooser;
struct edge {
int a, b, flag;
} es[maxe];
map<pair<int, int>, int> fp;
int cuteec;
void adde(int a, int b, int v, int w) {
e[++ec] = b;
ne[ec] = p[a];
p[a] = ec;
ev[ec] = v;
ew[ec] = w;
}
void addde(int a, int b, int v, int w) {
adde(a, b, v, w);
adde(b, a, 0, -w);
}
void clg() {
int i;
ec = 1;
for (i = 0; i < maxp; i++) p[i] = 0;
}
void mkgraph() {
int i;
for (i = 1; i <= n; i++) {
addde(S, 2 + i, da[i] / t, 0);
if (da[i] % t != 0) addde(S, 2 + i, 1, 1);
}
for (i = 1; i <= m; i++) {
addde(2 + n + i, T, db[i] / t, 0);
if (db[i] % t != 0) addde(2 + n + i, T, 1, 1);
}
for (i = 0; i < cuteec; i++)
if (es[i].flag == -1) addde(2 + es[i].a, 2 + n + es[i].b, 1, 0);
}
int l[maxe * 10], fa[maxe * 10], fae[maxe * 10], op, cl;
int pv[maxp], last[maxp];
inline bool isin(const int& a, const int& b, const int& c) {
return a >= b && a <= c;
}
int spfa() {
int i;
for (int i = 0; i < maxp; i++) pv[i] = 1 << 25;
fa[T] = -1;
for (last[S] = pv[l[op = cl = 0] = S] = 0; op <= cl; op++) {
int a = l[op];
for (i = p[a]; i; i = ne[i]) {
if (pv[e[i]] > pv[a] + ew[i] && ev[i] > 0) {
pv[l[++cl] = e[i]] = pv[a] + ew[i];
fa[e[i]] = a;
fae[e[i]] = i;
}
}
}
if (fa[T] == -1) return 0;
int minl = 1 << 25;
for (i = T; fa[i] != 0; i = fa[i]) minl = min(ev[fae[i]], minl);
for (i = T; fa[i] != 0; i = fa[i]) {
if (isin(i, 3, 3 + n - 1) && isin(fa[i], 3 + n, 3 + n + m - 1)) {
int a = i - 2, b = fa[i] - 2 - n;
es[fp[make_pair(a, b)]].flag = -1;
da[a]++;
db[b]++;
} else if (isin(i, 3 + n, 3 + n + m - 1) && isin(fa[i], 3, 3 + n - 1)) {
int a = fa[i] - 2, b = i - 2 - n;
es[fp[make_pair(a, b)]].flag = nowchooser;
da[a]--;
db[b]--;
}
ev[fae[i]] -= minl;
ev[fae[i] ^ 1] += minl;
}
return 1;
}
void flow() {
while (spfa())
;
}
void calc() {
for (t++; --t;) {
nowchooser++;
clg();
mkgraph();
flow();
}
}
int main() {
int i, ans = 0;
scanf("%d%d%d%d", &n, &m, &k, &t);
for (i = 0; i < k; i++) {
int a, b;
scanf("%d%d", &a, &b);
as[a].push_back(b);
bs[b].push_back(a);
es[cuteec].flag = -1;
es[cuteec].a = a;
es[cuteec++].b = b;
fp[make_pair(a, b)] = i;
}
for (i = 1; i <= n; i++) ans += ((da[i] = as[i].size()) % t) != 0;
for (i = 1; i <= m; i++) ans += ((db[i] = bs[i].size()) % t) != 0;
printf("%d\n", ans);
calc();
for (i = 0; i < k; i++) printf("%d ", es[i].flag);
printf("\n");
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x[5];
void read() {
for (int i = 0; i < 5; ++i) scanf("%d", &x[i]);
}
} p[105];
long long operator*(const Point& a, const Point& b) {
long long ret = 0;
for (int i = 0; i < 5; ++i) ret += (long long)a.x[i] * b.x[i];
return ret;
}
Point operator-(const Point& a, const Point& b) {
Point ret;
for (int i = 0; i < 5; ++i) ret.x[i] = a.x[i] - b.x[i];
return ret;
}
int n;
bool fg;
vector<int> G;
bool pd(int x, int y, int z) { return (p[y] - p[x]) * (p[z] - p[x]) > 0; }
int main() {
scanf("%d", &n);
if (n > 100) {
printf("0\n");
return 0;
}
for (int i = 1; i <= n; ++i) p[i].read();
for (int i = 1; i <= n; ++i) {
fg = true;
for (int j = 1; j <= n; ++j) {
for (int k = j + 1; k <= n; ++k)
if (i != j && i != k) {
if (pd(i, j, k)) {
fg = false;
break;
}
}
if (!fg) break;
}
if (fg) G.push_back(i);
}
printf("%d\n", G.size());
for (int i = 0; i < G.size(); ++i) printf("%d\n", G[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct persistent_array {
int tree_n = 0;
vector<T> values;
vector<int> left, right;
persistent_array(int n = 0, int reserve_size = 0) {
if (n > 0) init(n, reserve_size);
}
persistent_array(const vector<T> &v, int reserve_size = 0) {
init(v, reserve_size);
}
void init(int n, int reserve_size = 0) {
init(vector<T>(n, 0), reserve_size);
}
void set_left(int position, int result) { left[position] = result; }
void set_right(int position, int result) { right[position] = result; }
int build_tree(int start, int end) {
if (start >= end) return -1;
int node = (int)left.size();
left.emplace_back();
right.emplace_back();
if (end - start == 1) {
set_right(node, start);
return node;
}
int mid = (start + end) / 2;
set_left(node, build_tree(start, mid));
set_right(node, build_tree(mid, end));
return node;
}
void init(const vector<T> &v, int reserve_size = 0) {
tree_n = (int)v.size();
values = v;
left.clear();
right.clear();
if (reserve_size > 0) {
left.reserve(reserve_size);
right.reserve(reserve_size);
}
build_tree(0, tree_n);
}
T query(int root, int index) {
assert(0 <= index && index < tree_n);
int current = root;
int start = 0, end = tree_n;
while (end - start > 1) {
int mid = (start + end) / 2;
if (index < mid) {
current = left[current];
end = mid;
} else {
current = right[current];
start = mid;
}
}
assert(start == index && end == index + 1);
return values[right[current]];
}
int make_copy(int position) {
assert(0 <= position && position < (int)left.size());
left.push_back(left[position]);
right.push_back(right[position]);
return (int)left.size() - 1;
}
int update_tree(int position, int start, int end, int index, T value) {
assert(start < end);
position = make_copy(position);
if (end - start == 1) {
assert(start == index);
set_right(position, (int)values.size());
values.push_back(value);
return position;
}
int mid = (start + end) / 2;
if (index < mid)
set_left(position, update_tree(left[position], start, mid, index, value));
else
set_right(position, update_tree(right[position], mid, end, index, value));
return position;
}
int update(int root, int index, T value) {
assert(0 <= index && index < tree_n);
return update_tree(root, 0, tree_n, index, value);
}
};
const int INF = 1e9 + 5;
int N;
vector<int> A;
vector<int> matching;
vector<int> jumps;
vector<int> roots;
void solve_case() {
cin >> N;
A.resize(N);
for (int &a : A) {
cin >> a;
a--;
}
matching.assign(N, N);
jumps.assign(N + 1, 0);
persistent_array<int> closest(vector<int>(N, INF));
roots.assign(N + 1, 0);
long long answer = 0;
for (int i = N - 1; i >= 0; i--) {
int location = closest.query(roots[i + 1], A[i]);
if (location < N) {
assert(A[i] == A[location]);
matching[i] = location;
jumps[i] = jumps[location + 1] + 1;
}
answer += jumps[i];
location = min(location + 1, N);
roots[i] = closest.update(roots[location], A[i], i);
}
cout << answer << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int Q;
cin >> Q;
while (Q-- > 0) solve_case();
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 5e5;
const long long M = 20;
const long long SQ = 320;
const long long INF = 1e16;
const long long MOD = 1e9 + 7;
int n, m;
int a[N], b[N], b1[N], c[N];
vector<int> v, v1;
int l[N], r[N];
vector<pair<int, int> > q[N];
int d[N];
int ans[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
q[x].push_back(make_pair(y, i));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < q[i].size(); j++)
d[q[i][j].second] =
lower_bound(v.begin(), v.end(), q[i][j].first) - v.begin() + 1;
int pos = lower_bound(v.begin(), v.end(), a[i]) - v.begin();
if (pos == v.size())
v.push_back(a[i]);
else
v[pos] = a[i];
b[i] = pos + 1;
if (pos != 0) l[i] = v[pos - 1];
}
memset(r, 63, sizeof r);
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < q[i].size(); j++)
d[q[i][j].second] +=
lower_bound(v1.begin(), v1.end(), -q[i][j].first) - v1.begin();
int pos = lower_bound(v1.begin(), v1.end(), -a[i]) - v1.begin();
if (pos == v1.size())
v1.push_back(-a[i]);
else
v1[pos] = -a[i];
if (pos != 0) r[i] = -v1[pos - 1];
b1[i] = pos;
if (b[i] + b1[i] == v.size()) c[b[i]]++;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < q[i].size(); j++) {
if (d[q[i][j].second] >= v.size()) {
ans[q[i][j].second] = d[q[i][j].second];
} else if (b[i] + b1[i] == v.size() && c[b[i]] == 1 &&
(q[i][j].first <= l[i] || q[i][j].first >= r[i]))
ans[q[i][j].second] = v.size() - 1;
else
ans[q[i][j].second] = v.size();
}
for (int i = 0; i < m; i++) cout << ans[i] << '\n';
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long extendedGcd(long long a, long long b, long long &x, long long &y);
void addEdge(vector<long long> adj[], long long u, long long v);
void DFSUtil(long long u, vector<long long> adj[], vector<bool> &visited);
void DFS(vector<long long> adj[], long long V, long long start = 0);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n), b(n);
for (long long i = 0; i < n; i++) cin >> a[i] >> b[i];
long long sum = 0;
for (long long i = 0; i < n; i++)
sum += max((long long)0, a[(i + 1) % n] - b[i]);
long long ans = -1;
for (long long i = 0; i < n; i++) {
long long idx;
if (i == 0)
idx = n - 1;
else
idx = i - 1;
long long temp = sum - max((long long)0, a[i] - b[idx]);
temp += a[i];
if (ans == -1)
ans = temp;
else
ans = min(ans, temp);
}
cout << ans << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int modN = 1e9 + 7;
const double PI = 3.1415926535897932384626433832795028841;
int main() {
string a, b, x, name;
int n;
while (cin >> name >> n) {
map<string, int> m;
while (n--) {
cin >> a >> x;
m[a];
if (x == "posted") {
cin >> x >> b >> x;
b.erase(b.size() - 2, 2);
if (a == name || b == name) m[a] += 15, m[b] += 15;
} else if (x == "commented") {
cin >> x >> b >> x;
b.erase(b.size() - 2, 2);
if (a == name || b == name) m[a] += 10, m[b] += 10;
} else {
cin >> b >> x;
b.erase(b.size() - 2, 2);
if (a == name || b == name) m[a] += 5, m[b] += 5;
}
m[b];
}
vector<pair<int, string> > vec;
pair<int, string> a;
map<string, int>::iterator it = m.begin();
for (it; it != m.end(); it++) {
a = {-(it->second), it->first};
vec.push_back(a);
}
sort(vec.begin(), vec.end());
for (n = 0; n < vec.size(); n++)
if (vec[n].second != name) cout << vec[n].second << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int n, a[N], c[N << 1], pcnt, ncnt;
long long psum, nsum;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] - i > 0)
c[a[i] - i]++, pcnt++, psum += a[i] - i;
else
ncnt++, nsum += i - a[i];
}
long long ans = psum + nsum, ansk = 0;
for (int i = 1; i < n; i++) {
psum -= pcnt;
nsum += ncnt;
pcnt -= c[i];
ncnt += c[i];
long long x = a[n - i + 1];
nsum -= n + 1 - x;
ncnt--;
if (x > 1)
pcnt++, psum += x - 1, c[x - 1 + i]++;
else
ncnt++;
if (ans > psum + nsum) ans = psum + nsum, ansk = i;
}
cout << ans << ' ' << ansk << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 9000005;
int prim[maxn];
bool vis[maxn];
int cnt;
long long ans1[maxn];
long long ans2[maxn];
bool is(int x) {
int a[11];
int c = 0;
while (x) a[c++] = x % 10, x /= 10;
for (int i = 0, j = c - 1; i < j; i++, j--)
if (a[i] != a[j]) return 0;
return 1;
}
void init() {
for (int i = 2; i < maxn; i++)
if (!vis[i]) {
prim[cnt++] = i;
for (int j = i + i; j < maxn; j += i) vis[j] = 1;
}
for (int i = 1; i < maxn; i++) {
ans1[i] += ans1[i - 1];
if (i >= 2 && !vis[i]) ans1[i]++;
}
for (int i = 1; i < maxn; i++) {
ans2[i] += ans2[i - 1];
if (is(i)) ans2[i]++;
}
}
void print(int x) { cout << x << " " << ans1[x] << " " << ans2[x] << endl; }
int main() {
init();
int p, q;
cin >> p >> q;
for (int i = maxn - 1; i >= 1; i--) {
if (ans1[i] * q <= ans2[i] * p) {
cout << i << endl;
return 0;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, maxs, ans, tot[100], dp[50][100][100];
inline int lowbit(int x) { return x & -x; }
int calc(int x) {
int res = 0;
while (x) {
res++;
x -= lowbit(x);
}
return res;
}
bool check(int x, int y, int z) {
int sta = x | y | z | (y << 1) | (y >> 1);
if ((sta & maxs) == maxs) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &m);
if (n > m) swap(n, m);
maxs = (1 << n) - 1;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= maxs; ++j) {
for (int k = 0; k <= maxs; ++k) dp[i][j][k] = -20020430;
}
}
for (int s = 0; s <= maxs; ++s) tot[s] = n - calc(s), dp[0][0][s] = 0;
for (int i = 0; i < m; ++i) {
for (int j = 0; j <= maxs; ++j) {
for (int k = 0; k <= maxs; ++k) {
for (int l = 0; l <= maxs; ++l)
if (check(j, k, l))
dp[i + 1][k][l] = max(dp[i + 1][k][l], dp[i][j][k] + tot[k]);
}
}
}
for (int s = 0; s <= maxs; ++s) ans = max(ans, dp[m][s][0]);
printf("%d", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[2000002];
int b[2000002];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) scanf("%d%d", &a[i], &b[i]);
int ans = 0;
for (int i = 0; i < m; ++i) {
ans = max(ans, b[i]);
int d2 = a[i];
int h2 = b[i];
int t = 0;
if (!i) {
ans = max(ans, d2 - 1 + b[i]);
t = 1;
}
if (i + 1 >= m) ans = max(ans, n - d2 + b[i]);
if (t) continue;
int d1 = a[i - 1];
int h1 = b[i - 1];
if (d2 - d1 < abs(h2 - h1)) {
puts("IMPOSSIBLE");
return 0;
}
int l = 0, r = d2 - d1 + 1;
while (l + 1 < r) {
int mid = (l + r) / 2;
int d3 = d1 + mid;
int h3 = h1 + mid;
if (d2 - d3 < abs(h2 - h3))
r = mid;
else
l = mid;
}
ans = max(ans, h1 + l);
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
using namespace std;
long long mod = (1000000007LL);
inline long long Mod(long long a, long long b) { return (a % b); }
inline long long poww(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) {
while (b) {
a %= b, swap(a, b);
}
return a;
}
void read(vector<int> &w, int n) {
w.resize(n);
for (int i = 0; i < n; i++) cin >> w[i];
}
void print(vector<int> &w) {
for (int i = 0; i < (int)(w).size(); i++) {
if (i == (int)(w).size() - 1)
cout << w[i] << "\n";
else
cout << w[i] << " ";
}
}
int prodmod(vector<int> w);
int summod(vector<int> w);
int n, m, q, k, v[1000050], ans;
pair<int, int> w[1000050];
string second;
int nxt[1000050];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
cin >> second;
vector<int> pref[3];
pref[0].resize(n);
pref[1].resize(n);
vector<int> caras[2];
for (int i = 0; i < n; i++) {
if (i > 0) {
pref[0][i] = pref[0][i - 1];
pref[1][i] = pref[1][i - 1];
}
if (second[i] != '?')
pref[second[i] - '0'][i]++, caras[second[i] - '0'].push_back(i);
else
pref[2].push_back(i);
}
for (int i = 0; i < n; i++) {
int ini = 0, fim = (int)(caras[0]).size() - 1, mid, best = -1;
while (fim >= ini) {
mid = (ini + fim) / 2;
if (caras[0][mid] <= i) {
best = caras[0][mid];
ini = mid + 1;
} else
fim = mid - 1;
}
ini = 0, fim = (int)(caras[1]).size() - 1, mid;
int best2 = -1;
while (fim >= ini) {
mid = (ini + fim) / 2;
if (caras[1][mid] <= i) {
best2 = caras[1][mid];
ini = mid + 1;
} else
fim = mid - 1;
}
if (best != -1 and best2 != -1) {
nxt[i] = min(best + 1, best2 + 1);
}
}
for (int x = 1; x <= n; x++) {
int l = 0, r = x - 1, ans = 0;
while (r < n) {
int qtd0 = pref[0][r] - (l > 0 ? pref[0][l - 1] : 0);
int qtd1 = pref[1][r] - (l > 0 ? pref[1][l - 1] : 0);
if (qtd0 == 0 or qtd1 == 0) {
ans++;
l += x;
r = l + x - 1;
} else {
if (nxt[r] <= l) {
break;
}
l = nxt[r];
r = l + x - 1;
}
}
cout << ans << " ";
}
cout << "\n";
}
int summod(vector<int> w) {
int curr = 0;
for (int i = 0; i < (int)(w).size(); i++) {
curr = (curr + w[i]) % mod;
if (curr < 0) curr += mod;
}
return curr;
}
int prodmod(vector<int> w) {
int curr = 1;
for (int i = 0; i < (int)(w).size(); i++) {
if (w[i] >= mod) w[i] %= mod;
curr = (curr * w[i]) % mod;
if (curr < 0) curr += mod;
}
return curr;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n, m;
scanf("%lld %lld", &n, &m);
vector<vector<long long>> subjects(m);
for (long long i = 0; i < n; i++) {
long long si, ri;
scanf("%lld %lld", &si, &ri);
si--;
subjects[si].push_back(ri);
}
for (long long i = 0; i < m; i++) {
sort(subjects[i].rbegin(), subjects[i].rend());
}
sort(subjects.rbegin(), subjects.rend(),
[](const vector<long long>& a, const vector<long long>& b) {
return a.size() < b.size();
});
for (long long i = 0; i < m; i++) {
for (long long j = 1; j < subjects[i].size(); j++) {
;
;
;
subjects[i][j] = subjects[i][j - 1] + subjects[i][j];
;
}
}
long long total = 0;
for (long long pos = 0; pos < n; pos++) {
long long sum = 0;
for (long long i = 0; i < m; i++) {
if (!(subjects[i].size() > pos)) {
break;
}
if (subjects[i].size() > pos && subjects[i][pos] > 0) {
sum += subjects[i][pos];
;
;
}
};
total = max(total, sum);
}
cout << total << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string s;
int getLen(int i) {
int j = i;
while (s[j] != ',') j++;
return j - i;
}
vector<int> st;
string com[1000000];
int dep[1000000];
int cid[1000000];
bool cmp(int a, int b) {
if (dep[a] == dep[b]) return a < b;
return dep[a] < dep[b];
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
cin >> s;
s += ',';
int cur = 0;
int C = 0;
while (cur != s.size()) {
while (st.size() > 0 && st[st.size() - 1] == 0) st.pop_back();
if (st.size() > 0) st[st.size() - 1]--;
int l = getLen(cur);
com[C] = s.substr(cur, l);
dep[C++] = st.size();
cur = cur + l + 1;
l = getLen(cur);
int val = 0;
for (int j = cur; j < cur + l; j++) val = 10 * val + (s[j] - '0');
st.push_back(val);
cur = cur + l + 1;
}
for (int i = 0; i < C; i++) cid[i] = i;
sort(cid, cid + C, cmp);
cout << dep[cid[C - 1]] + 1 << '\n';
for (int i = 0; i < C; i++) {
cout << com[cid[i]];
if (i == C - 1 || dep[cid[i]] != dep[cid[i + 1]])
cout << '\n';
else
cout << ' ';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int main() {
cin >> n;
cout << 1 + 12 * (n * (n - 1) / 2) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dr[] = {1, 0, -1, 0, -1, -1, 1, 1};
int dc[] = {0, -1, 0, 1, -1, 1, -1, 1};
const int MAX = 500 + 7;
const int MOD = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
for (long long i = 0; i < n; ++i) {
int s, e, t;
cin >> s >> e >> t;
if (s == e) {
cout << t << "\n";
continue;
}
int k = t / (m - 1);
int out = t;
if (k % 2 == 0) {
int cur = t - (k * (m - 1)) + 1;
if (cur == s)
out += (e - s > 0) ? (e - s) : (2 * m - s - e);
else if (cur > s)
out += ((2 * m - cur - s) + ((s - e > 0) ? (s - e) : (s + e - 2)));
else if (cur < s)
out += ((s - cur) + ((e - s > 0) ? (e - s) : (2 * m - s - e)));
} else {
int cur = m - (t - (k * (m - 1)));
if (cur == s)
out += (s - e > 0) ? (s - e) : (s + e - 2);
else if (cur > s)
out += ((cur - s) + ((s - e > 0) ? (s - e) : (s + e - 2)));
else if (cur < s)
out += ((cur + s - 2) + ((e - s > 0) ? (e - s) : (2 * m - s - e)));
}
cout << out << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e5 + 5;
const int maxm = (int)1e5 + 5;
int n, m, k;
int cnt[maxn];
struct edge {
int u, v, w;
void read() { scanf("%d%d%d", &u, &v, &w); }
bool operator<(const edge &rhs) const { return w < rhs.w; }
} e[maxm];
int ans;
int lab[maxn];
int root(int x) { return lab[x] < 0 ? x : lab[x] = root(lab[x]); }
void unite(int u, int v, int w) {
u = root(u);
v = root(v);
if (u != v) {
if (lab[u] > lab[v]) {
swap(u, v);
}
if (cnt[u] && cnt[v]) {
ans = w;
}
lab[u] += lab[v];
lab[v] = u;
cnt[u] += cnt[v];
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; ++i) {
int x;
scanf("%d", &x);
cnt[x]++;
}
for (int i = 1; i <= m; ++i) {
e[i].read();
}
memset(lab, -1, sizeof(lab));
sort(e + 1, e + m + 1);
for (int i = 1; i <= m; ++i) {
unite(e[i].u, e[i].v, e[i].w);
}
for (int i = 1; i <= k; ++i) {
printf("%d ", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
bool flag = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') flag = 0;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return flag ? x : -x;
}
int n;
int main() {
n = read();
if (n == 1) {
cout << 0 << endl;
return 0;
}
int ans = n - 1;
for (int i = 2; i <= n / 2; i++) {
int x = i, y = n - i;
if (x == y) continue;
if (x == y || (x % 2 == 0 && y % 2 == 0)) continue;
int aa = 1;
bool f = 0;
while (x != 1 && y != 1) {
int t = y;
y = y % x;
if (y == 0) {
f = 1;
break;
}
aa += (t / x);
swap(x, y);
}
if (f == 1) continue;
aa += (y - 1);
ans = min(aa, ans);
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
template <class T>
istream& operator>>(istream& is, vector<T>& vec) {
for (int i = 0; i < vec.size(); ++i) is >> vec[i];
return is;
}
template <class T>
ostream& operator<<(ostream& os, vector<T>& vec) {
for (auto& t : vec) os << t << " ";
return os;
}
struct query {
int l, k;
int idx;
int ans;
};
template <typename IntType>
struct BinaryIndexedTreeAdd {
int n;
vector<IntType> elems;
BinaryIndexedTreeAdd(int n_) {
n = n_ + 1;
elems.assign(n, 0);
}
void __add(int idx, IntType v) {
idx++;
while (idx < n) {
elems[idx] += v;
idx += (idx & (-idx));
}
}
IntType __prefix(int idx) {
IntType res = 0;
while (idx > 0) {
res += elems[idx];
idx ^= (idx & (-idx));
}
return res;
}
void add(IntType v, int l, int r) {
__add(l, v);
__add(r, -v);
}
IntType get(int idx) { return __prefix(idx + 1); }
int upper_bound(IntType v) {
int bb = 31 - __builtin_clz(n);
int bbv = (1 << bb);
int ans = 0;
IntType vcp = v;
while (bbv > 0) {
if (ans + bbv < n && elems[ans + bbv] <= v) {
ans += bbv;
v -= elems[ans];
}
bbv /= 2;
}
return ans;
}
};
using BitAdd = BinaryIndexedTreeAdd<int>;
void dfs(vector<vector<int>>& V, vector<int>& A, int v,
vector<vector<query>>& Q, vector<set<int>>& S, vector<int>& cnt,
BitAdd& ba) {
if (cnt[A[v]] >= 1) {
S[cnt[A[v]]].erase(A[v]);
ba.add(-1, cnt[A[v]], A.size() + 1);
}
cnt[A[v]]++;
ba.add(1, cnt[A[v]], A.size() + 1);
S[cnt[A[v]]].insert(A[v]);
for (auto& q : Q[v]) {
int b = ba.upper_bound(ba.get(q.l - 1) + q.k - 1);
if (b < A.size() + 1) {
assert(S[b].size() > 0);
q.ans = *S[b].begin();
}
}
for (int x : V[v]) {
dfs(V, A, x, Q, S, cnt, ba);
}
S[cnt[A[v]]].erase(A[v]);
ba.add(-1, cnt[A[v]], A.size() + 1);
cnt[A[v]]--;
if (cnt[A[v]] > 0) {
S[cnt[A[v]]].insert(A[v]);
ba.add(1, cnt[A[v]], A.size() + 1);
}
}
void st() {
int n, q;
cin >> n >> q;
vector<int> A(n);
cin >> A;
vector<vector<int>> V(n);
for (int i = 1; i < n; ++i) {
int p;
cin >> p;
p--;
V[p].push_back(i);
}
vector<vector<query>> Q(n);
for (int i = 0; i < q; ++i) {
int v, l, k;
cin >> v >> l >> k;
Q[v - 1].push_back({l, k, i, -1});
}
vector<set<int>> S(n + 1);
vector<int> cnt(n + 1, 0);
BitAdd ba(n + 1);
dfs(V, A, 0, Q, S, cnt, ba);
vector<int> ans(q);
for (int i = 0; i < n; ++i) {
for (auto& qq : Q[i]) {
ans[qq.idx] = qq.ans;
}
}
cout << ans << (char)10;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
if (t < 50) {
cerr << "-------------------" << (char)10;
}
st();
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int L = 23, N = 110;
const int B = 1e9 + 7;
int no;
int n, k;
vector<int> e[N];
long long dp[N][L][L];
void add(long long &x, long long y) {
x = (x + y) % B;
if (x < 0) x += B;
}
void cpy(long long a[L][L], long long c[L][L]) {
for (int i = 0; i <= no; ++i)
for (int j = 0; j <= no; ++j) a[i][j] = c[i][j];
}
void mrgup(long long a[L][L], long long b[L][L]) {
long long c[L][L];
memset(c, 0, sizeof(c));
for (int ai = 0; ai <= no; ++ai) {
for (int aj = 0; aj <= no; ++aj) {
for (int bi = 0; bi <= no; ++bi) {
for (int bj = 0; bj <= no; ++bj) {
if (bj == k) continue;
int afl = aj == no || (bi != no && aj + 1 + bi <= k);
int bfl = bj == no || (ai != no && ai + 1 + bj <= k);
int mx = -1;
if (!afl) mx = max(mx, aj);
if (!bfl) mx = max(mx, bj + 1);
int x = no;
if (ai != no) x = min(x, ai);
if (bi != no) x = min(x, bi + 1);
add(c[x][mx == -1 ? no : mx], a[ai][aj] * b[bi][bj] % B);
}
}
}
}
cpy(a, c);
}
void dfs(int v, int p) {
dp[v][0][no] = 1;
if (k != 0) dp[v][no][0] = 1;
for (int u : e[v]) {
if (u == p) continue;
dfs(u, v);
mrgup(dp[v], dp[u]);
}
}
int main() {
scanf("%d%d", &n, &k);
no = k + 1;
for (int i = 1, u, v; i < n; ++i) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
dfs(1, 0);
long long ans = 0;
for (int i = 0; i <= k; ++i) {
add(ans, dp[1][i][no]);
}
printf("%lld\n", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << ": " << arg1 << 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...);
}
const long long INF64 = 1LL << 60;
const int INF = 1 << 30;
const int MOD = 1e9 + 7;
struct Edge {
int v, c, f;
long long w;
int dual;
Edge(int v, int c, long long w, int dual) : v(v), c(c), w(w), dual(dual) {
f = 0;
}
};
const int N = 7000;
vector<Edge> a[N];
vector<Edge>::iterator idx[N];
long long d[N];
int dp[N], pre[N];
bool visit[N];
int Q[N];
void add_edge(int x, int y, int c, int w) {
a[x].push_back(Edge(y, c, w, (int)(a[y].size())));
a[y].push_back(Edge(x, 0, -w, (int)(a[x].size()) - 1));
}
long long mincost_maxflow(int s, int t, int n, int lim) {
long long ret = 0;
int sum = 0;
while (true) {
fill(pre, pre + n, -1);
fill(d, d + n, INF64);
fill(visit, visit + n, false);
d[s] = 0;
visit[s] = true;
dp[s] = INF;
Q[0] = s;
int head = 0, tail = 1;
while (head != tail) {
int u = Q[head];
visit[u] = false;
for (vector<Edge>::iterator it = a[u].begin(); it != a[u].end(); ++it) {
if (it->c && d[it->v] > d[u] + it->w) {
d[it->v] = d[u] + it->w;
pre[it->v] = u;
idx[it->v] = it;
dp[it->v] = min(dp[u], it->c);
if (!visit[it->v]) {
visit[it->v] = true;
Q[tail++] = it->v;
if (tail == N) tail = 0;
}
}
}
if (++head == N) head = 0;
}
if (pre[t] == -1) break;
int aug = 1;
sum += aug;
for (int i = t; pre[i] != -1; i = pre[i]) {
idx[i]->c -= aug;
a[idx[i]->v][idx[i]->dual].c += aug;
ret += idx[i]->w;
}
if (sum == lim) break;
}
return ret;
}
struct Node {
int a, b;
Node *left, *right;
};
Node pool[N << 1], *last;
Node* build(int a, int b) {
Node* cur = last++;
cur->a = a;
cur->b = b;
if (a + 1 == b) return cur;
cur->left = build(a, (a + b) / 2);
cur->right = build((a + b) / 2, b);
return cur;
}
int A, B;
vector<int> nodes;
void query(Node* cur) {
if (cur->a >= A && cur->b <= B) {
nodes.push_back(cur - pool);
return;
}
if ((cur->a + cur->b) / 2 > A) query(cur->left);
if ((cur->a + cur->b) / 2 < B) query(cur->right);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> a(n), b(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%d", &b[i]);
}
last = pool;
Node* root = build(0, n);
for (int i = 0; i < n; ++i) {
A = i, B = n;
nodes.clear();
query(root);
for (auto& x : nodes) {
add_edge(i, n + x, INF, 0);
}
}
int s = n + last - pool, t = s + 1;
for (int i = 0; i < n; ++i) {
add_edge(s, i, 1, a[i]);
}
for (Node* p = pool; p != last; ++p) {
int i = p - pool;
if (p->a + 1 == p->b) {
add_edge(n + i, t, 1, b[p->a]);
} else {
int j = p->left - pool;
add_edge(n + i, n + j, INF, 0);
j = p->right - pool;
add_edge(n + i, n + j, INF, 0);
}
}
long long ret = mincost_maxflow(s, t, t + 1, m);
cout << ret << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> a;
map<long long, vector<long long>> adj;
long long cnt, mx;
pair<long long, long long> dfs(long long x) {
if (adj[x].size() == 0) {
mx = max(mx, (long long)a[x]);
return {1, a[x]};
}
long long sum = 0, ct = 0;
for (auto y : adj[x]) {
pair<long long, long long> f = dfs(y);
sum += f.second;
ct += f.first;
}
sum += a[x];
mx = max(mx, (sum + ct - 1) / ct);
return {ct, sum};
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
for (long long i = 2; i <= n; i++) {
long long x;
cin >> x;
adj[x].push_back(i);
}
long long sum = 0;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
a[i] += x;
}
dfs(1);
cout << mx << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, p, q, c[5005 << 1], T = (5005 << 1) - 5, bas = 5002;
long long ans = 0;
struct node {
int x, l, r;
} a[5005], b[5005];
bool cmp(node x, node y) { return x.x < y.x; }
bool cmp_(node x, node y) { return x.l < y.l; }
inline void add(int x) {
for (; x <= T; x += x & -x) c[x]++;
}
inline int ask(int x) {
int sum = 0;
for (; x; x -= x & -x) sum += c[x];
return sum;
}
void calc(int x) {
memset(c, 0, sizeof(c));
int j = 1;
for (int i = 1; i <= x - 1; i++) {
while (j <= q && b[j].l <= a[i].x) {
if (b[j].r >= a[x].x && b[j].x <= a[x].r && b[j].x >= a[x].l)
add(bas + b[j].x);
j++;
}
int cur = ask(a[i].r + bas) - ask(a[i].l + bas - 1);
ans += cur * (cur - 1) / 2;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y, X, Y;
scanf("%d%d%d%d", &x, &y, &X, &Y);
if (x > X) swap(x, X);
if (y > Y) swap(y, Y);
if (x == X)
a[++p].x = x, a[p].l = y, a[p].r = Y;
else
b[++q].x = y, b[q].l = x, b[q].r = X;
}
sort(a + 1, a + p + 1, cmp);
sort(b + 1, b + q + 1, cmp_);
for (int i = 2; i <= p; i++) calc(i);
printf("%lld\n", ans);
return 0;
}
| 14 |
#include <bits/stdc++.h>
int main() {
const unsigned MAX_DELTA = 5U;
unsigned n;
std::cin >> n;
std::vector<unsigned> a(n);
for (unsigned i = 0U; i < n; i++) {
std::cin >> a[i];
}
std::sort(a.begin(), a.end());
auto left = a.begin();
auto right = a.begin();
while (right != a.end() - 1U) {
if (*(right + 1) - *left <= MAX_DELTA) {
right++;
} else {
right++;
left++;
}
}
std::cout << 1U + std::distance(left, right);
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("O8")
#pragma GCC optimization("unroll-loops")
using namespace std;
const long long int N = 2e2 + 20, mod = 1e9 + 7, inf = 1e18, dlt = 12250,
maxm = 2e6;
int poww(long long a, int k) {
if (!k) return 1;
if (k == 1) return a;
long long r = poww(a, k / 2);
return (((r * r) % mod) * poww(a, k & 1)) % mod;
}
int f[N];
pair<string, int> dp[N][N];
int func(string s, string t) {
int n = s.size(), m = t.size();
string w = t + '#' + s;
int k = 0, ans = 0;
for (int i = 1; i < m + n + 1; i++) {
while (k && w[i] != w[k]) k = f[k - 1];
k += (w[i] == w[k]);
f[i] = k;
ans = max(ans, k);
}
return ans;
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
string s, t, v;
cin >> s >> t >> v;
int d1, d2, d3;
d1 = s.size(), d2 = t.size(), d3 = v.size();
int ans = 0;
string out;
for (int o = 0; o < d3; o++) {
for (int i = 0; i < d1; i++) {
if (!i) {
if (s[i] == t[0] && (o || s[i] != v[0])) dp[i][0] = make_pair(s[0], 1);
if ((dp[i][0].first).size() > ans) {
ans = (dp[i][0].first).size();
out = dp[i][0].first;
}
continue;
}
dp[i][0] = dp[i - 1][0];
if (s[i] == t[0]) {
if (s[i] != v[0]) dp[i][0] = make_pair(s[i], 0);
if (o && dp[i][0].first == "") dp[i][0] = make_pair(s[i], 1);
}
if (ans < (dp[i][0].first).size()) {
ans = (dp[i][0].first).size();
out = dp[i][0].first;
}
}
for (int i = 1; i < d2; i++) {
dp[0][i] = dp[0][i - 1];
if (s[0] == t[i]) {
if (s[0] != v[0]) dp[0][i] = make_pair(s[0], 0);
if (o && dp[0][i].first == "") dp[0][i] = make_pair(s[0], 1);
}
if (ans < (dp[0][i].first).size()) {
ans = (dp[0][i].first).size();
out = dp[0][i].first;
}
}
for (int i = 1; i < d1; i++) {
for (int j = 1; j < d2; j++) {
dp[i][j] = dp[i - 1][j];
if ((dp[i][j].first).size() < (dp[i][j - 1].first).size())
dp[i][j] = dp[i][j - 1];
if ((dp[i][j].first).size() == (dp[i][j - 1].first).size() &&
dp[i][j].second > dp[i][j - 1].second)
dp[i][j] = dp[i][j - 1];
if ((dp[i][j].first).size() > ans) {
out = dp[i][j].first;
ans = out.size();
}
if (s[i] == t[j]) {
int mx = func(dp[i - 1][j - 1].first + s[i], v);
if (mx > o ||
(dp[i - 1][j - 1].first).size() + 1 < (dp[i][j].first).size() ||
((dp[i - 1][j - 1].first).size() + 1 == (dp[i][j].first).size() &&
mx >= dp[i][j].second))
continue;
dp[i][j] = make_pair(dp[i - 1][j - 1].first + s[i], mx);
}
if ((dp[i][j].first).size() > ans) {
out = dp[i][j].first;
ans = out.size();
}
}
}
}
if (!ans)
cout << 0;
else
cout << out;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long a[100010];
long long po[300010], r[300010];
vector<int> v[300010];
void solve(int b, int p) {
if (r[p] != -1) return;
long long s = v[p].size() - 1;
if (!s) {
po[p] = 1;
r[p] = a[p];
return;
}
long long m = 10e15;
long long g = 1;
for (int u : v[p]) {
if (u == b) continue;
solve(p, u);
g = lcm(g, po[u]);
m = min(m, r[u]);
if (g > m) {
r[p] = 0;
po[p] = 1;
return;
}
}
long long d = (m / g) * g * s;
r[p] = d;
po[p] = g * s;
if (!po[p] && (s && g)) exit(15);
return;
}
int main(int argc, char *argv[]) {
int n;
cin >> n;
long long u = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
u += a[i];
}
for (int i = 0; i < 300010; i++) {
r[i] = -1;
po[i] = 1;
}
int x, y;
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
x--;
y--;
v[x].push_back(y);
v[y].push_back(x);
}
v[0].push_back(0);
solve(0, 0);
cout << u - r[0] << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
struct __s {
__s() {
srand(time(NULL));
if (1) {
ios_base::Init i;
cin.sync_with_stdio(0);
cin.tie(0);
}
}
~__s() {
if (!1)
fprintf(stderr, "Execution time: %.3lf s.\n",
(double)clock() / CLOCKS_PER_SEC);
long long n;
cin >> n;
}
} __S;
long long mod = 1000000007;
long long n;
string s[1111];
long long d[8][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1},
{-1, -1}, {-1, 1}, {1, -1}, {1, 1}};
long long b[2][4] = {{0, 1, 2, 3}, {4, 5, 6, 7}};
int r[8][1111][1111];
int cnt[8][1111][1111][4];
pair<long long, long long> B[4][2222];
bool check(long long x) { return (0 <= x && x < n); }
bool check(long long x, long long y) { return check(x) && check(y); }
long long getSum(long long i, long long xl, long long yl, long long xr,
long long yr, long long a) {
long long res = cnt[i][xl][yl][a];
if (check(xr, yr)) res -= cnt[i][xr][yr][a];
return res;
}
void get(long long x, long long y, long long i, long long rad, long long &a2,
long long &a3) {
for (long long j = 0; j < (long long)(4); j++) {
long long xx = x + d[b[i][j]][0] * rad;
long long yy = y + d[b[i][j]][1] * rad;
a2 += getSum(b[i][j], x, y, xx, yy, 2);
a3 += getSum(b[i][j], x, y, xx, yy, 3);
}
if (s[x][y] == '2') a2 -= 3;
if (s[x][y] == '3') a3 -= 3;
}
pair<long long, long long> mul(long long a2, long long a3) {
if (a2 == -1 || a3 == -1) return make_pair(0, 0);
long long x = B[2][a2].first + B[3][a3].first;
long long y = B[2][a2].second * B[3][a3].second;
while (y > mod) {
y /= 1000;
x++;
}
return make_pair(x, y);
}
int main(void) {
for (long long k = 2; k <= 3; k++) {
B[k][0] = make_pair(0, 1);
for (long long i = 1; i < 2222; i++) {
B[k][i] = B[k][i - 1];
B[k][i].second *= k;
if (B[k][i].second > mod) {
B[k][i].second /= 1000;
B[k][i].first++;
}
}
}
cin >> n;
for (long long i = 0; i < (long long)(n); i++) {
cin >> s[i];
}
for (long long i = 0; i < (long long)(8); i++) {
long long lx = 0, rx = n - 1, dx = 1;
if (d[i][0] >= 0) {
swap(lx, rx);
dx *= -1;
}
long long ly = 0, ry = n - 1, dy = 1;
if (d[i][1] >= 0) {
swap(ly, ry);
dy *= -1;
}
for (long long x = lx; check(x); x += dx) {
for (long long y = ly; check(y); y += dy) {
long long xx = x + d[i][0];
long long yy = y + d[i][1];
if (!check(xx, yy)) {
r[i][x][y] = (s[x][y] != '0');
cnt[i][x][y][s[x][y] - '0']++;
continue;
}
for (long long j = 0; j < (long long)(4); j++) {
cnt[i][x][y][j] = cnt[i][xx][yy][j];
}
cnt[i][x][y][s[x][y] - '0']++;
if (s[x][y] == '0')
r[i][x][y] = 0;
else
r[i][x][y] = r[i][xx][yy] + 1;
}
}
}
long long first = -1, second = -1, R = -1, I = -1;
long long A2 = -1, A3 = -1;
for (long long x = 0; x < (long long)(n); x++) {
for (long long y = 0; y < (long long)(n); y++) {
if (s[x][y] == '0') continue;
for (long long i = 0; i < (long long)(2); i++) {
int rad = n;
for (long long j = 0; j < (long long)(4); j++) {
rad = min(rad, r[b[i][j]][x][y]);
}
long long a2 = 0, a3 = 0;
get(x, y, i, rad, a2, a3);
if (mul(a2, a3) > mul(A2, A3)) {
first = x;
second = y;
I = i;
R = rad;
A2 = a2;
A3 = a3;
}
}
}
}
if (R == -1) {
cout << 0 << '\n';
return 0;
}
long long sum = 1LL;
for (long long i = 0; i < (long long)(A2); i++) {
sum *= 2;
sum %= mod;
}
for (long long i = 0; i < (long long)(A3); i++) {
sum *= 3;
sum %= mod;
}
cout << sum << '\n';
return 0;
}
| 15 |
Subsets and Splits