solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, head[300300], nxt[300300 << 1], to[300300 << 1], fa[300300][22],
dp[300300];
void add_edge(int x, int y, int id) {
nxt[id] = head[x], head[x] = id;
to[id] = y;
}
void dfs(int x, int p = 0) {
fa[x][0] = p;
for (int i = 1; i <= 31 - __builtin_clz(n); i++)
fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
if (y == p) continue;
dp[y] = dp[x] + 1;
dfs(y, x);
}
}
int anc(int x, int d) {
if (!d) return x;
for (int i = 31 - __builtin_clz(d); i >= 0; i--)
if (d & (1 << i)) x = fa[x][i];
return x;
}
int lca(int x, int y) {
if (dp[x] > dp[y])
x = anc(x, dp[x] - dp[y]);
else if (dp[y] > dp[x])
y = anc(y, dp[y] - dp[x]);
if (x == y) return x;
for (int i = 31 - __builtin_clz(dp[x]); i >= 0; i--) {
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
}
return fa[x][0];
}
int rnk[300300 << 1][22], ord[300300 << 1], dro[300300 << 1], cnt[300300 << 1];
int prf[300300 << 1], suf[300300 << 1];
void build(char *s) {
int m = 2 * n, p = 256;
for (int i = 1; i <= n; i++) rnk[i][0] = rnk[i + n][0] = s[i];
for (int j = 1; j <= 31 - __builtin_clz(n); j++) {
for (int i = 1; i <= n; i++) {
int pa = fa[i][j - 1];
prf[i] = rnk[i][j - 1], suf[i] = rnk[pa][j - 1];
prf[i + n] = rnk[pa ? pa + n : pa][j - 1], suf[i + n] = rnk[i + n][j - 1];
}
for (int i = 0; i <= p; i++) cnt[i] = 0;
for (int i = 1; i <= m; i++) cnt[suf[i]]++;
for (int i = 1; i <= p; i++) cnt[i] += cnt[i - 1];
for (int i = 1; i <= m; i++) dro[cnt[suf[i]]--] = i;
for (int i = 0; i <= p; i++) cnt[i] = 0;
for (int i = 1; i <= m; i++) cnt[prf[i]]++;
for (int i = 1; i <= p; i++) cnt[i] += cnt[i - 1];
for (int i = m; i >= 1; i--) ord[cnt[prf[dro[i]]]--] = dro[i];
p = 0;
for (int i = 1; i <= m; i++) {
if (prf[ord[i]] != prf[ord[i - 1]] || suf[ord[i]] != suf[ord[i - 1]]) p++;
rnk[ord[i]][j] = p;
}
}
}
int lcp(int x, int y, int d) {
if (!d) return 0;
int rlt = 0;
for (int i = 31 - __builtin_clz(d); i >= 0; i--) {
if (rlt + (1 << i) > d) continue;
int xx = x <= n ? x : anc(x - n, d - rlt - (1 << i)) + n;
int yy = y <= n ? y : anc(y - n, d - rlt - (1 << i)) + n;
if (rnk[xx][i] == rnk[yy][i]) {
rlt += 1 << i;
if (x <= n) x = fa[x][i];
if (y <= n) y = fa[y][i];
}
}
return rlt;
}
int query(int a, int b, int c, int d) {
int ab = lca(a, b), cd = lca(c, d);
if (dp[a] - dp[ab] < dp[c] - dp[cd]) {
a ^= c ^= a ^= c;
b ^= d ^= b ^= d;
ab ^= cd ^= ab ^= cd;
}
int del = dp[c] - dp[cd];
int rlt = lcp(a, c, del);
if (rlt < del) return rlt;
a = anc(a, del);
int d1 = dp[a] - dp[ab] + 1, d2 = dp[d] - dp[cd] + 1;
if (d1 >= d2) return rlt + lcp(a, d + n, d2);
int md = anc(d, d2 - d1);
int add = lcp(a, md + n, d1);
rlt += add;
if (add < d1) return rlt;
d1 = dp[b] - dp[ab], d2 = dp[d] - dp[md];
if (d1 > d2)
b = anc(b, d1 - d2);
else
d = anc(d, d2 - d1);
return rlt + lcp(b + n, d + n, min(d1, d2));
}
char s[300300];
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
add_edge(x, y, i);
add_edge(y, x, i + n);
}
dfs(1);
build(s);
int q, a, b, c, d;
scanf("%d", &q);
while (q--) {
scanf("%d %d %d %d", &a, &b, &c, &d);
printf("%d\n", query(a, b, c, d));
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5010;
long long a[maxn];
int p[maxn];
int dp[maxn];
int main() {
int n;
scanf("%d", &n);
memset(p, 0, sizeof(p));
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
while (a[i] % 2 == 0) a[i] /= 2, p[i]++;
}
int tmp = 1;
for (int i = 0; i < n; i++) {
dp[i] = 1;
for (int j = 0; j < i; j++) {
if (!p[i]) {
if (a[j] % a[i] == 0) dp[i] = max(dp[j] + 1, dp[i]);
} else {
if (i - j - 1 < p[i]) {
if ((p[i] - p[j]) == (i - j) && a[j] % a[i] == 0)
dp[i] = max(dp[j] + 1, dp[i]);
} else {
if (a[j] % a[i] == 0) dp[i] = max(dp[j] + 1, dp[i]);
}
}
}
tmp = max(dp[i], tmp);
}
printf("%d\n", n - tmp);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> g;
vector<int> chosen;
void dfs(int cur, int chose) {
chosen[cur] = chose;
for (int i = 0; i < (int)g[cur].size(); i++) {
if (!chosen[g[cur][i]]) {
dfs(g[cur][i], (chose == 1 ? -1 : 1));
}
}
}
void solve() {
int n, m;
cin >> n >> m;
g.assign(n, vector<int>());
chosen.assign(n, 0);
int mx = 0;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(0, 1);
int count = 0;
for (int i = 0; i < n; i++) {
if (chosen[i] == 1) count++;
}
int new_count = min(count, n - count);
cout << new_count << endl;
for (int i = 0; i < n; i++) {
if (new_count != count) chosen[i] = (chosen[i] == 1 ? -1 : 1);
if (chosen[i] == 1) cout << i + 1 << " ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
srand(chrono::steady_clock::now().time_since_epoch().count());
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
void O_o() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
bool prime(int n, int i) {
if (i == n) return true;
if (n % i == 0) return false;
prime(n, i + 1);
}
unsigned long long sum, sum1, sum2, j, l, s, count1, count2, rem1, rem2,
abdallah, kamal, rashed;
struct cont {
unsigned long long a, b, c, d;
};
bool acompare(cont l, cont r) { return l.d < r.d; }
cont arr[1000010], arr1[1000010], arr3[1000010];
int main() {
unsigned long long n, m, a1, b1, c1;
cin >> n >> m;
for (int i = 0; i < int(n); i++) {
cin >> a1 >> b1 >> c1;
if (b1 >= c1)
arr[j].a = a1, arr[j].b = b1, arr[j].c = c1, arr[j].d = b1 - c1, j++,
sum1 += a1;
else if (b1 < c1)
arr1[l].a = a1, arr1[l].b = b1, arr1[l].c = c1, arr1[l].d = c1 - b1,
arr3[l].a = a1, arr3[l].b = b1, arr3[l].c = c1, arr3[l].d = c1 - b1, l++,
sum2 += a1;
}
sum = sum1 + sum2;
if (sum % m != 0)
abdallah = (sum / m) + 1;
else
abdallah = sum / m;
if (sum1 % m != 0)
rashed = (sum1 / m) + 1;
else
rashed = sum1 / m;
if (sum2 % m != 0)
kamal = (sum2 / m) + 1;
else
kamal = sum2 / m;
if (double(sum) / double(m) <= 1.0) {
for (int i = 0; i < int(j); i++)
count1 += (arr[i].b * arr[i].a), count2 += (arr[i].c * arr[i].a);
for (int i = 0; i < int(l); i++)
count1 += (arr1[i].b * arr1[i].a), count2 += (arr1[i].c * arr1[i].a);
cout << max(count1, count2) << '\n';
return 0;
} else if (abdallah == kamal + rashed) {
for (int i = 0; i < int(j); i++) count1 += (arr[i].b * arr[i].a);
for (int i = 0; i < int(l); i++) count1 += (arr1[i].c * arr1[i].a);
cout << count1 << endl;
return 0;
}
sort(arr, arr + j, acompare);
sort(arr1, arr1 + l, acompare);
sort(arr3, arr3 + l, acompare);
rem1 = sum2 % m;
for (int i = 0; i < int(l); i++) {
if (arr1[i].a >= rem1 && rem1 != 0) {
count1 += (rem1 * arr1[i].b);
arr1[i].a -= rem1;
rem1 = 0;
count1 += (arr1[i].a * arr1[i].c);
} else if (arr1[i].a < rem1) {
count1 += (arr1[i].b * arr1[i].a);
rem1 -= arr1[i].a;
} else if (rem1 == 0)
count1 += (arr1[i].c * arr1[i].a);
}
for (int i = 0; i < int(j); i++) count1 += (arr[i].a * arr[i].b);
rem2 = sum1 % m;
for (int i = 0; i < int(j); i++) {
if (arr[i].a >= rem2 && rem2 != 0) {
count2 += (rem2 * arr[i].c);
arr[i].a -= rem2;
rem2 = 0;
count2 += (arr[i].a * arr[i].b);
} else if (arr[i].a < rem2) {
count2 += (arr[i].a * arr[i].c);
rem2 -= arr[i].a;
} else if (rem2 == 0)
count2 += (arr[i].a * arr[i].b);
}
for (int i = 0; i < int(l); i++) count2 += (arr3[i].a * arr3[i].c);
cout << max(count1, count2) << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c, ans = 0, ans1 = 0, a1, b1, c1;
cin >> a >> b >> c;
a1 = a;
b1 = b;
c1 = c;
while (a >= 1 && b >= 2) {
ans += 3;
a--;
b -= 2;
}
while (b >= 1 && c >= 2) {
ans += 3;
b--;
c -= 2;
}
while (b1 >= 1 && c1 >= 2) {
ans1 += 3;
b1--;
c1 -= 2;
}
while (a1 >= 1 && b1 >= 2) {
ans1 += 3;
a1--;
b1 -= 2;
}
cout << max(ans, ans1) << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ans = 0, n, m, k;
cin >> n >> m >> k;
int i, j;
vector<vector<char> > O(n + 1, vector<char>(m));
vector<vector<int> > A(n + 1, vector<int>(m + 1));
vector<vector<int> > B(n + 1, vector<int>(m + 1));
for (i = 1; i <= n; i++) {
for (j = 0; j < m; j++) cin >> O[i][j];
}
for (i = 2; i < n; i++)
for (j = 1; j < m - 1; j++)
if (O[i][j] == '1' && O[i][j - 1] == '1' && O[i][j + 1] == '1' &&
O[i - 1][j] == '1' && O[i + 1][j] == '1')
A[i][j + 1] = 1;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) A[i][j] = A[i][j] + A[i][j - 1];
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) B[i][j] = B[i - 1][j] + A[i][j];
}
j = 1;
for (int d = 1; d <= n - 2; d++) {
for (int z = 3; z <= n; z++) {
j = 1;
for (i = 1; i <= m; i++) {
while (j <= m &&
B[z - 1][j - 1] + B[d][i] - B[z - 1][i] - B[d][j - 1] < k)
j++;
if (j > m) {
break;
}
ans += m - j + 1;
}
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long T;
cin >> T;
for (long long tc = 1; tc <= T; ++tc) {
long long n;
cin >> n;
vector<long long> need(n + 1, true), spare;
for (long long i = 0; i < n; ++i) {
long long a;
cin >> a;
if (a <= n && need[a])
need[a] = false;
else
spare.push_back((a + 2 - 1) / 2 - 1);
}
sort(spare.begin(), spare.end());
long long ans = (long long)spare.size();
for (long long i = n; i >= 1; --i) {
if (need[i]) {
if (spare.back() >= i)
spare.pop_back();
else
ans = -1;
}
}
cout << ans << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int len;
string s, temp;
stack<int> proc, coun;
int numz[5005], numcnt;
int main() {
while (cin >> temp) s += temp;
len = s.size();
int cnt = 0;
for (int i = 0; i < len; i++) {
i++;
if (s[i] == '/') {
i++;
if (s[i + 1] == 'a') {
i += 5;
proc.pop();
numz[numcnt++] = cnt;
if (proc.size()) cnt = coun.top();
coun.pop();
} else if (s[i + 1] == 'r') {
i += 2;
proc.pop();
} else {
i += 2;
proc.pop();
cnt++;
}
} else {
if (s[i + 1] == 'a') {
i += 5;
if (proc.size()) coun.push(cnt);
cnt = 0;
proc.push(1);
} else if (s[i + 1] == 'r') {
i += 2;
proc.push(2);
} else {
i += 2;
proc.push(3);
}
}
}
sort(numz, numz + numcnt);
for (int i = 0; i < numcnt; i++) {
printf("%d", numz[i]);
if (i < numcnt - 1)
printf(" ");
else
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 1000000;
int phi[N + 100], s[N + 100], ps[N + 100], pis[N + 100], pi2s[N + 100];
int t;
long long ans, n, m;
int main() {
for (int i = 1; i <= N; i++) phi[i] = i;
for (int i = 1; i <= N; i++)
for (int j = i + i; j <= N; j += i) phi[j] -= phi[i];
for (int i = 1; i <= N; i++)
for (int j = i; j <= N; j += i) {
s[j] = (s[j] + 1ll * (i - 1) * phi[j / i]) % mod;
}
for (int i = 1; i <= N; i++) {
ps[i] = (ps[i - 1] + s[i]) % mod;
pis[i] = (pis[i - 1] + 1ll * s[i] * i) % mod;
pi2s[i] = (pi2s[i - 1] + 1ll * s[i] * i % mod * i) % mod;
}
for (scanf("%d", &t); t; t--) {
scanf("%I64d%I64d", &n, &m);
if (n > m) swap(n, m);
ans = ((n + 1) * (m + 1) % mod * ps[n] - (n + m + 2) * pis[n] + pi2s[n]) %
mod * 2 % mod;
ans += -((-1 + n) * n % mod * (1 + n) % mod * (2 + n) % mod *
((3 + m * (27 - 6 * n) + n * (-17 + 4 * n)) % mod)) %
mod * powmod(180, mod - 2) % mod;
ans += (-n * (n + 1) % mod * (n + 2) % mod) *
((3 * n * n + n - 4 - 5 * m * (1 + n)) % mod) % mod *
powmod(60, mod - 2) % mod;
ans %= mod;
if (ans < 0) ans += mod;
printf("%I64d\n", ans);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int m, i, a, b;
int Grup[10], Nr[10], maxim, T[10][10], minval = 0x3f3f3f3f;
int N[5];
int n1, n2, n3;
int get_number(char Nume[]) {
if (Nume[0] == 'A') return 1;
if (Nume[0] == 'T') return 4;
if (Nume[0] == 'D') return 5;
if (Nume[0] == 'S') return 6;
if (Nume[0] == 'H') return 7;
if (Nume[1] == 'h') return 2;
return 3;
}
void citire(int &a, int &b) {
char Nume1[20], Nume2[20];
scanf("%s", &Nume1);
scanf("%s", &Nume2);
scanf("%s", &Nume2);
a = get_number(Nume1);
b = get_number(Nume2);
}
void bt(int act) {
if (act == 8) {
if ((Nr[1] < 1) || (Nr[2] < 1) || (Nr[3] < 1)) return;
act = 0;
for (int i = 1; i <= 7; i++) {
for (int j = 1; j <= 7; j++) {
if ((Grup[i] == Grup[j]) && (T[i][j])) act++;
}
}
int min_val;
int val_min = 0x3f3f3f3f, val_max = 0;
for (int i = 1; i <= 3; i++) {
if (N[i] / Nr[i] < val_min) val_min = N[i] / Nr[i];
}
for (int i = 1; i <= 3; i++) {
if (N[i] / Nr[i] > val_max) {
val_max = N[i] / Nr[i];
}
}
if (val_max - val_min == minval) {
if (maxim < act) maxim = act;
}
if (val_max - val_min < minval) {
maxim = act;
minval = val_max - val_min;
}
} else {
Nr[1]++;
Grup[act] = 1;
bt(act + 1);
Nr[1]--;
Nr[2]++;
Grup[act] = 2;
bt(act + 1);
Nr[2]--;
Nr[3]++;
Grup[act] = 3;
bt(act + 1);
Nr[3]--;
}
}
int main() {
scanf("%d", &m);
for (i = 1; i <= m; i++) {
citire(a, b);
T[a][b] = 1;
}
scanf("%d %d %d", &N[1], &N[2], &N[3]);
bt(1);
printf("%d %d", minval, maxim);
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 1e5 + 50;
char s[N];
long long n, Ans;
int main() {
scanf("%I64d%s", &n, s + 1);
for (int i = 1; i <= n; i++) Ans += i * (s[i] % 2 == 0);
printf("%I64d\n", Ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string addOne(string s) {
string temp = "";
long long carry = 1;
for (long long i = s.size() - 1; i >= 0; i--) {
long long dig = (s[i] - '0') + carry;
carry = dig / 10;
temp += ('0' + (dig % 10));
}
if (carry) temp += '1';
reverse(temp.begin(), temp.end());
return temp;
}
int32_t main() {
long long k;
cin >> k;
string s;
cin >> s;
if (k > (long long)s.size()) {
cout << 1;
for (long long i = 0; i < k - 1; i++) cout << 0;
return 0;
}
s = addOne(s);
if (s.size() % k) {
string temp = "1";
for (long long i = 0; i < k - 1; i++) temp += '0';
for (long long i = 0; i < (long long)((s.size()) + (k - 1)) / k; i++) {
cout << temp;
}
} else {
string w = "", res = "";
for (long long i = 0; i < k; i++) w += s[i];
for (long long i = 0; i < (long long)s.size() / k; i++) res += w;
if (res >= s) {
cout << res << endl;
} else {
w = "";
res = "";
for (long long i = 0; i < k; i++) w += s[i];
w = addOne(w);
for (long long i = 0; i < (long long)s.size() / k; i++) res += w;
cout << res << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 10000 + 10;
int t[MAXN];
long long int mod = 1000 * 1000 * 1000 + 7;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
int a = -1, b = -1;
for (int i = 0; i < n; i++) {
char c;
cin >> c;
int x, y;
cin >> x >> y;
if (c == '+') {
if (a == -1 && b == -1) {
a = x;
b = y;
} else {
if ((x <= a && y <= b) || (x <= b && y <= a)) {
continue;
} else if ((a <= x && b <= y) || (a <= y && b <= x)) {
a = x;
b = y;
} else {
int t = max(a, b);
int d = min(a, b);
int c = max(x, y);
int e = min(x, y);
a = max(t, c);
b = max(d, e);
}
}
} else {
if ((a <= x && b <= y) || (a <= y && b <= x))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int Map[1010][1010], Move[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
char s[110];
int main() {
int i, x = 105, y = 105, x1, y1, len, cnt, flag = 0;
scanf("%s", s);
memset(Map, 0, sizeof(Map));
Map[105][105] = 1;
len = strlen(s);
for (int i = 0; i < len; i++) {
if (s[i] == 'L') {
y--;
if (Map[x][y]) {
flag = 1;
break;
}
Map[x][y] = 1;
} else if (s[i] == 'R') {
y++;
if (Map[x][y]) {
flag = 1;
break;
}
Map[x][y] = 1;
} else if (s[i] == 'U') {
x--;
if (Map[x][y]) {
flag = 1;
break;
}
Map[x][y] = 1;
} else if (s[i] == 'D') {
x++;
if (Map[x][y]) {
flag = 1;
break;
}
Map[x][y] = 1;
}
cnt = 0;
for (int i = 0; i < 4; i++) {
x1 = x + Move[i][0];
y1 = y + Move[i][1];
if (Map[x1][y1]) cnt++;
}
if (cnt != 1) {
flag = 1;
break;
}
}
if (flag)
puts("BUG");
else
puts("OK");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d, e, f, g, h;
char cd;
string s, s1;
cin >> a >> b;
vector<pair<long long, long long> > v;
cin >> s;
for (int i = 0; i < a; i++) {
v.push_back(make_pair(int(s[i]) - 96, i));
}
sort(v.begin(), v.end());
for (int i = 0; i < b; i++) {
v[i].first = -1;
}
int aux;
for (int i = 0; i < a; i++) {
aux = v[i].first;
v[i].first = v[i].second;
v[i].second = aux;
}
sort(v.begin(), v.end());
for (int i = 0; i < a; i++) {
if (v[i].second != -1) {
cout << char(v[i].second + 96);
}
}
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5, M = 505, OO = 0x3f3f3f3f;
string s;
int t, n;
int main() {
cin >> t;
while (t--) {
cin >> n;
bool f = 0;
int z = 0;
int o = 0;
for (int i = 0; i < n; ++i) {
cin >> s;
for (int j = 0; j < s.size(); ++j) {
if (s[j] == '0')
z++;
else
o++;
}
if (s.size() % 2) f = 1;
}
if (!f && z % 2 && o % 2)
cout << n - 1 << endl;
else
cout << n << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> c[11];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int a[n + 5];
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
c[a[i] % 10].push_back(i);
}
for (int i = 9; i >= 1; i--) {
if (c[i].size()) {
int x = 10 - i;
for (int j = 0; j < c[i].size(); j++) {
if (k - x < 0) {
break;
}
a[c[i][j]] += x;
k -= x;
}
}
}
for (int i = 0; i < n; i++) {
while (k && a[i] < 100) {
a[i]++;
k--;
}
}
int count = 0;
for (int i = 0; i < n; i++) {
count += a[i] / 10;
}
printf("%d", count);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct ss {
int x, index;
};
ss c[200050];
int a[200050];
bool cmp(ss x, ss y) { return x.x < y.x; }
int find(int x) {
int left = 1;
int right = n;
while (left <= right) {
int mid = (left + right) / 2;
if (c[left].x == x) return c[left].index;
if (c[mid].x < x) {
left = mid + 1;
} else {
if (c[right].x == x) return c[right].index;
if (c[mid].x == x) return c[mid].index;
right = mid + 1;
}
}
if (c[left].x == x) return c[left].index;
if (c[right].x == x) return c[right].index;
}
int main() {
cin >> n;
int flag = -1;
for (int i = 1; i <= n; i++) {
cin >> a[i];
ss temp;
temp.index = i;
temp.x = a[i];
c[i] = temp;
if (a[i] == n) flag = i;
}
sort(c, c + n, cmp);
bool check = true;
int left = flag - 1;
int right = flag + 1;
for (int i = n - 1; i >= 1; i--) {
int pos = find(i);
if (pos == left)
left--;
else if (pos == right)
right++;
else {
check = false;
break;
}
}
if (check)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, i, j, sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0, mmsum = 0;
scanf("%d", &n);
int A[n][n];
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
scanf("%d", &A[i][j]);
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i + j == (n + 1)) {
sum2 += A[i][j];
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i == j) {
sum1 += A[i][j];
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (j == ((n / 2) + 1)) {
sum3 += A[i][j];
}
}
}
for (i = 1; i <= n; i++) {
if (i == ((n / 2) + 1)) {
for (j = 1; j <= n; j++) {
sum4 += A[i][j];
}
}
}
for (i = 1; i <= n; i++) {
if (i == (n - (n / 2))) {
for (j = 1; j <= n; j++) {
if (j == (n - (n / 2))) {
mmsum = A[i][j];
}
}
}
}
printf("%d\n", (sum1 + sum2 + sum3 + sum4) - (mmsum * 3));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void code() {
long long n = 7;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
cout << a[0] << " " << a[1] << " " << a[6] - a[0] - a[1] << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
code();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 9;
int main() {
ios_base::sync_with_stdio(0);
long long n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
vector<long long> ans = {a[0], a[0]};
for (int i = 1; i < n; i++) {
long long mn = 2e18, pos;
for (int j = 0; j < ans.size() - 1; j++) {
long long now = max(abs(a[i] - ans[j]), abs(a[i] - ans[j + 1]));
if (now < mn) {
pos = j + 1;
mn = now;
}
}
ans.insert(ans.begin() + pos, a[i]);
}
for (int i = 0; i < ans.size() - 1; i++) cout << ans[i] << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9, PI = acos(-1);
const int mod = int(1e9) + 7, MX = int(2e5) + 10;
int n, pos = 0;
vector<int> Adj[110], ans;
void solve() {
scanf("%d", &n);
for (int i = 0, a; i < n; i++) {
scanf("%d", &a);
if (a <= 0) continue;
Adj[a].push_back(i + 1);
}
for (int i = 1; i <= 100; i++) {
pos = lower_bound(Adj[i].begin(), Adj[i].end(), pos) - Adj[i].begin();
if (pos == int(Adj[i].size())) break;
ans.push_back(pos = Adj[i][pos]);
}
printf("%d\n", int(ans.size()));
for (int a : ans) printf("%d ", 2000 + a);
}
int main() { solve(); }
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
cout << n << " ";
for (i = 1; i <= n - 1; i++) cout << i << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
long long MOD = 1e9 + 7;
double eps = 1e-6;
long long mpow(long long a, long long b) {
if (a == 0) return 0;
if (b >= (MOD - 1)) b %= (MOD - 1);
if (b == 0) return 1;
long long t1 = mpow(a, b / 2);
t1 *= t1;
t1 %= MOD;
if (b % 2) t1 *= a;
t1 %= MOD;
return t1;
}
long long mpow(long long a, long long b, long long p) {
if (b == 0) return 1;
long long t1 = mpow(a, b / 2, p);
t1 *= t1;
t1 %= p;
if (b % 2) t1 *= a;
t1 %= p;
return t1;
}
long long modinverse(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long range(long long l, long long r) { return l + rand() % (r - l + 1); }
long long rev(long long v) { return mpow(v, MOD - 2); }
void solve() {
long long n;
cin >> n;
if (n <= 2)
cout << -1 << "\n";
else if (n == 3) {
cout << "1 2 8"
<< "\n";
cout << "7 3 4"
<< "\n";
cout << "5 6 9"
<< "\n";
} else {
long long val = 1;
long long a[n][n];
long long n1 = n;
while (n > 4) {
for (long long i = 0; i < n; i++) a[i][n - 1] = val++;
for (long long i = 0; i < n - 1; i++) a[n - 1][i] = val++;
if (n == 5) {
swap(a[n - 1][1], a[n - 1][n - 2]);
}
n--;
}
n = n1;
a[2][1] = val++;
a[3][3] = val++;
a[0][1] = val++;
a[0][0] = val++;
a[1][1] = val++;
a[0][2] = val++;
a[1][0] = val++;
a[3][1] = val++;
a[1][2] = val++;
a[2][3] = val++;
a[2][2] = val++;
a[0][3] = val++;
a[3][0] = val++;
a[2][0] = val++;
a[1][3] = val++;
a[3][2] = val++;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) cout << a[i][j] << " ";
cout << "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
for (long long i = 0; i < t; i++) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a, i = 0, last = 0, current = 0;
int main() {
int x, y, z = 0, a = 0, c = 1;
long long b;
cin >> x;
for (int i = 0; i < x; i++) {
cin >> y >> z;
a = z * 2;
c = y * 2;
if (a > c) {
if (z > c)
cout << z * z << endl;
else
cout << c * c << endl;
} else {
if (y > a)
cout << y * y << endl;
else
cout << a * a << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int32_t n, k, len;
std::cin >> n >> k >> len;
if (len == 1) {
std::cout << 0;
return 0;
}
int32_t* arr = new int32_t[n];
for (int32_t i = 0; i < n; i++) {
std::cin >> arr[i];
arr[i] -= arr[i] == -1 ? 0 : 1;
}
int32_t** dp = new int32_t*[n];
dp[0] = new int32_t[k];
for (int32_t i = 0; i < k; i++)
dp[0][i] = arr[0] == -1 ? 1 : (arr[0] == i ? 1 : 0);
int32_t* total_sum_pref = new int32_t[n + 1];
total_sum_pref[0] = 0;
total_sum_pref[1] = arr[0] == -1 ? k : 1;
int32_t** color_sum_pref = new int32_t*[k];
for (int32_t i = 0; i < k; i++) {
color_sum_pref[i] = new int32_t[n + 1];
color_sum_pref[i][0] = 0;
color_sum_pref[i][1] = dp[0][i];
}
int32_t last_definte = arr[0] == -1 ? -1 : 0;
int32_t* last_occ = new int32_t[k];
for (int32_t i = 0; i < k; i++) last_occ[i] = -1;
for (int32_t i = 1; i < n; i++) {
dp[i] = new int32_t[k];
total_sum_pref[i + 1] = total_sum_pref[i];
for (int32_t j = 0; j < k; j++) {
color_sum_pref[j][i + 1] = color_sum_pref[j][i];
if (arr[i] != j && arr[i] != -1)
dp[i][j] = 0;
else {
if (last_definte == -1 || i - last_definte >= len) {
dp[i][j] = (total_sum_pref[i] -
total_sum_pref[std::max(i - len + 1, 0)] + 998244353) %
998244353;
dp[i][j] -=
(color_sum_pref[j][i] -
color_sum_pref[j][std::max(i - len + 1, 0)] + 998244353) %
998244353;
dp[i][j] = (dp[i][j] + 998244353) % 998244353;
if (i < len - 1) dp[i][j] = (dp[i][j] + 1) % 998244353;
} else {
if (j != arr[last_definte]) {
dp[i][j] =
(total_sum_pref[i] - total_sum_pref[last_definte] + 998244353) %
998244353;
dp[i][j] -= (color_sum_pref[j][i] -
color_sum_pref[j][last_definte] + 998244353) %
998244353;
dp[i][j] = (dp[i][j] + 998244353) % 998244353;
} else {
int32_t last = i - len;
bool exist_other = false;
for (int32_t p = 0; p < k; p++)
if (p != arr[last_definte]) {
last = std::max(last, last_occ[p] - 1);
if (last_occ[p] != -1) exist_other = true;
}
dp[i][j] = (total_sum_pref[i] -
total_sum_pref[std::max(last + 1, 0)] + 998244353) %
998244353;
dp[i][j] -= (color_sum_pref[j][i] -
color_sum_pref[j][std::max(last + 1, 0)] + 998244353) %
998244353;
dp[i][j] = (dp[i][j] + 998244353) % 998244353;
if (i < len - 1 && !exist_other)
dp[i][j] = (dp[i][j] + 1) % 998244353;
}
}
}
total_sum_pref[i + 1] += dp[i][j];
total_sum_pref[i + 1] %= 998244353;
color_sum_pref[j][i + 1] += dp[i][j];
color_sum_pref[j][i + 1] %= 998244353;
}
if (arr[i] != -1) {
last_definte = i;
last_occ[arr[i]] = i;
}
}
int32_t answer = 0;
for (int32_t i = 0; i < k; i++) {
answer += dp[n - 1][i];
answer %= 998244353;
}
std::cout << answer;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long GCD(long a, long b) {
if (b == 0) return a;
return GCD(b, a % b);
}
long long bigMod(long long b, long long p, long long m) {
if (b == 1) return b;
if (p == 0) return 1;
if (p == 1) return b;
if (p % 2 == 0) {
long long temp = bigMod(b, p / 2, m);
return (temp * temp) % m;
} else
return (b * bigMod(b, p - 1, m)) % m;
}
long long modInverse(long long a, long long m) { return bigMod(a, m - 2, m); }
int main() {
int n;
while (cin >> n) {
vector<long long> v;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
long long serveTime = 0;
int ans = 0;
for (int i = 0; i < v.size(); i++) {
if (serveTime <= v[i])
ans++;
else
continue;
serveTime += v[i];
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(false);
using namespace std;
long long d, k, a, b, t, k_cost_walk, k_cost_drive;
cin >> d >> k >> a >> b >> t;
if (a >= b) {
cout << d * b << "\n";
return 0;
}
k_cost_walk = k * b;
k_cost_drive = k * a + t;
if (k_cost_walk <= k_cost_drive || d <= k) {
if (d <= k) {
cout << d * a << "\n";
} else {
cout << k * a + (d - k) * b << "\n";
}
return 0;
}
long long m = d / k;
long long car_time = m * k * a + (m - 1) * t;
long long rest = min(t + (d % k) * a, (d % k) * b);
cout << car_time + rest << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
int n, t, x, mx, temp1, temp2;
int main() {
scanf("%d", &n);
while (n--) {
scanf("%d%d", &temp1, &temp2);
x -= temp1 - t;
if (x < 0)
x = temp2;
else
x += temp2;
if (x > mx) mx = x;
t = temp1;
}
printf("%d %d\n", t + x, mx);
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define lowbit(x) ((x)&(-(x)))
#define mid ((l+r)>>1)
#define lson lc[rt], l, mid
#define rson rc[rt], mid+1, r
#define fors(i, a, b) for(int i = (a); i < (b); ++i)
using namespace std;
const int maxn = 2e5 + 5;
const int lim = 1e9 + 7;
const int inf = 0x3f3f3f3f;
int mx[maxn*32], lc[maxn*32], rc[maxn*32], tot = 0, root = 0;
void update(int &rt, int l, int r, int pos, int val){
if(!rt){
rt = ++tot;
}
if(l == r){
mx[rt] = max(mx[rt], val); return;
}
if(pos <= mid) update(lson, pos, val);
else update(rson, pos, val);
mx[rt] = max(mx[lc[rt]], mx[rc[rt]]);
return;
}
int qry(int rt, int l, int r, int L, int R){
if(!rt) return 0;
if(L <= l && r <= R) return mx[rt];
int res = 0;
if(L <= mid) res = max(res, qry(lson, L, R));
if(R > mid) res = max(res, qry(rson, L, R));
return res;
}
int n, m;
int a[maxn];
ll s[maxn], key[maxn];
bool check(int x, int i){
int pos = qry(root, 1, lim, 1, x);
ll val = s[pos] + (ll)(i-pos)*x;
return val >= s[i];
}
int ask[maxn], ans[maxn];
#define P pair<int,int>
vector<P> fuck;
set<int> mp;
int main()
{
cin>>n>>m;
fors(i,1,n+1) scanf("%d", &a[i]), s[i] = s[i-1] + a[i];
fors(i,1,m+1) scanf("%d", &ask[i]);
if(n==1){
fors(i,1,m+1) printf("0 "); return 0;
}
update(root, 1, lim, 1, 0);
fors(i,1,n){
int l = 1, r = lim;
while(l <= r){
if(check(mid, i)) key[i] = mid, r = mid-1;
else l = mid+1;
}
update(root, 1, lim, key[i], i);
//cout<<"i:"<<i<<" key:"<<key[i]<<endl;
fuck.pb(P(key[i], i));
}
sort(fuck.begin(), fuck.end());
int cur = 0;
fors(i,0,n+1) mp.insert(i);
int p = fuck.size()-1;
for(int i = m; i >= 1; --i){
while(p >= 0 && fuck[p].first > ask[i]){
int x = fuck[p].second;
auto it = mp.lower_bound(x);
auto ip = it;
int l = *(--it), r = *(++ip);
cur = max(r-l-1, cur); mp.erase(x);
p--;
}
ans[i] = cur;
}
fors(i,1,m+1) printf("%d ", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, y, z, p;
cin >> n >> m >> x >> y >> z >> p;
x %= 4;
z %= 4;
y %= 2;
int n1 = n, m1 = m;
for (int i = 1; i <= p; i++) {
n = n1;
m = m1;
int xk, yk;
cin >> xk >> yk;
int xv, yv;
xv = xk;
yv = yk;
for (int j = 1; j <= x; j++) {
xv = yk, yv = n - xk + 1;
swap(n, m);
xk = xv;
yk = yv;
}
xk = xv;
yk = yv;
if (y == 1) yv = m - yk + 1, xv = xk;
xk = xv;
yk = yv;
for (int j = 1; j <= z; j++) {
xv = m - yk + 1, yv = xk;
swap(n, m);
xk = xv;
yk = yv;
}
cout << xv << ' ' << yv << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 310;
const int M = 210005;
int num[N], r[N], sz = 0, sr = 0, ord1[N], ord2[N];
bool divide[40005], vis[N];
int head[N], Next[M], V[M], C[M], cnt = 1, dep[N];
vector<int> ans[N / 3];
inline void prime() {
for (int i = 2; i <= 40000; i++) {
if (!divide[i]) {
for (int j = 2; j <= 40000 / i; j++) divide[i * j] = 1;
}
}
}
inline void add(int x, int y, int w) {
V[++cnt] = y;
C[cnt] = w;
Next[cnt] = head[x];
head[x] = cnt;
}
inline void link(int x, int y, int w) {
add(x, y, w);
add(y, x, 0);
}
queue<int> Q;
inline bool BFS(int s, int t) {
memset(dep, -1, sizeof(dep));
dep[s] = 0;
Q.push(s);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = head[x]; i; i = Next[i]) {
if (dep[V[i]] == -1 && C[i]) {
dep[V[i]] = dep[x] + 1;
Q.push(V[i]);
}
}
}
return (dep[t] != -1);
}
inline int DFS(int x, int t, int flow) {
if (!flow || x == t) return flow;
int res = 0, d;
for (int i = head[x]; i; i = Next[i]) {
if (dep[V[i]] == dep[x] + 1 && C[i]) {
d = DFS(V[i], t, min(flow, C[i]));
C[i] -= d;
C[i ^ 1] += d;
res += d;
flow -= d;
if (!flow) break;
}
}
if (!res) dep[x] = -1;
return res;
}
inline void write(int x, int st, int la, int id) {
ans[id].push_back(ord1[x]);
vis[x] = 1;
for (int i = head[x]; i; i = Next[i]) {
if (V[i] == 0 || V[i] == sz * 2 + 1 || V[i] == st || V[i] == la ||
vis[V[i]])
continue;
if (x <= sz && C[i]) continue;
if (x > sz && !C[i]) continue;
write(V[i], st, x, id);
break;
}
}
int main() {
int n, k;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &k);
if (k % 2 == 1)
num[++sz] = k, ord1[sz] = i;
else
r[++sr] = k, ord2[sr] = i;
}
if (sz != sr) {
printf("Impossible\n");
return 0;
}
prime();
for (int i = sz + 1; i <= n; i++) num[i] = r[i - sz], ord1[i] = ord2[i - sz];
for (int i = 1; i <= sz; i++) link(0, i, 2);
for (int i = sz + 1; i <= n; i++) link(i, n + 1, 2);
for (int i = 1; i <= sz; i++) {
for (int j = sz + 1; j <= n; j++) {
if (!divide[num[i] + num[j]]) link(i, j, 1);
}
}
int check = 0;
while (BFS(0, n + 1)) check += DFS(0, n + 1, 2e9);
if (check != n) {
printf("Impossible\n");
return 0;
}
int cnt = 0;
for (int i = 1; i <= sz; i++) {
if (!vis[i]) {
cnt++;
write(i, i, 0, cnt);
}
}
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) {
int s = ans[i].size();
printf("%d ", s);
for (int j = 0; j < s; j++) {
printf("%d", ans[i][j]);
if (j != s - 1)
printf(" ");
else
printf("\n");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int a[200020], b[200020], c[200020], n;
int sum[200020 << 2];
void PushUp(int rt) { sum[rt] = sum[rt << 1] + sum[rt << 1 | 1]; }
void BuildTree(int l, int r, int rt) {
if (l == r) {
sum[rt] = 1;
return;
}
int m = (l + r) >> 1;
BuildTree(l, m, rt << 1);
BuildTree(m + 1, r, rt << 1 | 1);
PushUp(rt);
}
int Query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return sum[rt];
int m = (l + r) >> 1;
int ret = 0;
if (L <= m) ret += Query(L, R, l, m, rt << 1);
if (R > m) ret += Query(L, R, m + 1, r, rt << 1 | 1);
return ret;
}
void Update(int L, int R, int l, int r, int rt) {
if (L <= l && R >= r) {
sum[rt] = 0;
return;
}
int m = (l + r) >> 1;
if (L <= m) Update(L, R, l, m, rt << 1);
if (R > m) Update(L, R, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
int Query1(int x, int l, int r, int rt) {
if (l == r) {
sum[rt] = 0;
return l;
}
int res;
int m = (l + r) >> 1;
if (sum[rt << 1] >= x)
res = Query1(x, l, m, rt << 1);
else
res = Query1(x - sum[rt << 1], m + 1, r, rt << 1 | 1);
PushUp(rt);
return res;
}
void ReadData() {
int x;
BuildTree(1, n, 1);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
x++;
Update(x, x, 1, n, 1);
a[i] = Query(1, x, 1, n, 1);
}
BuildTree(1, n, 1);
for (int j = 1; j <= n; j++) {
scanf("%d", &x);
x++;
Update(x, x, 1, n, 1);
b[j] = Query(1, x, 1, n, 1);
}
BuildTree(1, n, 1);
int res = 0;
for (int i = n; i >= 1; i--) {
c[i] = (res + a[i] + b[i]) % (n - i + 1);
res = (res + a[i] + b[i]) / (n - i + 1);
}
}
int main() {
scanf("%d", &n);
ReadData();
for (int i = 1; i <= n; i++) {
printf("%d", Query1(c[i] + 1, 1, n, 1) - 1);
if (i == n)
printf("\n");
else
printf(" ");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (-1u) / 2;
const long long int INF2 = (-1ull) / 2;
int a, b, i, j, k, n, m, timer = 0, l, r, x, y;
int cnt = 0, fl = 0, a2, a3 = -1000000, ans = 0;
char s[5010][5010];
int d[5010][5010];
int main() {
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%s", s[i]);
cnt = 0;
for (j = m - 1; j >= 0; j--) {
if (s[i][j] == '1') {
cnt++;
} else
cnt = 0;
d[j][cnt]++;
}
}
cnt = 0;
for (j = 0; j < m; j++) {
fl = 0;
for (i = m; i >= 1; i--) {
fl += d[j][i];
cnt = max(cnt, (fl)*i);
}
}
printf("%d\n", cnt);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void read(register int *n) {
register char c;
*n = 0;
do {
c = getchar();
} while (c < '0' || c > '9');
do {
*n = c - '0' + *n * 10;
c = getchar();
} while (c >= '0' && c <= '9');
}
vector<string> rot(vector<string> V) {
vector<string> res(((int)(V[0]).size()), "");
for (register int j = (0); j < (int)(((int)(V[0]).size())); ++j)
for (int i = ((int)(V).size()) - 1; i >= 0; i--) res[j] += V[i][j];
return res;
}
int main(int argv, char **argc) {
int n;
int next = 1;
cin >> n;
vector<int> res;
for (register int i = (1); i < (int)(n + 1); ++i) {
int x;
cin >> x;
if (x == next) {
res.push_back(i + 2000);
next++;
}
}
cout << ((int)(res).size()) << endl;
if (!res.empty()) {
for (register int i = (0); i < (int)(((int)(res).size())); ++i)
cout << res[i] << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long int n, k, i, j, sum = 0;
cin >> n >> k;
long long int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = n - 1; i > 0; i--) {
sum += ((k - a[i]) / a[0]);
}
cout << sum << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int depth[100005], sz[100005], p[100005][20], ans[100005], n, m;
set<int> g[100005];
int parcentroid[100005];
void dfs1(int node, int par) {
depth[node] = depth[par] + 1;
p[node][0] = par;
for (int i = 1; i < 20; i++) p[node][i] = p[p[node][i - 1]][i - 1];
for (auto it : g[node]) {
if (it != par) dfs1(it, node);
}
}
void dfs(int node, int par) {
sz[node] = 1;
for (auto it : g[node]) {
if (it != par) {
dfs(it, node);
sz[node] += sz[it];
}
}
}
int find_centroid(int node, int par, int cnt) {
for (auto it : g[node]) {
if (it == par) continue;
if (sz[it] > cnt / 2) return find_centroid(it, node, cnt);
}
return node;
}
void decompose(int node, int par) {
dfs(node, node);
int centroid = find_centroid(node, node, sz[node]);
parcentroid[centroid] = par;
for (auto it : g[centroid]) {
g[it].erase(centroid);
decompose(it, centroid);
}
g[centroid].clear();
}
int lca(int x, int y) {
if (depth[x] > depth[y]) swap(x, y);
for (int i = 20 - 1; i >= 0; i--) {
if ((depth[y] - (1 << i)) >= depth[x]) y = p[y][i];
}
if (x == y) return x;
for (int i = 20 - 1; i >= 0; i--) {
if (p[x][i] != p[y][i]) {
x = p[x][i];
y = p[y][i];
}
}
return p[x][0];
}
int dist(int x, int y) {
return (depth[x] + depth[y] - (2 * depth[lca(x, y)]));
}
void update(int node) {
int cur = node;
while (cur) {
ans[cur] = min(ans[cur], dist(node, cur));
cur = parcentroid[cur];
}
}
int query(int node) {
int cur = node, res = 10000000;
while (cur) {
res = min(res, ans[cur] + dist(node, cur));
cur = parcentroid[cur];
}
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].insert(y);
g[y].insert(x);
}
dfs1(1, 0);
decompose(1, 0);
for (int i = 1; i <= n; i++) ans[i] = 10000000;
update(1);
while (m--) {
int t, x;
scanf("%d%d", &t, &x);
if (t == 1)
update(x);
else {
int res = query(x);
printf("%d\n", res);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int n, a[100000 + 2], b[100000 + 2];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
b[i] = a[i];
}
std::sort(b, b + n);
int cnt = 0;
for (int i = 0; i < n; i++) cnt += (a[i] != b[i]);
if (cnt == 0 || cnt == 2)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
template <class T>
inline void umin(T &x, T y) {
x = x < y ? x : y;
}
template <class T>
inline void umax(T &x, T y) {
x = x > y ? x : y;
}
inline unsigned int R() {
static unsigned int seed = 416;
return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
const int N = 1020;
int n, m, a[N][N];
struct QQ {
int s[N], n;
void init(int *a, int nn) {
n = nn;
for (register int i = (1); i <= (n); i++) s[i] = a[i];
sort(s + 1, s + n + 1);
n = unique(s + 1, s + n + 1) - s - 1;
}
int q(int x) { return lower_bound(s + 1, s + n + 1, x) - s; }
int query1(int x) { return q(x) - 1; }
int query2(int x) { return n - q(x); }
} l[N], r[N];
int main() {
read(n);
read(m);
for (register int i = (1); i <= (n); i++)
for (register int j = (1); j <= (m); j++) read(a[i][j]);
static int s[N];
for (register int i = (1); i <= (n); i++) {
for (register int j = (1); j <= (m); j++) s[j] = a[i][j];
l[i].init(s, m);
}
for (register int j = (1); j <= (m); j++) {
for (register int i = (1); i <= (n); i++) s[i] = a[i][j];
r[j].init(s, n);
}
for (register int i = (1); i <= (n); i++) {
for (register int j = (1); j <= (m); j++) {
printf("%d ", 1 + max(l[i].query1(a[i][j]), r[j].query1(a[i][j])) +
max(l[i].query2(a[i][j]), r[j].query2(a[i][j])));
}
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
long long int i, j, maxi, n, maxi1, mini1, sum;
for (i = 0; i < t; i++) {
maxi = -100;
maxi1 = -10000;
mini1 = 1000000001;
cin >> n;
long long int a[n], b[n];
for (j = 0; j < n; j++) {
cin >> a[j];
b[j] = a[j];
}
for (j = 0; j < n; j++) {
if (j == 0) {
if (a[1] != -1 && a[0] == -1) {
maxi1 = a[1];
mini1 = a[1];
}
} else if (j == n - 1) {
if (a[n - 1] == -1 && a[n - 2] != -1) {
maxi1 = max(maxi1, a[j - 1]);
mini1 = min(mini1, a[j - 1]);
}
} else if (a[j] == -1) {
if (a[j - 1] != -1) {
maxi1 = max(maxi1, a[j - 1]);
mini1 = min(mini1, a[j - 1]);
}
if (a[j + 1] != -1) {
maxi1 = max(maxi1, a[j + 1]);
mini1 = min(mini1, a[j + 1]);
}
}
}
sum = (maxi1 + mini1) / 2;
if (a[0] == -1) a[0] = sum;
for (j = 1; j < n; j++) {
if (a[j] == -1) a[j] = sum;
if (abs(a[j] - a[j - 1]) > maxi) maxi = abs(a[j] - a[j - 1]);
}
cout << maxi << " " << sum << endl;
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
clock_t clk = clock();
long long int i, j;
void solve(void);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int t = 1;
while (t--) solve();
return 0;
}
long long int power(long long int x, long long int n,
unsigned long long int m = ULLONG_MAX) {
long long int res = 1;
x %= m;
while (n > 0) {
if (n & 1 == 1) res = (res * x) % m;
n /= 2;
x = (x * x) % m;
}
return res;
}
void solve() {
long long int n, m;
cin >> n >> m;
double val = log2(n);
if (m <= val)
cout << "0\n";
else {
long long int ans = 1;
for (i = 1; i <= n; ++i)
ans = (ans * (power(2, m, 1000000009) - i + 1000000009) % 1000000009) %
1000000009;
cout << ans << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[110];
bool hit[2 * 1000000 + 1];
int b[110], num;
int main() {
int T;
cin >> T;
while (T--) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
memset(hit, 0, sizeof(hit));
num = 0;
for (int i = 1; i <= 1000000 && num < n; i++) {
bool ok = 1;
for (int j = 0; j < n && ok; j++) {
if (hit[a[j] + i]) ok = 0;
}
if (ok) {
b[num++] = i;
for (int j = 0; j < n; j++) hit[a[j] + i] = 1;
}
}
if (num < n)
cout << "NO\n";
else {
cout << "YES\n";
for (int i = 0; i < n; i++) cout << b[i] << ' ';
cout << '\n';
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int p;
if (n % 2 == 0)
p = n - 1;
else
p = n;
long long sum = 0;
if (k >= n / 2) {
for (int i = n - 1; i > 0; i--) sum += i;
} else
for (int i = k * 2, j = n - 1; i > 0; j--, i--) {
sum += j;
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
int call(string sub) {
int cnt = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == sub[0] and s[i + 1] == sub[1]) cnt++;
}
return cnt;
}
int main() {
int n, maxi = 0, res;
string sub, gram;
cin >> n >> s;
for (int i = 0; i < s.length() - 1; i++) {
sub = s.substr(i, 2);
int check = call(sub);
if (check > maxi) {
maxi = check;
gram = sub;
}
}
cout << gram << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 5;
long long mod;
vector<long long> numbers[maxn];
vector<long long> children[maxn];
char forbid[maxn];
long long dp[maxn];
long long parent[maxn];
long long gcd(long long a, long long b) {
while (a && b) {
if (a >= b)
a %= b;
else
b %= a;
}
return a + b;
}
long long power(long long x, long long p) {
if (p == 0) return 1 % mod;
if (p & 1) return x * power(x, p - 1) % mod;
return power(x * x % mod, p >> 1);
}
long long gcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
long long step(long long prev, long long cur) {
long long x, y;
long long g = gcd(prev, mod, x, y);
return (x * (cur / g) % mod + mod) % mod;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long num;
cin >> num >> mod;
for (long long i = 0; i < num; ++i) {
long long x;
cin >> x;
if (x == 0) x += mod;
forbid[x] = true;
}
for (long long i = 1; i <= mod; ++i) {
if (!forbid[i]) {
numbers[gcd(i, mod)].push_back(i % mod);
}
}
for (long long i = 1; i <= mod; ++i) {
if (mod % i != 0) continue;
for (long long j = i + i; j <= mod; j += i) {
if (mod % j != 0) continue;
children[i].push_back(j);
}
}
for (long long i = mod; i >= 1; --i) {
if (gcd(i, mod) != i) continue;
long long maxval = 0;
parent[i] = -1;
for (auto d : children[i]) {
if (dp[d] > maxval) {
maxval = dp[d];
parent[i] = d;
}
}
dp[i] = maxval + (long long)numbers[i].size();
}
long long current = 1;
vector<long long> muls;
while (current != -1) {
for (auto i : numbers[current]) {
muls.push_back(i);
}
current = parent[current];
}
for (long long i = 1; i <= mod; ++i) {
if (forbid[i]) {
numbers[gcd(i, mod)].push_back(i % mod);
}
}
cout << muls.size() << '\n';
for (long long i = 0; i < muls.size(); ++i) {
if (i == 0) {
cout << muls[i] << ' ';
} else {
long long tmp = step(muls[i - 1], muls[i]);
cout << tmp << ' ';
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return x * f;
}
inline void print(int x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) print(x / 10);
putchar(x % 10 + 48);
}
int n, m;
int a[251][251];
int ans[251][251];
queue<pair<int, int> > q;
bool c[100010], r[100010];
int main() {
n = read(), m = read();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) a[i][j] = read();
for (int i = 1; i <= n; ++i) {
int x = -1;
for (int j = 1; j <= m; ++j) {
x = max(x, a[i][j]);
}
c[x] = 1;
}
for (int i = 1; i <= m; ++i) {
int x = -1;
for (int j = 1; j <= n; ++j) x = max(x, a[j][i]);
r[x] = 1;
}
int x = 0, y = 0;
for (int i = n * m; i; --i) {
x += c[i], y += r[i];
if (r[i] || c[i]) {
ans[x][y] = i;
if (r[i]) {
for (int j = x - 1; j; --j) q.push(make_pair(j, y));
}
if (c[i]) {
for (int j = y - 1; j; --j) q.push(make_pair(x, j));
}
} else {
pair<int, int> res = q.front();
q.pop();
ans[res.first][res.second] = i;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
print(ans[i][j]);
putchar(' ');
}
putchar('\n');
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool usedV[300000];
bool usedE[500000];
int main() {
int T;
scanf("%d", &T);
for (int epoch = 0; epoch < T; epoch++) {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n * 3; i++) usedV[i] = false;
int ans = 0;
for (int i = 0; i < m; i++) {
usedE[i] = false;
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
if (!usedV[a] && !usedV[b]) {
ans++;
usedV[a] = true;
usedV[b] = true;
usedE[i] = true;
}
}
int c = 0;
if (ans >= n) {
puts("Matching");
for (int i = 0; i < m; i++) {
if (usedE[i]) {
printf("%d ", i + 1);
c++;
if (c == n) break;
}
}
} else {
puts("IndSet");
for (int i = 0; i < n * 3; i++) {
if (!usedV[i]) {
printf("%d ", i + 1);
c++;
if (c == n) break;
}
}
}
puts("");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string t;
int num[10] = {0};
bool is_ok() {
for (int i = 0; i < t.size(); i++) {
if (num[t[i] - '0'] < 1) return 0;
num[t[i] - '0']--;
}
return 1;
}
int main() {
cin >> t;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '9') {
s[i] = '6';
}
if (s[i] == '5') {
s[i] = '2';
}
num[s[i] - '0']++;
}
for (int i = 0; i < t.size(); i++) {
if (t[i] == '9') {
t[i] = '6';
}
if (t[i] == '5') {
t[i] = '2';
}
}
int ans = 0;
while (1) {
if (is_ok())
ans++;
else
break;
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void chmax(T &x, T &y) {
if (x < y) swap(x, y);
}
template <class T>
inline void chmin(T &x, T &y) {
if (x > y) swap(x, y);
}
const long long INF = 0x3f3f3f3f3f3f;
const long long MOD = 1e9 + 7;
const long double EPS = 10e-10;
void Solution() {
long long l, r;
scanf("%lld %lld", &l, &r);
if (l * 2 <= r)
printf("%lld %lld\n", l, l * 2);
else
printf("-1 -1\n");
}
int32_t main() {
long long tc = 1;
scanf("%lld", &tc);
for (long long tn = 1; tn < tc + 1; tn += 1) {
Solution();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
unsigned long long sum = 0, sum1 = 0;
cin >> n >> m;
vector<pair<bool, int>> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec[i].second;
sum += vec[i].second;
sum1 += vec[i].second;
vec[i].first = 1;
}
for (int i = 0; i < m; i++) {
int x;
cin >> x;
sum -= vec[x - 1].second;
sum1 -= vec[x - 1].second;
vec[x - 1].first = 0;
}
sort(vec.begin(), vec.end());
sum1 += vec[m - 1].second;
sum1 *= pow(2, m - 1);
for (int i = 0; i < m; i++) {
if (vec[i].second >= sum) {
sum += vec[m - 1].second;
m--;
i--;
} else
sum *= 2;
}
cout << max(sum, sum1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) return a.second < b.second;
return (a.first > b.first);
}
bool comp1(pair<int, int> a, pair<int, int> b) { return (a.second < b.second); }
void solve() {
vector<pair<int, int>> m;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
m.emplace_back(x, i);
}
sort(m.begin(), m.end(), comp);
int q;
cin >> q;
while (q--) {
int k, pos;
cin >> k >> pos;
auto temp = m;
sort(temp.begin(), temp.begin() + k, comp1);
cout << temp[pos - 1].first << endl;
}
return;
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
const long long MOD = 1000000007;
const long long BIG = 1000000;
const long long inf = 1LL << 62;
const int base = 1000000000;
const int base_digits = 9;
using namespace std;
struct bigint {
vector<int> a;
int sign;
bigint() : sign(1) {}
bigint(long long v) { *this = v; }
bigint(const string &s) { read(s); }
void operator=(const bigint &v) {
sign = v.sign;
a = v.a;
}
void operator=(long long v) {
sign = 1;
if (v < 0) sign = -1, v = -v;
for (; v > 0; v = v / base) a.push_back(v % base);
}
bigint operator+(const bigint &v) const {
if (sign == v.sign) {
bigint res = v;
for (int i = 0, carry = 0; i < (int)max(a.size(), v.a.size()) || carry;
++i) {
if (i == (int)res.a.size()) res.a.push_back(0);
res.a[i] += carry + (i < (int)a.size() ? a[i] : 0);
carry = res.a[i] >= base;
if (carry) res.a[i] -= base;
}
return res;
}
return *this - (-v);
}
bigint operator-(const bigint &v) const {
if (sign == v.sign) {
if (abs() >= v.abs()) {
bigint res = *this;
for (int i = 0, carry = 0; i < (int)v.a.size() || carry; ++i) {
res.a[i] -= carry + (i < (int)v.a.size() ? v.a[i] : 0);
carry = res.a[i] < 0;
if (carry) res.a[i] += base;
}
res.trim();
return res;
}
return -(v - *this);
}
return *this + (-v);
}
void operator*=(int v) {
if (v < 0) sign = -sign, v = -v;
for (int i = 0, carry = 0; i < (int)a.size() || carry; ++i) {
if (i == (int)a.size()) a.push_back(0);
long long cur = a[i] * (long long)v + carry;
carry = (int)(cur / base);
a[i] = (int)(cur % base);
}
trim();
}
bigint operator*(int v) const {
bigint res = *this;
res *= v;
return res;
}
bigint operator^(const bigint &v) {
bigint ans = 1, a = *this, b = v;
while (!b.isZero()) {
if (b % 2) ans *= a;
a *= a, b /= 2;
}
return ans;
}
friend pair<bigint, bigint> divmod(const bigint &a1, const bigint &b1) {
int norm = base / (b1.a.back() + 1);
bigint a = a1.abs() * norm;
bigint b = b1.abs() * norm;
bigint q, r;
q.a.resize(a.a.size());
for (int i = a.a.size() - 1; i >= 0; i--) {
r *= base;
r += a.a[i];
int s1 = r.a.size() <= b.a.size() ? 0 : r.a[b.a.size()];
int s2 = r.a.size() <= b.a.size() - 1 ? 0 : r.a[b.a.size() - 1];
int d = ((long long)base * s1 + s2) / b.a.back();
r -= b * d;
while (r < 0) r += b, --d;
q.a[i] = d;
}
q.sign = a1.sign * b1.sign;
r.sign = a1.sign;
q.trim();
r.trim();
return make_pair(q, r / norm);
}
bigint operator/(const bigint &v) const { return divmod(*this, v).first; }
bigint operator%(const bigint &v) const { return divmod(*this, v).second; }
void operator/=(int v) {
if (v < 0) sign = -sign, v = -v;
for (int i = (int)a.size() - 1, rem = 0; i >= 0; --i) {
long long cur = a[i] + rem * (long long)base;
a[i] = (int)(cur / v);
rem = (int)(cur % v);
}
trim();
}
bigint operator/(int v) const {
bigint res = *this;
res /= v;
return res;
}
int operator%(int v) const {
if (v < 0) v = -v;
int m = 0;
for (int i = a.size() - 1; i >= 0; --i)
m = (a[i] + m * (long long)base) % v;
return m * sign;
}
void operator+=(const bigint &v) { *this = *this + v; }
void operator-=(const bigint &v) { *this = *this - v; }
void operator*=(const bigint &v) { *this = *this * v; }
void operator/=(const bigint &v) { *this = *this / v; }
bool operator<(const bigint &v) const {
if (sign != v.sign) return sign < v.sign;
if (a.size() != v.a.size()) return a.size() * sign < v.a.size() * v.sign;
for (int i = a.size() - 1; i >= 0; i--)
if (a[i] != v.a[i]) return a[i] * sign < v.a[i] * sign;
return false;
}
bool operator>(const bigint &v) const { return v < *this; }
bool operator<=(const bigint &v) const { return !(v < *this); }
bool operator>=(const bigint &v) const { return !(*this < v); }
bool operator==(const bigint &v) const {
return !(*this < v) && !(v < *this);
}
bool operator!=(const bigint &v) const { return *this < v || v < *this; }
void trim() {
while (!a.empty() && !a.back()) a.pop_back();
if (a.empty()) sign = 1;
}
bool isZero() const { return a.empty() || (a.size() == 1 && !a[0]); }
bigint operator-() const {
bigint res = *this;
res.sign = -sign;
return res;
}
bigint abs() const {
bigint res = *this;
res.sign *= res.sign;
return res;
}
long long longValue() const {
long long res = 0;
for (int i = a.size() - 1; i >= 0; i--) res = res * base + a[i];
return res * sign;
}
friend bigint gcd(const bigint &a, const bigint &b) {
return b.isZero() ? a : gcd(b, a % b);
}
friend bigint lcm(const bigint &a, const bigint &b) {
return a / gcd(a, b) * b;
}
void read(const string &s) {
sign = 1;
a.clear();
int pos = 0;
while (pos < (int)s.size() && (s[pos] == '-' || s[pos] == '+')) {
if (s[pos] == '-') sign = -sign;
++pos;
}
for (int i = s.size() - 1; i >= pos; i -= base_digits) {
int x = 0;
for (int j = max(pos, i - base_digits + 1); j <= i; j++)
x = x * 10 + s[j] - '0';
a.push_back(x);
}
trim();
}
friend istream &operator>>(istream &stream, bigint &v) {
string s;
stream >> s;
v.read(s);
return stream;
}
friend ostream &operator<<(ostream &stream, const bigint &v) {
if (v.sign == -1) stream << '-';
stream << (v.a.empty() ? 0 : v.a.back());
for (int i = (int)v.a.size() - 2; i >= 0; --i)
stream << setw(base_digits) << setfill('0') << v.a[i];
return stream;
}
static vector<int> convert_base(const vector<int> &a, int old_digits,
int new_digits) {
vector<long long> p(max(old_digits, new_digits) + 1);
p[0] = 1;
for (int i = 1; i < (int)p.size(); i++) p[i] = p[i - 1] * 10;
vector<int> res;
long long cur = 0;
int cur_digits = 0;
for (int i = 0; i < (int)a.size(); i++) {
cur += a[i] * p[cur_digits];
cur_digits += old_digits;
while (cur_digits >= new_digits) {
res.push_back(int(cur % p[new_digits]));
cur /= p[new_digits];
cur_digits -= new_digits;
}
}
res.push_back((int)cur);
while (!res.empty() && !res.back()) res.pop_back();
return res;
}
static vector<long long> karatsubaMultiply(const vector<long long> &a,
const vector<long long> &b) {
int n = a.size();
vector<long long> res(n + n);
if (n <= 32) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) res[i + j] += a[i] * b[j];
return res;
}
int k = n >> 1;
vector<long long> a1(a.begin(), a.begin() + k);
vector<long long> a2(a.begin() + k, a.end());
vector<long long> b1(b.begin(), b.begin() + k);
vector<long long> b2(b.begin() + k, b.end());
vector<long long> a1b1 = karatsubaMultiply(a1, b1);
vector<long long> a2b2 = karatsubaMultiply(a2, b2);
for (int i = 0; i < k; i++) a2[i] += a1[i];
for (int i = 0; i < k; i++) b2[i] += b1[i];
vector<long long> r = karatsubaMultiply(a2, b2);
for (int i = 0; i < (int)a1b1.size(); i++) r[i] -= a1b1[i];
for (int i = 0; i < (int)a2b2.size(); i++) r[i] -= a2b2[i];
for (int i = 0; i < (int)r.size(); i++) res[i + k] += r[i];
for (int i = 0; i < (int)a1b1.size(); i++) res[i] += a1b1[i];
for (int i = 0; i < (int)a2b2.size(); i++) res[i + n] += a2b2[i];
return res;
}
bigint operator*(const bigint &v) const {
vector<int> a6 = convert_base(this->a, base_digits, 6);
vector<int> b6 = convert_base(v.a, base_digits, 6);
vector<long long> a(a6.begin(), a6.end());
vector<long long> b(b6.begin(), b6.end());
while (a.size() < b.size()) a.push_back(0);
while (b.size() < a.size()) b.push_back(0);
while (a.size() & (a.size() - 1)) a.push_back(0), b.push_back(0);
vector<long long> c = karatsubaMultiply(a, b);
bigint res;
res.sign = sign * v.sign;
for (int i = 0, carry = 0; i < (int)c.size(); i++) {
long long cur = c[i] + carry;
res.a.push_back((int)(cur % 1000000));
carry = (int)(cur / 1000000);
}
res.a = convert_base(res.a, 6, base_digits);
res.trim();
return res;
}
};
int powm(int a, int n, int m) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return powm(a * a % m, n / 2, m);
else if (n % 2 != 0)
return (a % m * powm((a * a) % m, n / 2, m)) % m;
}
template <int n>
vector<bool> pri_gen() {
vector<bool> p(n, true);
long long c = 2;
p[0] = false;
p[1] = false;
for (long long i = 4; i < n; i += 2) {
p[i] = false;
}
p[2] = true;
for (long long i = 3; i * i <= n; i += 2) {
if (p[i]) {
for (long long j = i * i; j < n; j += 2 * i) {
p[j] = false;
}
}
}
return p;
}
vector<int> prigen_c_1() {
vector<int> p(BIG);
for (long long i = 2; i * i <= BIG; i++) {
if (!p[i]) {
for (long long j = i; j < BIG; j += i) {
p[j] = i;
}
}
}
return p;
}
vector<int> prigen_c_2() {
vector<int> p(BIG);
for (int i = 2; i < BIG; i++) {
if (i % 2 == 0)
p[i] = 2;
else
p[i] = i;
}
for (int i = 2; i * i < BIG; i++) {
if (p[i] == i) {
for (int j = i * i; j < BIG; j += 2 * i) {
if (p[j] == j) p[j] = i;
}
}
}
return p;
}
template <class T>
class graph {
private:
struct vertex {
vector<pair<T, vertex *>> adj;
T key;
int in_deg;
int top_num;
long long dist;
bool known;
vertex *path;
vertex(T k) : key(k), in_deg(0), dist(inf), top_num(0), known(false) {}
};
long long no_of_vertices = 0;
map<T, vertex *> m;
public:
long long no_vertices() { return no_of_vertices; }
void topsort() {
queue<vertex *> q;
int counter = 0;
for (auto it = m.begin(); it != m.end(); it++) {
if (it->second->in_deg == 0) {
q.push(it->second);
}
}
while (!q.empty()) {
vertex *v = q.front();
q.pop();
v->top_num = ++counter;
for (int i = 0; i < v->adj.size(); i++) {
if ((--(((v->adj)[i].second)->in_deg)) == 0) {
q.push((v->adj)[i].second);
}
}
}
}
void unweighted(vertex *s) {
queue<vertex *> q;
s->dist = 0;
q.push(s);
while (!q.empty()) {
vertex *v = q.front();
q.pop();
for (int i = 0; i < (v->adj).size(); i++) {
if (v->adj[i].second->dist == inf) {
(v->adj[i].second)->dist = v->dist + 1;
(v->adj[i].second)->path = v;
q.push((v->adj[i].second));
}
}
}
}
void add_vertex(T &ver) {
auto it = m.find(ver);
if (it == m.end()) {
vertex *v = new vertex(ver);
m[ver] = v;
no_of_vertices++;
return;
}
}
void add_edge(T &from, T &to, double cost = 0) {
(m[from]->adj).push_back({cost, m[to]});
m[to]->in_deg++;
return;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n;
cin >> n;
long long xi = 0, yi = 1;
long long xf = 1000000000, yf = 1;
long long lx, ly;
cout << "0 1" << endl;
string s;
cin >> s;
lx = (xi + xf) / 2;
ly = (yi + yf) / 2;
for (int i = 1; i < n; i++) {
long long mx = (xi + xf) / 2, my = (yi + yf) / 2;
cout << mx << " " << my << endl;
string str;
cin >> str;
if (s[0] == str[0]) {
xi = mx;
yi = my;
} else {
xf = mx;
yf = my;
}
}
cout << xi << " " << 2 << " " << xf << " " << 0 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 10;
const int MOD = (int)1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
set<int> s;
vector<int> lift;
int n, m, ans = 0;
cin >> n >> m;
vector<int> weight(n), days(m);
for (int i = 0; i < n; i++) cin >> weight[i];
for (int i = 0; i < m; i++) cin >> days[i];
stack<int> revOrder, order;
for (int i = 0; i < m; i++) {
if (s.count(days[i])) continue;
revOrder.push(days[i]);
s.insert(days[i]);
}
while (revOrder.size()) order.push(revOrder.top()), revOrder.pop();
for (int i = 0; i < m; i++) {
while (order.top() != days[i])
lift.push_back(order.top()), ans += weight[order.top() - 1], order.pop();
order.pop();
for (int i = lift.size() - 1; i >= 0; i--) order.push(lift[i]);
order.push(days[i]);
lift.clear();
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 9e18;
const long long MOD = 1e9 + 7;
const long long mod = 998244353;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
void fileio() {}
const long long N = 1e6;
vector<vector<long long> > v(N);
void solve() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
vector<long long> t(n + 1);
vector<vector<long long> > c(n + 1);
for (long long i = 1; i < n + 1; i++) {
cin >> t[i];
c[t[i]].push_back(i);
}
long long fl = 0;
vector<long long> o(n + 1, 0);
long long k = 1;
for (long long i = 1; i < n + 1; i++) {
for (auto x : c[i]) {
o[x] = k++;
set<long long> s;
for (long long j = 1; j < t[x] + 1; j++) s.insert(j);
for (auto ch : v[x]) s.erase(t[ch]);
if (!(s.size() == 1 && *s.begin() == t[x])) {
fl = 1;
break;
}
}
}
if (fl) {
cout << -1 << "\n";
return;
}
vector<long long> ans(n + 1);
for (long long i = 1; i < n + 1; i++) ans[o[i]] = i;
for (long long i = 1; i < n + 1; i++) cout << ans[i] << " ";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
fileio();
solve();
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:216000000")
const int MAX = 1000001;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
vector<int> d(10);
cin >> n;
for (int i = 0; i < n; ++i) {
char c;
cin >> c;
d[c - '0'] = 1;
}
if (d[7] || d[0] || d[9]) {
if (d[1] || d[2] || d[3]) {
if (d[1] || d[4] || d[7] || d[0]) {
if (d[3] || d[6] || d[9] || d[0]) {
cout << "YES";
return 0;
}
}
}
}
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 40;
int v[N], x[N], ct, al[N], col[N], n, lu[N], lv[N];
int read() {
int sum = 0, fg = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fg = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum * fg;
}
inline void add(int u, int V) {
v[++ct] = V;
x[ct] = al[u];
al[u] = ct;
}
inline void dfs(int u, int tw) {
col[u] = tw;
for (int i = al[u]; i; i = x[i])
if (col[v[i]] == -1) dfs(v[i], tw ^ 1);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) col[i] = -1;
for (register int i = 1, x, y; i <= n; i++) {
x = read();
y = read();
if (lu[x]) {
add(lu[x], i);
add(i, lu[x]);
lu[x] = 0;
} else
lu[x] = i;
if (lv[y]) {
add(lv[y], i);
add(i, lv[y]);
lv[y] = 0;
} else
lv[y] = i;
}
for (register int i = 1; i <= n; i++)
if (col[i] == -1) dfs(i, 0);
for (register int i = 1; i <= n; i++)
if (col[i] == 0)
cout << "r";
else
cout << "b";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long N = 101;
long long comb[N][N], sol[N][N * N], quick[N][2];
char solved[N][N * N];
long long n, m, k;
inline long long mod(long long x) { return (1ll * x % MOD + MOD) % MOD; }
long long fexp(long long a, long long r) {
long long t = 1ll;
while (r) {
if (r % 2 == 1) t = mod(1ll * t * a);
a = mod(1ll * a * a);
r /= 2ll;
}
return mod(t);
}
inline long long inv(long long x) { return fexp(x, MOD - 2); }
void choices() {
comb[0][0] = 1ll;
for (int i = 1; i < n + 1; i++) {
comb[i][0] = 1ll;
for (int j = 1; j < i + 1; j++)
comb[i][j] = mod(comb[i - 1][j - 1] + comb[i - 1][j]);
}
}
long long solve(long long p, long long k) {
if (k == 0) return 1ll;
if (p == n) return 0ll;
if (solved[p][k] == 0) {
for (int i = 0; i < min(n, k) + 1; i++) {
sol[p][k] = mod(sol[p][k] + quick[i][(m % n > p)] * solve(p + 1, k - i));
}
solved[p][k] = 1;
}
return sol[p][k];
}
int main() {
scanf("%I64d %I64d %I64d", &n, &m, &k);
choices();
for (int i = 0; i < n + 1; i++) {
quick[i][0] = fexp(comb[n][i], m / n);
quick[i][1] = mod(quick[i][0] * comb[n][i]);
}
printf("%I64d\n", solve(0, k));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const double PI = 2 * acos(0.0);
inline int cmp(double x, double y = 0, double tol = EPS) {
return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
bool debug = true;
long long stoim(string s) {
long long v = 0;
for (int i = 0; i < int(s.size()); ++i) {
if (s[i] >= '0' && s[i] <= '9') {
v = v * 10 + s[i] - '0';
}
}
return v;
}
void print(long long v) {
string vet;
if (v % 100 == 0) {
v /= 100;
} else {
vet.push_back('0' + v % 10);
v /= 10;
vet.push_back('0' + v % 10);
v /= 10;
vet.push_back('.');
if (v == 0) {
vet.push_back('0');
}
}
int c = 0;
while (v > 0) {
if (c == 3) {
vet.push_back('.');
c = 0;
}
vet.push_back('0' + v % 10);
v /= 10;
c++;
}
reverse((vet).begin(), (vet).end());
cout << vet << endl;
}
int main(void) {
char s[1123];
long long sum = 0;
while (scanf("%[^0-9]", s) == 1) {
if (scanf("%[^a-z]", s) != 1) break;
long long n = strlen(s);
if (s[n - 1] < '0' || s[n - 1] > '9') --n;
if (n >= 3 && s[n - 3] == '.') {
sum += stoim((string)s);
} else {
sum += stoim((string)s) * 100;
}
}
print(sum);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, q;
cin >> n >> q;
vector<int> res(n + 1, 0);
vector<vector<int>> adjacenyList(n + 1);
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adjacenyList[u].emplace_back(v);
adjacenyList[v].emplace_back(u);
}
function<void(int, int)> DFS = [&](int u, int val) {
res[u] = val;
for (int v : adjacenyList[u]) {
if (res[v]) continue;
DFS(v, min(v, val));
}
};
int c = 0, l = 0;
int t, x;
cin >> t >> x;
x = (x + l) % n + 1;
c = x;
DFS(x, x);
while (--q) {
cin >> t >> x;
x = (x + l) % n + 1;
if (t & 1) {
c = min(c, res[x]);
} else {
l = min(c, res[x]);
cout << l << '\n';
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
bool dp[501][501][501];
int main() {
int n, k;
scanf("%d%d", &n, &k);
dp[0][0][0] = 1;
for (int i = 1; i <= n; i++) {
int c;
scanf("%d", &c);
for (int j = 0; j <= k; j++)
for (int kk = 0; kk <= j; kk++)
if (dp[i - 1][j][kk] || j >= c && dp[i - 1][j - c][kk] ||
kk >= c && dp[i - 1][j - c][kk - c])
dp[i][j][kk] = 1;
}
for (int i = 0; i <= k; i++)
if (dp[n][k][i]) ans.push_back(i);
int l = ans.size();
printf("%d\n", l);
for (int i = 0; i < l; i++) {
if (i != 0) printf(" ");
printf("%d", ans[i]);
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
char str[105];
char ch;
int l;
int i, j;
scanf("%c", &ch);
scanf("%s", str);
l = strlen(str);
if (ch == 'R') {
for (i = 0; i <= l; i++) {
if (str[i] == 's') {
printf("a");
}
if (str[i] == 'd') {
printf("s");
}
if (str[i] == 'f') {
printf("d");
}
if (str[i] == 'g') {
printf("f");
}
if (str[i] == 'h') {
printf("g");
}
if (str[i] == 'j') {
printf("h");
}
if (str[i] == 'k') {
printf("j");
}
if (str[i] == 'l') {
printf("k");
}
if (str[i] == ';') {
printf("l");
}
if (str[i] == 'x') {
printf("z");
}
if (str[i] == 'c') {
printf("x");
}
if (str[i] == 'v') {
printf("c");
}
if (str[i] == 'b') {
printf("v");
}
if (str[i] == 'n') {
printf("b");
}
if (str[i] == 'm') {
printf("n");
}
if (str[i] == ',') {
printf("m");
}
if (str[i] == '.') {
printf(",");
}
if (str[i] == '/') {
printf(".");
}
if (str[i] == 'w') {
printf("q");
}
if (str[i] == 'e') {
printf("w");
}
if (str[i] == 'r') {
printf("e");
}
if (str[i] == 't') {
printf("r");
}
if (str[i] == 'y') {
printf("t");
}
if (str[i] == 'u') {
printf("y");
}
if (str[i] == 'i') {
printf("u");
}
if (str[i] == 'o') {
printf("i");
}
if (str[i] == 'p') {
printf("o");
}
}
}
if (ch == 'L') {
for (j = 0; j <= l; j++) {
if (str[j] == 'a') {
printf("s");
}
if (str[j] == 's') {
printf("d");
}
if (str[j] == 'd') {
printf("f");
}
if (str[j] == 'f') {
printf("g");
}
if (str[j] == 'g') {
printf("h");
}
if (str[j] == 'h') {
printf("j");
}
if (str[j] == 'j') {
printf("k");
}
if (str[j] == 'k') {
printf("l");
}
if (str[j] == 'l') {
printf(";");
}
if (str[j] == 'q') {
printf("w");
}
if (str[j] == 'w') {
printf("e");
}
if (str[j] == 'e') {
printf("r");
}
if (str[j] == 'r') {
printf("t");
}
if (str[j] == 't') {
printf("y");
}
if (str[j] == 'y') {
printf("u");
}
if (str[j] == 'u') {
printf("i");
}
if (str[j] == 'i') {
printf("o");
}
if (str[j] == 'o') {
printf("p");
}
if (str[j] == 'z') {
printf("x");
}
if (str[j] == 'x') {
printf("c");
}
if (str[j] == 'c') {
printf("v");
}
if (str[j] == 'v') {
printf("b");
}
if (str[j] == 'b') {
printf("n");
}
if (str[j] == 'n') {
printf("m");
}
if (str[j] == 'm') {
printf(",");
}
if (str[j] == ',') {
printf(".");
}
if (str[j] == '.') {
printf("/");
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int t, n, per[200001], where[200001];
int groupcnt;
int main() {
scanf("%d", &t);
for (int test = 0; test < t; test++) {
scanf("%d", &n);
groupcnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &per[i]);
where[per[i]] = i;
}
for (int i = 1; i <= n; i++) {
groupcnt++;
int location = where[i];
if (location > 1 && per[location - 1] < i) groupcnt--;
if (location < n && per[location + 1] < i) groupcnt--;
if (groupcnt == 1)
printf("1");
else
printf("0");
}
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename X>
inline X sqr(const X& a) {
return a * a;
}
int nxt() {
int x;
cin >> x;
return x;
}
void solve() {
int n = nxt();
if (n == 1 || n == 2 || n == 4) {
cout << -1 << '\n';
return;
}
if (n % 3 == 0) {
cout << n / 3 << ' ' << 0 << ' ' << 0 << '\n';
} else if (n % 3 == 1) {
cout << (n - 7) / 3 << ' ' << 0 << ' ' << 1 << '\n';
} else {
cout << (n - 5) / 3 << ' ' << 1 << ' ' << 0 << '\n';
}
}
int main() {
int t = nxt();
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, d[5][3][100][100];
char a[100][100];
bool was[100][100];
string s;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> s;
m = s.length();
for (int j = 0; j < m; j++) a[i][j] = s[j];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (!was[i][j]) {
int ii = i, jj = j;
while (ii < n && a[ii][j] == a[i][j]) ii++;
ii--;
while (jj < m && a[i][jj] == a[i][j]) jj++;
jj--;
for (int g = i; g <= ii; g++)
for (int h = j; h <= jj; h++) {
was[g][h] = true;
d[1][0][g][h] = ii * 100 + jj;
d[1][1][g][h] = i * 100 + jj;
d[2][0][g][h] = ii * 100 + j;
d[2][1][g][h] = ii * 100 + jj;
d[3][0][g][h] = i * 100 + j;
d[3][1][g][h] = ii * 100 + j;
d[4][0][g][h] = i * 100 + jj;
d[4][1][g][h] = i * 100 + j;
}
}
int in = 0, jn = 0, cp = 1, dp = 1, iin, jjn;
while (k) {
bool flag = false;
k--;
iin = in, jjn = jn;
in = d[dp][cp][iin][jjn] / 100;
jn = d[dp][cp][iin][jjn] % 100;
if (dp == 1 && jn < m - 1 && a[in][jn + 1] != '0')
jn++, flag = true;
else if (dp == 2 && in < n - 1 && a[in + 1][jn] != '0')
in++, flag = true;
else if (dp == 3 && jn > 0 && a[in][jn - 1] != '0')
jn--, flag = true;
else if (dp == 4 && in > 0 && a[in - 1][jn] != '0')
in--, flag = true;
if (!flag)
if (cp == 1)
cp = 0;
else
cp = 1, dp = dp % 4 + 1;
}
cout << a[in][jn];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int BUFFER_SIZE = 1 << 15;
char input_buffer[BUFFER_SIZE];
int input_pos = 0, input_len = 0;
char output_buffer[BUFFER_SIZE];
int output_pos = 0;
char number_buffer[100];
uint8_t lookup[100];
void _update_input_buffer() {
input_len = fread(input_buffer, sizeof(char), BUFFER_SIZE, stdin);
input_pos = 0;
if (input_len == 0) input_buffer[0] = EOF;
}
inline char next_char(bool advance = true) {
if (input_pos >= input_len) _update_input_buffer();
return input_buffer[advance ? input_pos++ : input_pos];
}
template <typename T>
inline void read_int(T &number) {
bool negative = false;
number = 0;
while (!isdigit(next_char(false)))
if (next_char() == '-') negative = true;
do {
number = 10 * number + (next_char() - '0');
} while (isdigit(next_char(false)));
if (negative) number = -number;
}
template <typename T, typename... Args>
inline void read_int(T &number, Args &...args) {
read_int(number);
read_int(args...);
}
void _flush_output() {
fwrite(output_buffer, sizeof(char), output_pos, stdout);
output_pos = 0;
}
inline void write_char(char c) {
if (output_pos == BUFFER_SIZE) _flush_output();
output_buffer[output_pos++] = c;
}
template <typename T>
inline void write_int(T number, char after = '\0') {
if (number < 0) {
write_char('-');
number = -number;
}
int length = 0;
while (number >= 10) {
uint8_t lookup_value = lookup[number % 100];
number /= 100;
number_buffer[length++] = (lookup_value & 15) + '0';
number_buffer[length++] = (lookup_value >> 4) + '0';
}
if (number != 0 || length == 0) write_char(number + '0');
for (int i = length - 1; i >= 0; i--) write_char(number_buffer[i]);
if (after) write_char(after);
}
void init() {
bool exit_success = atexit(_flush_output) == 0;
assert(exit_success);
for (int i = 0; i < 100; i++) lookup[i] = (i / 10 << 4) + i % 10;
}
} // namespace IO
const int sz = 18;
int f[1 << sz];
struct union_find {
vector<int> p;
union_find(int n) : p(n, -1) {}
int join(int u, int v) {
if ((u = root(u)) == (v = root(v))) return 0;
if (p[u] > p[v]) swap(u, v);
int r = (size(u) == 1 ? f[u] : 1) + (size(v) == 1 ? f[v] : 1) - 1;
p[u] += p[v];
p[v] = u;
return r;
}
int root(int u) { return p[u] < 0 ? u : p[u] = root(p[u]); }
int size(int u) { return -p[root(u)]; }
};
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
IO::init();
int n;
IO::read_int(n);
long long ans = 0;
for (int x; n--;) IO::read_int(x), ++f[x], ans -= x;
++f[0];
union_find uf(1 << sz);
for (int i = 1 << sz; --i >= 0;)
for (int j = i; 2 * j >= i; --j &= i)
if (f[i ^ j] && f[j]) {
ans += (long long)i * uf.join(i ^ j, j);
if (j == 0) break;
}
IO::write_int(ans, '\n');
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 103;
bool W[N][N][N];
bool check(int i, int j, int l, int checkX = 0, int checkY = 0,
int checkZ = 0) {
if (W[i][j][l] && !W[i - checkZ][j - checkY][l - checkX]) return true;
return false;
}
int main(void) {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
char line[N];
for (int j = 1; j <= m; j++) {
scanf("%s", line);
for (int l = 1; l <= k; l++) {
if (line[l - 1] == '1') {
W[i][j][l] = true;
}
}
}
}
int res = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int l = 1; l <= k; l++) {
if (W[i][j][l] && ((W[i][j][l - 1] && W[i][j][l + 1]) ||
(W[i][j - 1][l] && W[i][j + 1][l]) ||
(W[i - 1][j][l] && W[i + 1][j][l]) ||
(W[i][j - 1][l] && check(i, j, l + 1, 0, 1, 0)) ||
(W[i][j - 1][l] && check(i + 1, j, l, 0, 1, 0)) ||
(W[i][j][l - 1] && check(i, j + 1, l, 1, 0, 0)) ||
(W[i][j][l - 1] && check(i + 1, j, l, 1, 0, 0)) ||
(W[i - 1][j][l] && check(i, j, l + 1, 0, 0, 1)) ||
(W[i - 1][j][l] && check(i, j + 1, l, 0, 0, 1)))) {
res++;
}
}
}
}
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 4;
int n, q, a[N], b[N];
pair<int, int> tree[2 * N + 400];
void insert(int v, int l, int r, int a, int b, int c, int d) {
if (r - l + 1 > 1 && tree[v] != make_pair(0, 0)) {
int mid = (l + r) / 2;
tree[2 * v] = make_pair(tree[v].first, tree[v].first + (mid - l));
tree[2 * v + 1] = make_pair(tree[v].first + (mid - l) + 1, tree[v].second);
tree[v] = make_pair(0, 0);
}
if (r < a || l > b || l > r) return;
if (a <= l && r <= b) {
tree[v] = make_pair(c + (l - a), d - (b - r));
return;
}
int mid = (l + r) / 2;
insert(2 * v, l, mid, a, b, c, d);
insert(2 * v + 1, mid + 1, r, a, b, c, d);
}
int query(int v, int l, int r, int x) {
if (r - l + 1 > 1 && tree[v] != make_pair(0, 0)) {
int mid = (l + r) / 2;
tree[2 * v] = make_pair(tree[v].first, tree[v].first + (mid - l));
tree[2 * v + 1] = make_pair(tree[v].first + (mid - l) + 1, tree[v].second);
tree[v] = make_pair(0, 0);
}
if (x < l || x > r || l > r) return 0;
if (l == x && r == x) return tree[v].first;
int mid = (l + r) / 2;
if (x <= mid)
query(2 * v, l, mid, x);
else
query(2 * v + 1, mid + 1, r, x);
}
int main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
}
while (q--) {
int type;
cin >> type;
if (type == 1) {
int x, y, k;
cin >> x >> y >> k;
insert(1, 1, n, y, y + k - 1, x, x + k - 1);
} else {
int x;
cin >> x;
int pom = query(1, 1, n, x);
if (pom == 0)
cout << b[x] << endl;
else
cout << a[pom] << endl;
}
}
getchar();
getchar();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<string> F[26], L[26];
string s;
int main() {
std::ios::sync_with_stdio(false);
int i, j, k, n;
cin >> n;
for (i = 0; i < n; F[s[0] - 'A'].push_back(s), ++i) cin >> s;
for (i = 0; i < n; L[s[0] - 'A'].push_back(s), ++i) cin >> s;
for (i = 0; i < 26; ++i) {
sort(F[i].begin(), F[i].end());
sort(L[i].begin(), L[i].end());
}
for (k = 0, i = 0, j = 0; i < 26; ++i)
while (F[i].size() > 0) {
if (k++ > 0) cout << ", ";
cout << F[i][0] << ' ';
for (; L[j].size() <= F[j].size(); ++j)
;
if (L[i].size() == 0 ||
L[i].size() > 0 && F[i].size() > L[i].size() && j < i) {
cout << L[j][0];
L[j].erase(L[j].begin());
} else {
cout << L[i][0];
L[i].erase(L[i].begin());
}
F[i].erase(F[i].begin());
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, p[100], l = -1, r = -1;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
cin >> p[i];
}
for (int i = m - 2; i >= 0; i--) {
if (p[i] <= k && p[i] > 0) {
l = i;
break;
}
}
for (int i = m; i < n; i++) {
if (p[i] <= k && p[i] > 0) {
r = i;
break;
}
}
if (l < 0) {
cout << (r - m + 1) * 10 << endl;
} else if (r < 0) {
cout << (m - l - 1) * 10 << endl;
} else {
cout << min(m - l - 1, r - m + 1) * 10 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 7;
int32_t main() {
long long vals[5], ans[7];
for (long long i = 1; i <= 4; i++) {
cout << "? " << i << " " << i + 1 << "\n";
fflush(stdout);
cin >> vals[i];
}
long long flag = 0;
for (long long i = 1; i <= 3; i++)
if ((vals[i] % 15 == 0) && (vals[i + 1] % 15 == 0))
ans[i + 1] = 15, flag = i + 1;
if (!flag) {
if (vals[1] % 15 != 0 && vals[4] % 15 != 0)
ans[6] = 15;
else if (vals[1] % 15 == 0)
ans[1] = 15, flag = 1;
else if (vals[4] % 15 == 0)
ans[5] = 15, flag = 5;
for (long long i = 1; i <= 3; i++)
if ((vals[i] % 23 == 0) && (vals[i + 1] % 23 == 0))
ans[i + 1] = 23, flag = i + 1;
if (!flag) {
if (vals[1] % 23 == 0)
ans[1] = 23, flag = 1;
else
ans[5] = 23, flag = 5;
}
}
for (long long i = flag; i >= 2; i--) ans[i - 1] = vals[i - 1] / ans[i];
for (long long i = flag + 1; i <= 5; i++) ans[i] = vals[i - 1] / ans[i - 1];
long long s = 4 + 8 + 15 + 16 + 23 + 42;
for (long long i = 1; i <= 5; i++) s -= ans[i];
ans[6] = s;
cout << "!";
for (long long i = 1; i <= 6; i++) cout << " " << ans[i];
cout << "\n";
fflush(stdout);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, i, ans;
cin >> n;
vector<long long> a(n);
for (i = 0; i < n; i++) cin >> a[i];
ans = a[n - 1];
vector<long long> v(n);
v[n - 1] = a[n - 1];
for (i = n - 2; i >= 0; i--) {
v[i] = v[i + 1] + a[i];
ans = max(ans, v[i]);
}
cout << ans << endl;
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
long long arr[100003];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
reverse(arr, arr + n);
long long a = 0, b = 0;
for (int i = 0; i < n; i++) {
if (a <= b)
a += arr[i];
else {
b += arr[i];
}
}
cout << abs(a - b) + 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100111;
const int INF = 0x7f7f7f7f;
int cases;
char str[MAXN];
int main() {
int cntl = 0, cntr = 0, pos = 0, cnt1 = 0;
scanf("%s", str);
int len = strlen(str);
for (int i = len - 1; i >= 0; i--) {
if (str[i] == '#') {
pos = i;
break;
} else if (str[i] == '(') {
if (cntr <= 0) {
puts("-1");
return 0;
}
--cntr;
} else if (str[i] == ')') {
++cntr;
}
}
if (cntr < 0) {
puts("-1");
return 0;
}
for (int i = 0; i < pos; i++) {
if (str[i] == '#') {
++cnt1;
--cntl;
if (cntl < 0) {
puts("-1");
return 0;
}
} else if (str[i] == '(') {
++cntl;
} else if (str[i] == ')') {
--cntl;
if (cntl < 0) {
puts("-1");
return 0;
}
}
}
cntl -= cntr;
if (cntl <= 0) {
puts("-1");
return 0;
} else {
for (int i = 0; i < cnt1; i++) {
printf("1\n");
}
printf("%d\n", cntl);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long b;
const int MAXN = 200000 + 100;
long long a[MAXN], p[MAXN];
template <typename T>
T binary_search(T lower_bound, T upper_bound, bool (*checker)(T)) {
T middle;
while (lower_bound < upper_bound) {
middle = (lower_bound + upper_bound) >> 1;
if ((*checker)(middle)) {
upper_bound = middle;
} else {
lower_bound = middle + 1;
}
}
return lower_bound;
}
bool checker(int dorm_number) { return p[dorm_number] >= b; }
int main() {
cin >> n >> m;
p[0] = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
p[i + 1] = a[i] + p[i];
}
int lower_bound = 0, upper_bound = n;
for (int i = 0; i < m; ++i) {
cin >> b;
int dorm_number = binary_search(lower_bound, upper_bound, checker);
cout << dorm_number << " " << b - p[dorm_number - 1] << "\n";
lower_bound = dorm_number;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, a[501][501], x, y, s, ans;
vector<int> v;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int p = 1; p <= q; p++) {
cin >> x >> y;
if (a[x][y] == 1)
a[x][y] = 0;
else
a[x][y] = 1;
for (int i = 1; i <= n; i++) {
s = 0;
for (int j = 1; j <= m; j++) {
if (a[i][j] == 1)
s++;
else
s = 0;
ans = max(ans, s);
}
}
v.push_back(ans);
ans = 0;
}
for (int i = 0; i < v.size(); i++) cout << v[i] << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18 + 5;
long long int dp[51], fact[51];
inline long long int mult(long long int a, long long int b) {
long long int r;
try {
r = a * b;
} catch (const std::exception &e) {
return INF;
}
if (r > INF) {
return INF;
}
return r;
}
inline long long int add(long long int a, long long int b) {
long long int r = a + b;
if (r < 0 || r > INF) {
return INF;
}
return r;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
dp[0] = 1;
fact[0] = 1;
for (int i = 1; i < 51; i++) {
fact[i] = mult(fact[i - 1], i);
}
for (int i = 1; i <= 50; i++) {
dp[i] = dp[i - 1];
for (int j = 0; j < i - 1; j++) {
dp[i] = add(dp[i], mult(dp[j], fact[i - j - 2]));
}
}
int t;
cin >> t;
while (t--) {
int ind = 0;
int n;
long long int k;
cin >> n >> k;
if (dp[n] < k) {
cout << "-1\n";
continue;
}
vector<int> arr(n + 1, 0), v(n + 1, 1), p(n + 1, 0);
for (int i = 0; i < n + 1; i++) {
p[i] = i;
}
v[0] = 0;
for (int i = 1; i <= n; i++) {
int e = arr[ind + 1];
int pi = p[i];
while (p[pi] != pi) {
pi = p[pi];
}
for (int j = ind + 1; j <= n; j++) {
if (ind + 1 == i) {
long long int r = mult(dp[n - j], fact[max(1, j - i - 1)]);
if (k > r) {
k -= r;
} else {
arr[i] = j;
v[j] = 0;
p[j] = i;
if (j == i) {
ind++;
v[j] = 0;
}
break;
}
} else {
if (j == i || v[j] == 0 || (j == pi && i != e)) {
continue;
}
long long int r = mult(dp[n - e], fact[max(1, e - i - 1)]);
if (k > r) {
k -= r;
} else {
arr[i] = j;
v[j] = 0;
p[j] = i;
if (i == e) {
ind = i;
}
break;
}
}
}
}
for (int i = 1; i <= n; i++) {
cout << arr[i] << " ";
}
cout << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class T1>
void chkmin(T &x, const T1 &y) {
return x > y ? x = y, 1 : 0;
}
template <class T, class T1>
void chkmax(T &x, const T1 &y) {
return x < y ? x = y, 1 : 0;
}
const int MAXN = (1 << 20);
int n;
pair<int, int> a[MAXN];
int main_dir[MAXN];
vector<pair<int, int> > adj[MAXN];
char col[MAXN];
void read() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
}
int deg[MAXN];
void path_dfs(int u) {
while (!adj[u].empty()) {
if (col[adj[u].back().second] != 0) {
adj[u].pop_back();
continue;
}
int i = adj[u].back().second, v = adj[u].back().first;
adj[u].pop_back();
col[i] = (main_dir[i] == u) ? 'r' : 'b';
deg[u] ^= 1, deg[v] ^= 1;
path_dfs(v);
return;
}
}
void solve() {
for (int i = 0; i < n; i++) {
int u = a[i].first, v = a[i].second + (int)5e5;
adj[u].push_back(make_pair(v, i));
adj[v].push_back(make_pair(u, i));
main_dir[i] = u;
deg[u] ^= 1, deg[v] ^= 1;
}
for (int i = 1; i < MAXN; i++)
if (deg[i]) path_dfs(i);
for (int i = 1; i < MAXN; i++) path_dfs(i);
for (int i = 0; i < n; i++) cout << col[i];
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n % 2 == 0 ? cout << "white 1 2" : cout << "black";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5, inf = 1e9 + 7;
long long n, k, par[N], cur, pos[N], sz[N], in[N];
vector<long long> h[N];
inline long long expo(long long n, long long k, long long p = inf) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long i, j, a, b, ans = 0;
cin >> n >> k;
if (k > n * (n + 1) / 2 || k < n * 2 - 1) return cout << "No", 0;
for (i = 1; i <= n; i++)
h[i].emplace_back(i), par[i] = i - 1, sz[i] = (i < n);
long long p = 1, mx = 2, cur = n * (n + 1) / 2;
for (long long c = n; c > 2; c--) {
for (auto i : h[c]) {
if (cur >= k + c - p - 1) {
while (pos[p] < expo(mx, p - 1) && sz[h[p][pos[p]]] == mx) pos[p]++;
while (p < c && pos[p] == expo(mx, p - 1)) pos[p] = 0, p++;
if (p >= c - 1) p = 1, mx++;
if (cur - (c - p - 1) < k) {
while (p <= c - 1 && cur < k + c - p - 1) p++;
if (p < c - 1) {
cur -= c - p - 1;
par[i] = h[p][0];
}
break;
}
cur -= c - p - 1;
par[i] = h[p][pos[p]];
sz[h[p][pos[p]]]++;
h[p + 1].emplace_back(i);
sz[i] = 0;
} else {
if (cur == k) break;
while (p <= c - 1 && cur < k + c - p - 1) p++;
if (p < c - 1) {
cur -= c - p - 1;
par[i] = h[p][0];
break;
}
}
}
if (cur == k) break;
}
cout << "Yes\n";
for (i = 2; i <= n; i++) cout << par[i] << " ";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 150 + 5;
const int MAXD = 50 + 5;
const int mod = 51123987;
inline void add_mod(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
char s[MAXN];
int f[MAXN][MAXD][MAXD][MAXD], res[MAXD][MAXD][MAXD];
int main(void) {
int n;
scanf("%d%s", &n, s + 1);
static int nxt[MAXN][5];
nxt[n + 1][0] = nxt[n + 1][1] = nxt[n + 1][2] = n + 1;
for (int i = n; i >= 0; --i) {
for (int j = 0; j < 3; ++j) nxt[i][j] = nxt[i + 1][j];
if (i) nxt[i][s[i] - 'a'] = i;
}
int d = (n + 2) / 3;
f[0][0][0][0] = 1;
for (int i = 0; i <= n; ++i)
for (int x = 0; x <= d; ++x)
for (int y = 0; y <= d; ++y)
for (int z = 0; z <= d; ++z)
if (f[i][x][y][z]) {
int cur = f[i][x][y][z];
add_mod(res[x][y][z], cur);
add_mod(f[nxt[i][0]][x + 1][y][z], cur);
add_mod(f[nxt[i][1]][x][y + 1][z], cur);
add_mod(f[nxt[i][2]][x][y][z + 1], cur);
}
int ans = 0;
for (int x = 0; x <= d; ++x)
for (int y = max(0, x - 1); y <= x + 1; ++y) {
int z = n - x - y;
if (z < 0 || abs(x - z) > 1 || abs(y - z) > 1) continue;
add_mod(ans, res[x][y][z]);
}
printf("%d", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int bas = 23333;
const long long mod = 9999999999973ll;
int N, M, S[26], L[555];
char C[255][255];
long long H[26], W[255][255][255], G[555];
int manacher(int n) {
int k = 0, m = 0, res = 0;
memset(L, 0, sizeof(L));
for (int i = 1; i <= n; i++) {
if (G[i] == -1) {
continue;
}
int l = (m > i) ? min(L[2 * k - i], m - i) : 1;
while (G[i - l] != -1 && G[i + l] != -1 && G[i - l] == G[i + l]) {
l++;
}
if (l + i > m) {
m = l + i;
k = i;
}
L[i] = l;
res += l;
}
return (res - N - 1) >> 1;
}
int main() {
scanf("%d%d\n", &N, &M);
long long h = 1;
for (int i = 0; i < 26; i++) {
h = h * bas % mod;
H[i] = h;
}
for (int i = 1; i <= N; i++) {
scanf("%s", C[i] + 1);
for (int j = 1; j <= M; j++) {
C[i][j] -= 'a';
W[i][j][j] = H[C[i][j]];
for (int k = j - 1; k > 0; k--) {
W[i][k][j] = W[i][k + 1][j] + H[C[i][k]];
if (W[i][k][j] >= mod) {
W[i][k][j] -= mod;
}
}
memset(S, 0, sizeof(S));
int cnt = 0;
for (int k = j; k > 0; k--) {
S[C[i][k]]++;
if (S[C[i][k]] & 1) {
cnt++;
} else {
cnt--;
}
if (cnt > 1) {
W[i][k][j] = -1;
}
}
}
}
long long ANS = 0;
for (int j = 1; j <= M; j++) {
for (int k = j; k <= M; k++) {
memset(G, 0, sizeof(G));
G[0] = -1;
G[(N + 1) << 1] = -1;
for (int i = 1; i <= N; i++) {
G[i << 1] = W[i][j][k];
}
ANS += manacher((N << 1) | 1);
}
}
printf("%lld", ANS);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 20;
const int INF = 1e9 + 7;
const double eps = 1e-5;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
if (n % 2) {
int d;
for (int i = 2; i <= n; i++) {
if (n % i == 0) {
d = i;
break;
}
}
cout << n + d + 2 * (k - 1) << endl;
} else {
cout << n + 2 * k << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int A = 26;
int n;
string s[N];
int cnt[A];
bool cmp(const string& x, const string& y) {
return ((int)x.size()) > ((int)y.size());
}
void die() {
cout << "NO\n";
exit(0);
}
vector<int> g[N];
int was[A], have[A], in[A];
string result;
void dfs(int v) {
was[v] = 1;
result += char(v + 'a');
for (auto& to : g[v]) {
if (!was[to]) dfs(to);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < (n); ++i) {
cin >> s[i];
for (auto& c : s[i]) ++cnt[c - 'a'], have[c - 'a'] = 1;
for (int j = 0; j < (A); ++j) {
if (cnt[j] > 1) die();
cnt[j] = 0;
}
for (int j = 1; j < ((int)s[i].size()); ++j) {
g[s[i][j - 1] - 'a'].push_back(s[i][j] - 'a');
++in[s[i][j] - 'a'];
}
}
for (int i = 0; i < (A); ++i)
if (!was[i] && !in[i] && have[i]) dfs(i);
for (int i = 0; i < (n); ++i)
if (result.find(s[i]) == string::npos) die();
cout << result << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<char> vec[200];
vector<string> str;
void func(int c) {
vector<string> ptr;
ptr = str;
int f = 1;
for (int i = 0; i < vec[c].size(); i++) {
ptr[i] += vec[c][i];
}
for (int i = 0; i + 1 < ptr.size(); i++) {
if (ptr[i] > ptr[i + 1]) {
f = 0;
break;
}
}
if (f == 1) {
for (int i = 0; i < vec[c].size(); i++) {
str[i] += vec[c][i];
}
}
return;
}
int main() {
int n, m, ans = 0, idx, pdx;
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s = "";
str.push_back("");
}
for (int i = 0; i < n; i++) {
string str;
cin >> str;
for (int j = 0; j < str.size(); j++) {
vec[j].push_back(str[j]);
}
}
for (int i = 0; i < m; i++) {
int flag = 1;
for (int j = 0; j + 1 < vec[i].size(); j++) {
if (vec[i][j] > vec[i][j + 1]) {
flag = 0;
break;
}
}
if (flag == 1) {
for (int l = 0; l < vec[i].size(); l++) {
str[l] += vec[i][l];
}
idx = i;
break;
}
}
while (idx + 1 < m) {
func(idx + 1);
idx++;
}
cout << (m - str[0].size()) << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ld = long double;
template <typename T>
inline T in(int t) {
T n;
cin >> n;
return !t ? n : n + t;
}
const int maxn = 53;
vector<int> adj[maxn], a(maxn, 0);
bool visited[maxn];
void dfs(int v) {
visited[v] = true;
for (int u : adj[v]) {
if (!visited[u]) dfs(u);
}
}
int main() {
int n = in<int>(0), m = n - 1;
for (int i = 1; i < ((n * m) >> 1); i++) {
int x = in<int>(-1), y = in<int>(-1);
adj[x].push_back(y);
a[x]++, a[y]++;
}
int p = maxn, i = 0;
for (; i < n; i++) {
if (a[i] != m and i < p) {
dfs(i);
p = i;
}
if (a[i] != m and p < i) {
if (visited[i])
cout << ++p << ' ' << ++i << '\n';
else
cout << ++i << ' ' << ++p << '\n';
return 0;
}
}
cout << ++p << ' ' << ++i << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) cout << a[i] << " ";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> a[200005];
struct edge {
int to, nxt;
} e[200005];
int hed[200005], cnt;
inline void add(int u, int v) {
e[++cnt] = (edge){v, hed[u]};
hed[u] = cnt;
}
int num[200005], ru[200005];
int sg[200005], tag[200005], dep[200005];
inline void topo() {
queue<int> q;
for (int i = 1; i <= n; ++i)
if (!ru[i]) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < a[u].size(); ++i) tag[dep[a[u][i]]] = u;
while (tag[dep[u]] == u) dep[u]++;
sg[dep[u]] ^= num[u];
for (int i = hed[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (--ru[v] == 0) q.push(v);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", num + i);
int u, v;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u, &v);
a[u].push_back(v), add(v, u), ru[u]++;
}
topo();
for (int i = n; i >= 0; --i) {
if (sg[i] == 0) continue;
for (int j = 1; j <= n; ++j) {
if (dep[j] == i && num[j] > (num[j] ^ sg[i])) {
u = j;
break;
}
}
num[u] ^= sg[i];
for (int j = 0; j < a[u].size(); ++j) {
int v = a[u][j];
num[v] ^= sg[dep[v]], sg[dep[v]] = 0;
}
printf("WIN\n");
for (int j = 1; j <= n; ++j) printf("%d ", num[j]);
return 0;
}
printf("LOSE");
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
int n, m, r[maxn], c[maxn];
string str[maxn];
long long ans;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> str[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (str[i][j] == '*') r[i]++, c[j]++;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (str[i][j] == '*') ans += (r[i] - 1) * (c[j] - 1);
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
inline int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
int N, K;
cin >> N >> K;
int g;
cin >> g;
for (int i = 1; i < N; i++) {
int x;
cin >> x;
g = gcd(g, x);
}
vector<bool> possible(K);
int cur = g, ans = 0;
cur = cur % K;
while (!possible[cur]) {
possible[cur] = true;
ans++;
cur = (cur + g) % K;
}
cout << ans << "\n";
for (int i = 0; i < K; i++) {
if (possible[i]) cout << i << " ";
}
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
vector<int> x;
long long int a, b;
a = 0;
b = 0;
for (int i = 0; i < n; i++) {
long long int l;
cin >> l;
x.push_back(l);
if (l % 2 != i % 2) {
if (i % 2 == 0)
a++;
else
b++;
}
}
if (a != b)
cout << -1 << endl;
else
cout << a << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int8_t INFC = 0x3f;
const int16_t INFS = 0x3f3f;
const int32_t INF = 0x3f3f3f3f;
const int64_t INFL = 0x3f3f3f3f3f3f3f3fLL;
const array<string, 12> tones = {"C", "C#", "D", "D#", "E", "F",
"F#", "G", "G#", "A", "B", "H"};
int getDist(const string &s1, const string &s2) {
int res1 = -1, res2 = -1;
for (int i = 0; i < tones.size(); i++) {
if (tones[i] == s1) {
res1 = i;
break;
}
}
for (int i = 0; i < tones.size(); i++) {
if (tones[i] == s2) {
res2 = i;
break;
}
}
if (res1 <= res2)
return res2 - res1;
else
return res2 - res1 + tones.size();
}
int main() {
ios::sync_with_stdio(0);
string a[3];
cin >> a[0] >> a[1] >> a[2];
sort(a, a + 3);
do {
int res1 = getDist(a[0], a[1]);
int res2 = getDist(a[1], a[2]);
if (res1 == 4 && res2 == 3) {
cout << "major" << endl;
return 0;
}
if (res1 == 3 && res2 == 4) {
cout << "minor" << endl;
return 0;
}
} while (next_permutation(a, a + 3));
cout << "strange" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 100009;
int t, n;
int main() {
char ch[200];
cin >> ch;
int len = strlen(ch);
int ans = 0;
for (int i = 0; i < len; i++) {
if (ch[i] == 'Q') {
for (int j = i + 1; j < len; j++) {
if (ch[j] == 'A') {
for (int k = j + 1; k < len; k++) {
if (ch[k] == 'Q') ans++;
}
}
}
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int maxn = 1000;
char s[maxn], t[maxn];
int main() {
while (~scanf("%s%s", &s, &t)) {
getchar();
int i;
if (strlen(s) != strlen(t)) {
printf("No\n");
continue;
}
for (i = 0; i < strlen(s); i++) {
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u')
s[i] = 'a';
else
s[i] = 'b';
if (t[i] == 'a' || t[i] == 'e' || t[i] == 'i' || t[i] == 'o' ||
t[i] == 'u')
t[i] = 'a';
else
t[i] = 'b';
}
int flag = 1;
for (i = 0; i < strlen(s); i++)
if (s[i] != t[i]) {
flag = 0;
break;
}
if (flag == 1)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const string ORDER = "DLRU";
const string REV_ORDER = "URLD";
const int DX[] = {1, 0, 0, -1};
const int DY[] = {0, -1, 1, 0};
struct TPosition {
int X;
int Y;
};
struct TParent {
char C;
TPosition P;
};
char Rev(char c) { return ORDER[REV_ORDER.find(c)]; }
int n, m, k;
vector<string> g;
vector<vector<TParent>> parent;
vector<vector<int>> dist;
TPosition start;
void BFS() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
dist[i][j] = -1;
}
}
dist[start.X][start.Y] = 0;
queue<TPosition> q;
q.push(start);
while (!q.empty()) {
const TPosition pos = q.front();
q.pop();
for (int i = 0; i < 4; ++i) {
const TPosition p{pos.X + DX[i], pos.Y + DY[i]};
if (p.X < 0 || p.X >= n || p.Y < 0 || p.Y >= m) {
continue;
}
if (g[p.X][p.Y] == '*') {
continue;
}
if (dist[p.X][p.Y] != -1) {
continue;
}
parent[p.X][p.Y] = {Rev(ORDER[i]), pos};
dist[p.X][p.Y] = dist[pos.X][pos.Y] + 1;
q.push(p);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
g.resize(n);
for (int i = 0; i < n; ++i) {
cin >> g[i];
assert((int)g[i].size() == m);
}
if (k % 2 == 1) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (g[i][j] == 'X') {
start = {i, j};
}
}
}
parent.resize(n, vector<TParent>(m));
dist.resize(n, vector<int>(m, 0));
BFS();
string answer;
TPosition pos = start;
for (int to = k; to >= 1; --to) {
bool found = false;
for (int i = 0; i < 4; ++i) {
TPosition next{pos.X + DX[i], pos.Y + DY[i]};
if (next.X < 0 || next.X >= n || next.Y < 0 || next.Y >= m) {
continue;
}
if (g[next.X][next.Y] == '*') {
continue;
}
if (dist[next.X][next.Y] > to) {
continue;
}
found = true;
answer += ORDER[i];
pos = next;
break;
}
if (!found) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
}
cout << answer << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
long long int arr[100005];
int main() {
long long int n, s, t, i, cnt = 0, x;
scanf("%lld %lld %lld", &n, &s, &t);
for (i = 1; i <= n; i++) {
scanf("%lld", &arr[i]);
}
for (i = s; i <= n; i++) {
x = arr[i];
++cnt;
if (s == t) {
printf("0\n");
return 0;
} else if (arr[i] == t) {
printf("%lld\n", cnt);
return 0;
}
i = x;
--i;
if (cnt == n) break;
}
printf("-1\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long maxinput = 7005;
long long a[maxinput], b[maxinput];
set<long long> myset;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long temp[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
temp[i] = a[i];
}
for (long long i = 0; i < n; i++) cin >> b[i];
sort(temp, temp + n);
for (long long i = n - 2; i >= 0; i--) {
if (temp[i] == temp[i + 1]) {
for (long long j = 0; j < n; j++) {
if ((a[j] & temp[i]) == a[j]) myset.insert(j);
}
}
}
long long ans = 0;
for (auto itr = myset.begin(); itr != myset.end(); itr++) {
ans += b[(*itr)];
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int clrsvis[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
int clr[100005];
vector<int> clrindx[100005];
vector<int> adj[100005];
for (int i = 0; i < n; i++) {
cin >> clr[i];
clrindx[clr[i]].push_back(i);
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u - 1].push_back(v - 1);
adj[v - 1].push_back(u - 1);
}
int maxx = 0, ans = 999999;
map<int, int> mymap;
for (int i = 0; i < n; i++) {
int k = clr[i];
if (clrsvis[k]) continue;
clrsvis[k] = 1;
int cnt = 0;
int len = clrindx[k].size();
for (int j = 0; j < len; j++) {
int v = clrindx[k][j];
int len1 = 0;
if (!adj[v].empty()) len1 = adj[v].size();
for (int x = 0; x < len1; x++) {
int u = adj[v][x];
if (k != clr[u] && mymap.empty()) {
mymap[clr[u]] = 1;
cnt++;
} else if (k != clr[u] && mymap.find(clr[u]) == mymap.end()) {
mymap[clr[u]] = 1;
cnt++;
}
}
}
if (maxx < cnt) {
maxx = cnt;
ans = clr[i];
} else if (maxx == cnt) {
if (ans > clr[i]) ans = clr[i];
}
mymap.clear();
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int q, n;
bool ip(int n) {
int i;
if (n == 1) {
return 1;
}
for (i = 2; i * i <= n; i++) {
if (!(n % i)) {
return 0;
}
}
return 1;
}
int main() {
scanf("%d", &q);
while (q--) {
scanf("%d", &n);
if (n % 4 == 3) {
if (n < 15) {
printf("-1\n");
} else {
printf("%d\n", (n - 15) / 4 + 2);
}
continue;
}
int ans = n / 4;
n %= 4;
if (!n) {
printf("%d\n", ans);
continue;
}
int t = 0;
while (ip(n)) {
n += 4;
ans--;
t = 1;
}
if (ans < 0) {
printf("-1\n");
} else {
printf("%d\n", ans + t);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int Sz = 1 << 13;
char ibuf[Sz], *ed = ibuf + Sz, *ips = ed - 1;
int getchar() {
if (++ips == ed) ed = ibuf + fread(ips = ibuf, 1, Sz, stdin);
if (ips < ed)
return *ips;
else
return EOF;
}
} // namespace io
int read() {
int x = 0, f = 1, c = io::getchar();
for (; !isdigit(c); c = io::getchar())
if (c == '-') f ^= 1;
for (; isdigit(c); c = io::getchar()) x = x * 10 + c - 48;
return f ? x : -x;
}
const int N = 1 << 20;
namespace g {
int head[N], nxt[N], to[N], tot;
void ini() {
memset(head, -1, sizeof head);
tot = 0;
}
inline void add(int u, int v) {
nxt[tot] = head[u];
head[u] = tot;
to[tot] = v;
++tot;
}
} // namespace g
int n;
int tp[N];
int cnt[N], dp[N];
int fa[N];
const int inf = 0x3f3f3f3f;
void dfs(int u, int p) {
bool isleaf = 1;
if (tp[u] == 0) {
dp[u] = 0;
} else {
dp[u] = inf;
}
for (int e = g::head[u]; ~e; e = g::nxt[e]) {
int v = g::to[e];
if (v != p) {
isleaf = 0;
dfs(v, u);
cnt[u] += cnt[v];
if (tp[u] == 0) {
dp[u] += cnt[v] - dp[v] + 1;
} else {
dp[u] = min(dp[u], cnt[v] - dp[v] + 1);
}
}
}
if (isleaf) {
cnt[u] = 1;
dp[u] = 1;
} else {
if (tp[u] == 0) {
dp[u] = cnt[u] - dp[u] + 1;
} else {
dp[u] = cnt[u] - dp[u] + 1;
}
}
}
int main() {
g::ini();
n = read();
for (int i = 0; i < n; ++i) tp[i] = read();
for (int i = 1; i < n; ++i) {
fa[i] = read() - 1;
g::add(fa[i], i);
}
dfs(0, -1);
printf("%d\n", dp[0]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, q, a, b, i, ans = 0;
cin >> n >> k >> q;
vector<long long int> v(200005, 0);
vector<long long int> vsu(200005, 0);
vector<long long int> vzo(200005, 0);
while (n--) {
cin >> a >> b;
v[a] += 1;
v[b + 1] -= 1;
}
for (i = 1; i < 200005; i++) v[i] = v[i] + v[i - 1];
long long int c = 0;
for (i = 1; i < 200005; i++) {
if (v[i] >= k) {
++c;
}
vsu[i] = c;
}
while (q--) {
cin >> a >> b;
ans = vsu[b] - vsu[a - 1];
cout << ans << "\n";
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.