solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int solve();
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
const int MAXN = (int)1e6 + 5;
bool prime[MAXN];
vector<int> p;
int solve() {
int n;
cin >> n;
for (int i = 2; i <= n; i++) prime[i] = 1;
prime[0] = prime[1] = 0;
for (int i = 2; i <= n; i++)
if (prime[i])
if (i * 1ll * i <= n)
for (int j = i * i; j <= n; j += i) prime[j] = 0;
int d = (int)1e9;
for (int i = 2; i <= n; i++)
if (prime[i] && n % i == 0) d = min(d, max(n - i + 1, i + 1));
int cur = (int)1e9;
for (int i = 2; i <= n; i++)
if (prime[i]) {
int x = (d - (d % i) + i * (d % i != 0));
if (x <= n) cur = min(cur, max(x - i + 1, i + 1));
}
cout << cur << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 100;
const int MAXK = 5e3 + 10;
const int dx[9] = {0, 1, -1, 0, 0, -1, -1, 1, 1};
const int dy[9] = {0, 0, 0, -1, 1, -1, 1, -1, 1};
const double pi = acos(-1.0);
int n, k, a[MAXN], f[MAXK][MAXK];
int bn, sn, t;
int main() {
for (int i = 0; i <= MAXK - 1; i++)
for (int j = 0; j <= MAXK - 1; j++) f[i][j] = 2000000000;
scanf("%d", &n);
scanf("%d", &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
t = n / k;
bn = n % k, sn = k - bn;
f[0][0] = 0;
for (int i = 0; i <= bn; i++)
for (int j = 0; j <= sn; j++) {
if (i)
f[i][j] = min(f[i][j], f[i - 1][j] + a[i * (t + 1) + j * t] -
a[(i - 1) * (t + 1) + j * t + 1]);
if (j)
f[i][j] = min(f[i][j], f[i][j - 1] + a[i * (t + 1) + j * t] -
a[i * (t + 1) + (j - 1) * t + 1]);
}
printf("%d\n", f[bn][sn]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void kaam() {
long long int x, n, ans = 0, ctr = 1;
cin >> x >> n;
ans = x;
if (x % 2 == 0) {
if (n % 4 == 0)
ans = x;
else if (n % 4 == 2)
ans = x + 1;
else if (n % 4 == 1)
ans = (x - 1) - 4 * (n / 4);
else
ans = ((n / 4) + 1) * 4 + x;
} else {
if (n % 4 == 0)
ans = x;
else if (n % 4 == 2)
ans = x - 1;
else if (n % 4 == 1)
ans = (x + 1) + 4 * (n / 4);
else
ans = x - ((n / 4) + 1) * 4;
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) kaam();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize(3, "Ofast", "inline")
const long long mod = 1e9 + 7;
long long gcd(long long a, long long b) {
long long r;
while (b > 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long llread() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int intread() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
long long fp(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
const int maxn = 505;
int in[maxn], in2[maxn];
vector<int> v[maxn];
queue<int> q;
bool vis[505];
int solve(int s, int n) {
memset(vis, 0, sizeof(vis));
while (!q.empty()) q.pop();
int tot = 0;
for (int i = 1; i <= n; i++) in2[i] = in[i];
in2[s]--;
for (int i = 1; i <= n; i++) {
if (!in2[i]) q.push(i);
}
while (!q.empty()) {
int x = q.front();
q.pop();
if (vis[x]) continue;
vis[x] = 1;
tot++;
int _size = v[x].size();
for (int i = 0; i <= _size - 1; i++) {
int y = v[x][i];
in2[y]--;
if (!in2[y]) q.push(y);
}
}
if (tot == n) return 1;
return 0;
}
int main() {
int n = intread();
int m = intread();
for (int i = 1; i <= m; i++) {
int x = intread();
int y = intread();
in[y]++;
v[x].push_back(y);
}
for (int i = 1; i <= n; i++) {
in2[i] = in[i];
if (!in[i]) q.push(i);
}
int cnt = 0;
while (!q.empty()) {
cnt++;
int x = q.front();
q.pop();
int _size = v[x].size();
for (int i = 0; i <= _size - 1; i++) {
int y = v[x][i];
in2[y]--;
if (in2[y] == 0) q.push(y);
}
}
if (cnt == n) {
printf("YES\n");
} else {
for (int i = 1; i <= n; i++) {
int flag = 0;
if (in[i]) flag = solve(i, n);
if (flag) {
printf("YES\n");
return 0;
}
}
printf("NO\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string str;
cin >> str;
vector<int> counts(10, 0);
for (int i = 0; i < n; ++i) counts[str[i] - '0']++;
int min_cost = 99999999;
vector<int> best_digit;
vector<int> best_gap;
for (int i = 0; i < 10; ++i) {
int cost = 0;
int count_cur = counts[i];
int gap = 1;
while (count_cur < k) {
int avail = i - gap >= 0 ? counts[i - gap] : 0;
avail += i + gap < 10 ? counts[i + gap] : 0;
int needed = min(avail, k - count_cur);
cost += needed * gap;
count_cur += needed;
gap++;
}
if (count_cur >= k && cost <= min_cost) {
if (cost < min_cost) {
best_digit.clear();
best_gap.clear();
}
min_cost = min(min_cost, cost);
best_digit.push_back(i);
best_gap.push_back(gap - 1);
}
}
cout << min_cost << endl;
string ans = string(1, 'z');
for (int kk = 0; kk < best_digit.size(); ++kk) {
string str2 = str;
int needed = max(0, k - counts[best_digit[kk]]);
for (int i = 0; i < str2.size(); ++i) {
if (needed > 0 && abs(str2[i] - '0' - best_digit[kk]) < best_gap[kk] &&
str2[i] != char(best_digit[kk] + '0')) {
str2[i] = best_digit[kk] + '0';
needed--;
}
}
for (int i = 0; i < str2.size(); ++i) {
if (needed > 0 && str2[i] == char(best_digit[kk] + '0' + best_gap[kk])) {
str2[i] = best_digit[kk] + '0';
needed--;
}
}
for (int i = str2.size() - 1; i >= 0; --i) {
if (needed > 0 && str2[i] == char(best_digit[kk] + '0' - best_gap[kk])) {
str2[i] = best_digit[kk] + '0';
needed--;
}
}
ans = min(ans, str2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[200200], ans;
struct Node {
long long v, id, t, x;
} node[200200];
int n;
long long x, y, fx;
vector<int> g[200200];
long long dfs(int i) {
x = i;
if (x >= 1 && x <= n) {
x += a[x];
if (x >= 1 && x <= n) {
x -= a[x];
} else
return 0;
} else
return 0;
return x;
}
long long fuck(int i) {
long long tmp = 0;
x = i;
if (x >= 1 && x <= n) {
tmp += a[x];
x += a[x];
if (x >= 1 && x <= n) {
tmp += a[x];
x -= a[x];
} else
return tmp;
} else
return tmp;
return tmp;
}
void work(int i, long long tmp) {
if (node[i].t == -1) {
node[i].x = fuck(i);
for (int k = 0; k < g[i].size(); k++) {
work(g[i][k], node[i].x);
}
} else {
node[i].x += fuck(i) + tmp;
for (int k = 0; k < g[i].size(); k++) {
work(g[i][k], node[i].x);
}
}
}
long long solve() {
x = 1;
y = 0;
if (x >= 1 && x <= n) {
y += a[x];
x += a[x];
if (x >= 1 && x <= n) {
y += a[x];
x -= a[x];
} else
return y;
} else
return y;
if (x < 1 || x >= n)
return y;
else if (node[x].x == 0)
return -1;
else
return y + node[x].x;
}
int main() {
while (~scanf("%d", &n)) {
a[1] = 1;
for (int i = 1; i <= n; i++) {
node[i].id = i;
g[i].clear();
}
memset(node, 0, sizeof(node));
for (int i = 2; i <= n; i++) {
scanf("%I64d", &a[i]);
}
for (int i = 2; i <= n; i++) {
fx = dfs(i);
if (fx < 1 || fx > n)
node[i].t = -1;
else {
g[fx].push_back(i);
node[i].v++;
}
}
for (int i = 2; i <= n; i++) {
if (node[i].t == -1 && !node[i].v) {
work(i, 0);
}
}
for (int i = 1; i < n; i++) {
a[1] = i;
ans = solve();
printf("%I64d\n", ans);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long r = 0, b = 0, g = 0, y = 0;
for (int i = 0; i < s.size(); ++i) {
if (s[i] != '!') {
for (int j = i + 4; j < s.size(); j += 4) {
if (s[j] == '!') {
r += (s[i] == 'R');
y += (s[i] == 'Y');
b += (s[i] == 'B');
g += (s[i] == 'G');
s[j] = s[i];
}
}
for (int j = i - 4; j >= 0; j -= 4) {
if (s[j] == '!') {
r += (s[i] == 'R');
y += (s[i] == 'Y');
b += (s[i] == 'B');
g += (s[i] == 'G');
s[j] = s[i];
}
}
}
}
cout << r << " " << b << " " << y << " " << g << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const long double pi = 3.1415926535898;
const int mod = 1e9 + 7;
using namespace std;
const int MOD = 1000000007;
long double PI = 4 * atan(1);
int dr[10001], dc[10001];
vector<int> row[10001], col[10001];
priority_queue<pair<int, int> > todo;
vector<pair<int, int> > lights;
int dist[10001];
map<pair<int, int>, int> label;
int xdir[4] = {1, 0, -1, 0}, ydir[4] = {0, 1, 0, -1};
int n, m, k;
void filrow(int i, int val) {
if (i >= 1 && i <= n && dr[i] == 0) {
dr[i] = 1;
for (int x : row[i])
if (val < dist[x]) {
dist[x] = val;
todo.push({-dist[x], x});
}
}
}
void filcol(int i, int val) {
if (i >= 1 && i <= m && dc[i] == 0) {
dc[i] = 1;
for (int x : col[i])
if (val < dist[x]) {
dist[x] = val;
todo.push({-dist[x], x});
}
}
}
void ad(int x, int y, int val) {
if (label.find({x, y}) != label.end())
if (dist[label[{x, y}]] > val) {
dist[label[{x, y}]] = val;
todo.push({-val, label[{x, y}]});
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
int r, c;
cin >> r >> c;
lights.push_back({r, c});
row[r].push_back(i);
col[c].push_back(i);
label[{r, c}] = i;
}
for (int i = 0; i < 10001; i++) dist[i] = MOD;
if (label.find({n, m}) == label.end()) {
filrow(n - 1, 1);
filrow(n, 1);
filcol(m - 1, 1);
filcol(m, 1);
} else
todo.push({0, label[{n, m}]});
while (todo.size()) {
auto a = todo.top();
todo.pop();
a.first = -a.first;
if (a.first > dist[a.second]) continue;
for (int i = 0; i < 4; i++)
ad(lights[a.second].first + xdir[i], lights[a.second].second + ydir[i],
a.first);
for (int i = lights[a.second].first - 2; i < lights[a.second].first + 3;
i++)
filrow(i, a.first + 1);
for (int i = lights[a.second].second - 2; i < lights[a.second].second + 3;
i++)
filcol(i, a.first + 1);
}
if (dist[0] != MOD)
cout << dist[0];
else
cout << -1;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
vector<string> ans;
string t = "";
string prev = "=";
while (cin >> s) {
if (s[0] >= '0' && s[0] <= '9' && prev[prev.length() - 1] >= '0' &&
prev[prev.length() - 1] <= '9')
t += " " + s;
else
t += s;
prev = s;
}
stringstream ss(t);
while (ss >> s) {
int pos = 0;
string cur = "";
while (pos < s.length()) {
if (s[pos] == '.') {
if (cur != "") ans.push_back(cur);
cur = "...";
pos += 3;
continue;
}
cur += s[pos];
if (s[pos] == ',') {
ans.push_back(cur);
cur = "";
}
pos++;
}
if (cur != "") ans.push_back(cur);
}
for (int i = 0; i < ans.size() - 1; i++) cout << ans[i] << " ";
cout << ans.back();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int qtdBatatas, TamanhoProcessador, processos;
cin >> qtdBatatas >> TamanhoProcessador >> processos;
std::vector<long long int> batatas;
for (long long int i = 0; i < qtdBatatas; ++i) {
long long int leitor;
cin >> leitor;
batatas.push_back(leitor);
}
long long int processador = 0;
long long int i = 0;
long long int tempo = 0;
while (i < batatas.size()) {
while (processador + batatas[i] <= TamanhoProcessador &&
i < batatas.size()) {
processador += batatas[i];
++i;
}
if (processador <= processos) {
++tempo;
processador = 0;
} else {
long long int resto = processador % processos;
long long int aux = (processador - resto) / processos;
processador = resto;
tempo += aux;
}
}
if (processador > 0) {
if (processador < processos) {
tempo++;
} else {
long long int resto = processador % processos;
long long int aux = (processador - resto) / processos;
processador = resto;
tempo += aux;
}
}
cout << tempo << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000 + 10;
int dp[maxn], mx1[maxn], mx2[maxn], n, fa[maxn];
bool work(int x, int f) {
if (!f) return false;
if (dp[x] <= mx2[f])
return false;
else {
if (dp[x] >= mx1[f]) {
mx2[f] = mx1[f];
mx1[f] = dp[x];
} else
mx2[f] = dp[x];
}
int vv = max(mx1[f], mx2[f] + 1);
if (dp[f] == vv)
return false;
else {
dp[f] = vv;
return true;
}
}
int main() {
scanf("%d", &n);
dp[1] = 1;
for (int i = 2; i <= n + 1; i++) {
scanf("%d", &fa[i]);
dp[i] = 1;
for (int t = i; work(t, fa[t]); t = fa[t])
;
printf("%d\n", mx1[1]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long com[1010][1010];
int ball[1010];
void com_init() {
com[0][0] = 1;
for (int i = 1; i < 1010; i++) {
com[i][0] = 1;
for (int j = 1; j <= i; j++)
com[i][j] = (com[i - 1][j] + com[i - 1][j - 1]) % mod;
}
}
long long H(int n, int r) { return com[n + r - 1][n - 1]; }
int main() {
com_init();
int k;
while (cin >> k) {
for (int i = 1; i <= k; i++) cin >> ball[i];
long long ans = 1;
int cur = ball[1];
for (int i = 2; i <= k; i++) {
ans = ans * H(cur + 1, ball[i] - 1) % mod;
cur += ball[i];
}
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
long long min(long long a, long long b) {
if (a < b) {
return (a);
} else {
return (b);
}
}
long long h[110000];
long long l[110000];
long long r[110000];
int main() {
long long a, b, c, d, M = 0, can;
scanf("%lld", &a);
for (b = 0; b < a; b++) {
scanf("%lld", &h[b]);
}
l[0] = 1;
for (b = 1; b < a; b++) {
l[b] = min(h[b], l[b - 1] + 1);
}
r[a - 1] = 1;
for (b = a - 2; b >= 0; b--) {
r[b] = min(h[b], r[b + 1] + 1);
}
for (b = 0; b < a; b++) {
can = min(r[b], l[b]);
if (can > M) {
M = can;
}
}
printf("%lld\n", M);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string w = " RPS";
string s;
int t[4], n, m, a[105], ans[105];
int main() {
ios::sync_with_stdio(0);
int Q;
cin >> Q;
while (Q--) {
memset(ans, 0, sizeof(ans));
cin >> n >> t[1] >> t[2] >> t[3] >> s;
m = (n + 1) / 2;
for (int i = 0; i < n; i++) switch (s[i]) {
case 'R':
a[i] = 2;
break;
case 'P':
a[i] = 3;
break;
case 'S':
a[i] = 1;
break;
}
for (int i = 0; i < n; i++)
if (t[a[i]]) {
t[a[i]]--;
ans[i] = a[i];
}
if (n - (t[1] + t[2] + t[3]) < (n + 1) / 2) {
cout << "NO\n";
continue;
}
cout << "YES\n";
for (int i = 0; i < n; i++)
if (!ans[i]) {
for (int j = 1; j <= 3; j++)
if (t[j]) {
t[j]--, ans[i] = j;
break;
}
}
for (int i = 0; i < n; i++) cout << w[ans[i]];
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, A[100001], BIT[100001], res[100001];
vector<int> v;
map<int, int> m;
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) scanf("%d", &A[i]), v.push_back(A[i]);
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
int n = v.size();
for (int i = 0; i < n; ++i) m[v[i]] = i + 1;
for (int i = N; i >= 1; --i) {
int mx = 0;
for (int x = m[A[i]] - 1; x > 0; x -= x & -x)
if (mx < BIT[x]) mx = BIT[x];
res[i] = ((mx - i - 1 >= 0) ? (mx - i - 1) : -1);
for (int x = m[A[i]]; x <= n; x += x & -x)
if (!BIT[x]) BIT[x] = i;
}
for (int i = 1; i <= N; ++i) printf("%d ", res[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
vector<bool> p(1500001, true);
p[0] = p[1] = false;
for (int i = 2; i < 1500001; ++i)
if (p[i])
for (int j = 2 * i; j < 1500001; j += i) p[j] = false;
int n, x;
cin >> n >> x;
if (x == 2) {
cout << "0";
return 0;
}
set<int> S;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
S.insert(a);
}
if (S.find(1) != S.end()) {
cout << "1";
return 0;
}
if (x > 1500000) {
cout << "-1";
return 0;
}
bool odp = true;
int il = 0;
for (int i = 2; i <= x - (x % 2); ++i) {
if (p[i]) {
if (S.find(i) != S.end())
++il;
else
odp = false;
}
}
if (odp)
cout << il;
else
cout << "-1";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int a[N];
int n, m, k;
int f[N];
int jihe[N];
vector<int> v[N];
int find(int x) {
if (x != f[x]) f[x] = find(f[x]);
return f[x];
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
f[i] = i;
}
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d%d", &l, &r);
int x = find(l), y = find(r);
if (x != y) f[x] = y;
}
int tol = 1;
for (int i = 1; i <= n; i++) {
if (f[i] == i) {
jihe[i] = tol;
tol++;
}
}
for (int i = 1; i <= n; i++) {
v[jihe[find(i)]].push_back(a[i]);
}
int sum = 0;
for (int i = 1; i < tol; i++) {
int m = v[i].size();
map<int, int> st;
int ans = 0;
for (auto t : v[i]) {
st[t]++;
ans = max(ans, st[t]);
}
sum += m - ans;
}
cout << sum << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
map<tuple<int, int, int>, bool> used;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int k = i ^ j;
if (k <= n && i + j > k && k + j > i && i + k > j) {
ans++;
}
}
}
cout << ans / 3 << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
static int a[200050] = {};
memset(a, 2000000002, sizeof(a));
for (int i = 0; i < (n); ++i) {
scanf("%d", &a[i]);
};
int ret = -1;
int right = 0;
for (int left = 0; left < n; ++left) {
while ((right < n && (a[right] <= 2 * a[right - 1])) or
(right < n && right == left)) {
++right;
}
ret = max(ret, right - left);
if (right == left) ++right;
}
printf("%d\n", ret);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int lmax, rmax;
int findLen(string& A, int n, int k, char ch) {
int maxlen = 0;
int cnt = 0;
int l = 0, r = 0;
while (r < n) {
if (A[r] != ch) ++cnt;
while (cnt > k) {
if (A[l] != ch) --cnt;
++l;
}
if (r - l + 1 > maxlen) {
maxlen = r - l + 1;
rmax = r, lmax = l;
}
++r;
}
return maxlen;
}
void solve() {
long long n, k, s = 0;
cin >> n >> k;
vector<int> v(n);
for (int& x : v) cin >> x;
sort(v.begin(), v.end());
for (int i = n - k - 1; i < n; i++) s += v[i];
cout << s << '\n';
}
int main() {
long long t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> resp(n + 5, 0);
vector<int> data(n + 5, 0);
for (int i = 1; i < n + 1; i++) {
cin >> data[i];
}
int fin = 0;
int mini = 0;
for (int i = 1; i < n + 1; i++) {
mini = min(mini, data[i] - i);
resp[i] = i + mini;
}
mini = n + 1;
for (int i = n; i > 0; i--) {
mini = min(mini, data[i] + i);
resp[i] = min(resp[i], mini - i);
}
for (int i = 1; i < n + 1; i++) {
fin = max(fin, resp[i]);
}
cout << fin << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k;
int n, m, t;
scanf("%d%d", &n, &k);
pair<int, int> a[n];
for (i = 0; i < n; i++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a, a + n, greater<pair<int, int> >());
set<int> s;
for (i = 0; i < n; i++) s.insert(i);
string ans(n, '0');
i = 0;
m = 1;
while (s.size()) {
while (!s.count(a[i].second) && i < n) i++;
vector<int> vec;
if (i >= n) break;
auto itr = s.find(a[i].second);
for (j = 0; j <= k; j++) {
if (itr == s.begin()) {
vec.push_back(*itr);
break;
}
vec.push_back(*itr);
itr--;
}
itr = next(s.find(a[i].second));
for (j = 0; j < k; j++) {
if (itr == s.end()) break;
vec.push_back(*itr);
itr++;
}
for (int e : vec) ans[e] = m + '0', s.erase(e);
if (m == 1)
m = 2;
else
m = 1;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
int N, M, dx, dy;
int xidx[MAXN];
int cnt[MAXN];
int ans[MAXN][2];
int main() {
cin >> N >> M >> dx >> dy;
for (int i = 0; i < N; i++) xidx[((long long)i * dx) % N] = i;
for (int i = 0; i < M; i++) {
int x, y;
cin >> x >> y;
int val = (y - (long long)xidx[x] * dy) % N;
if (val < 0) val += N;
cnt[val]++;
ans[val][0] = x, ans[val][1] = y;
}
int best = 0;
for (int i = 1; i < N; i++)
if (cnt[best] < cnt[i]) best = i;
cout << ans[best][0] << " " << ans[best][1] << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int r, s = 0, c;
for (; !isdigit(c = getchar()); s = c)
;
for (r = c ^ 48; isdigit(c = getchar()); (r *= 10) += c ^ 48)
;
return s ^ 45 ? r : -r;
}
const int N = 300010, L = 20;
int n, opt, f;
int a[2][N], l[2], l3;
int d, d1, d2, d3;
int fa[N][L];
int dep[N];
void modify(int u, int f) {
dep[u] = dep[f] + 1;
fa[u][0] = f;
for (int i = 1; (1 << i) <= dep[u]; i++) fa[u][i] = fa[fa[u][i - 1]][i - 1];
}
int dis(int u, int v) {
if (u == v) return 0;
if (dep[u] < dep[v]) swap(u, v);
int ans = 0;
for (int i = 19; i >= 0; i--)
if (dep[v] + (1 << i) <= dep[u]) {
u = fa[u][i];
ans += (1 << i);
}
if (u == v) return ans;
for (int i = 19; i >= 0; i--)
if (fa[u][i] != fa[v][i]) {
ans += ((1 << i) << 1);
u = fa[u][i], v = fa[v][i];
}
return ans + 2;
}
void debug(int x) {
cout << "-----------------------" << endl;
cout << x << ":\n";
cout << l[0] << ' ' << l[1] << endl;
for (int i = 1; i <= l[0]; i++) cout << a[0][i] << ' ';
cout << endl;
for (int i = 1; i <= l[1]; i++) cout << a[1][i] << ' ';
cout << endl;
cout << "-----------------------" << endl;
}
int main() {
n = read();
a[0][1] = 1, l[0] = 1;
a[1][1] = 2, l[1] = 1;
dep[1] = 1, dep[2] = 2;
f = read();
d = 1;
puts("2");
modify(1, 0);
modify(2, 1);
for (int i = 3; i <= n + 1; i++) {
d1 = d2 = 0;
f = read();
modify(i, f);
if (l[0]) d1 = dis(i, a[0][1]);
if (l[1]) d2 = dis(i, a[1][1]);
d3 = max(d1, d2);
if (d3 == d1)
opt = 0;
else
opt = 1;
l3 = 0;
if (d3 > d) {
d = d3;
for (int j = 1; j <= l[opt ^ 1]; j++)
if (dis(i, a[opt ^ 1][j]) == d) a[opt][++l[opt]] = a[opt ^ 1][j];
l[opt ^ 1] = 0;
}
if (d3 == d) a[opt ^ 1][++l[opt ^ 1]] = i;
printf("%d\n", l[0] + l[1]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int INF = 1 << 29;
using namespace std;
void put(int i) {
cout << (i == 0 ? 0 : i);
exit(0);
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
;
int n, x, y;
cin >> n;
vector<int> v(n);
for (int &it : v) cin >> it;
cin >> x >> y;
for (int i = 0; i < n; ++i) {
int g1 = 0, g2 = 0;
for (int j = 0; j < i; ++j) {
g1 += v[j];
}
for (int j = i; j < n; ++j) g2 += v[j];
if (g1 >= x && g1 <= y && g2 >= x && g2 <= y) put(i + 1);
}
put(0);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000001000;
const long long INFL = 2000000000000001000;
int solve();
int main() {
srand(2317);
cout.precision(10);
cout.setf(ios::fixed);
int tn = 1;
for (int i = 0; i < tn; ++i) solve();
}
int s[100001];
int deg[100001];
bool used[100001];
queue<int> q;
vector<pair<int, int> > ans;
int solve() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> deg[i] >> s[i];
if (deg[i] < 2) {
q.push(i);
used[i] = true;
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
if (deg[u] == 0) continue;
--deg[u];
int v = s[u];
--deg[v];
s[v] ^= u;
ans.push_back({u, v});
if (deg[v] < 2 && !used[v]) {
q.push(v);
used[v] = true;
}
}
cout << ((int)(ans).size()) << '\n';
for (auto e : ans) cout << e.first << ' ' << e.second << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 1) {
cout << "Ehab";
} else {
cout << "Mahmoud";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long powm(long long base, long long exp, long long mod = 1000000007) {
base %= mod;
long long ans = 1;
while (exp) {
if (exp & 1LL) ans = (ans * base) % mod;
exp >>= 1LL, base = (base * base) % mod;
}
return ans;
}
string s;
long long dp[5003][5003];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
char c;
cin >> c;
s.push_back(c);
}
int x = 1;
if (s[0] == 's') {
dp[0][0] = 1;
} else {
int j = 0;
while (s[j] == 'f') j++;
dp[j][j] = 1;
x = j + 1;
for (int k = n - 1; k >= 0; k--) {
dp[j][k] = ((dp[j][k + 1] + dp[j][k]) % 1000000007);
}
}
for (long long i = x; i < n; i++) {
if (s[i] == 'f') {
int j = i;
while (s[j] == 'f') j++;
int b = j - i + 1;
for (int k = b - 1; k < n; k++) {
if (dp[i - 1][k - b + 1] == 0) break;
dp[j][k] = dp[i - 1][k - b + 1];
}
i = j;
} else {
for (int k = 0; k < n; k++) {
if (dp[i - 1][k] == 0) break;
dp[i][k] = dp[i - 1][k];
}
}
for (int k = n - 1; k >= 0; k--) {
dp[i][k] = ((dp[i][k + 1] + dp[i][k]) % 1000000007);
}
}
cout << dp[n - 1][0] << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long add(long long x, long long y) { return (x + y) % MOD; }
long long n, m, dp[2005][4005][2];
string s;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> s;
long long Min = 0, last = 0;
for (long long i = 0; i < m; i++) {
if (s[i] == '(')
last++;
else
last--;
Min = min(Min, last);
}
if (abs(last) > n - m) {
cout << 0;
return 0;
}
dp[0][0][0] = 1;
if (Min >= 0) dp[0][last][1] = 1;
for (long long i = 1; i <= n - m; i++) {
for (long long j = 0; j < 4004; j++) {
dp[i][j][0] = add(dp[i][j][0], dp[i - 1][j + 1][0]);
if (j > 0) dp[i][j][0] = add(dp[i][j][0], dp[i - 1][j - 1][0]);
}
for (long long j = 0; j < 4004; j++) {
if (j - last >= 0 && j - last < 4004 && j - last + Min >= 0) {
dp[i][j][1] = add(dp[i][j][1], dp[i][j - last][0]);
}
dp[i][j][1] = add(dp[i][j][1], dp[i - 1][j + 1][1]);
if (j > 0) dp[i][j][1] = add(dp[i][j][1], dp[i - 1][j - 1][1]);
}
}
cout << dp[n - m][0][1];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long my_pow(long long _x, long long _n) {
long long ret = 1;
while (0 < _n) {
if ((_n % 2) == 0) {
_x = (_x * _x) % 1000000007LL;
_n >>= 1;
} else {
ret = (ret * _x) % 1000000007LL;
--_n;
}
}
return ret;
}
map<long long, long long> fm;
int main() {
long long m, n = 1;
cin >> m;
long long p;
for (long long i = 0; i < m; i++) {
cin >> p;
if (fm.find(p) == fm.end()) {
fm[p] = 1;
} else {
fm[p]++;
}
}
long long ans = 1;
bool issq = true;
long long tp = -1;
for (auto pp : fm) {
if (issq && pp.second % 2 == 1) {
issq = false;
tp = pp.first;
}
}
if (issq) {
for (auto pp : fm) {
n = (n * my_pow(pp.first, pp.second / 2)) % 1000000007LL;
}
ans = n;
for (auto pp : fm) {
ans = my_pow(ans, pp.second + 1) % 1000000007LL;
}
} else {
for (auto pp : fm) {
n = (n * my_pow(pp.first, pp.second)) % 1000000007LL;
}
ans = n;
for (auto pp : fm) {
if (pp.first == tp) {
if ((pp.second + 1) / 2 > 1) {
ans = my_pow(ans, (pp.second + 1) / 2) % 1000000007LL;
}
} else {
ans = my_pow(ans, pp.second + 1) % 1000000007LL;
}
}
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, mod = 1e9 + 7;
string second, t;
int idx[N];
int main() {
cin >> second >> t;
int cur = t.size() - 1, ans = 0;
for (int i = second.size() - 1; i >= 0; i--) {
if (t[cur] == second[i]) {
idx[cur] = i;
cur--;
}
if (cur < 0) ans = max(ans, i);
}
cur = 0;
for (int i = 0; i < second.size(); i++) {
if (t[cur] == second[i] && cur != t.size() - 1) {
ans = max(ans, idx[cur + 1] - i - 1);
cur++;
} else if (t[cur] == second[i])
ans = max(ans, (int)second.size() - i - 1);
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
static const long long MOD = 1000000007;
template <class T>
void DEBUGA(T arr[], T n) {
for (int i = 0; i < (n); i++) cout << arr[i] << " ";
cout << "\n";
}
void solve() {
int n, a;
cin >> (n) >> (a);
long long int pos[n + 2], neg[n + 2];
long long int p = 0, m = 0, rem = n - 1;
for (int i = 0; i < (n); i++) {
long long int b;
cin >> (b);
if (b < a)
neg[++m] = a - b;
else if (b > a)
pos[++p] = b - a;
else
rem--;
}
pos[0] = neg[0] = 0;
sort(pos + 1, pos + p + 1);
sort(neg + 1, neg + m + 1);
long long int ans = INFL, cur, rm;
if (p == n) {
ans = pos[rem];
cout << (ans) << "\n";
return;
}
if (m == n) {
ans = neg[rem];
cout << (ans) << "\n";
return;
}
if (rem <= 0) {
cout << (0) << "\n";
return;
}
rm = rem - p;
cur = 2 * pos[p] + neg[rm];
if (cur < ans) ans = cur;
cur = 2 * neg[rm] + pos[p];
if (cur < ans) ans = cur;
rm = rem - m;
cur = 2 * neg[m] + pos[rm];
if (ans > cur) ans = cur;
cur = 2 * pos[rm] + neg[m];
if (ans > cur) ans = cur;
cout << (ans) << "\n";
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m;
cin >> n >> m;
vector<int> answer(n, -1);
set<int> st;
for (int i = 0; i < n; i++) st.insert(i);
int l, r, x;
for (int i = 0; i < m; i++) {
cin >> l >> r >> x;
l--, r--, x--;
for (auto j = st.lower_bound(l); j != st.upper_bound(r);) {
if (*j != x) {
answer[*j] = x;
st.erase(*j);
j = st.lower_bound(l);
} else {
j++;
}
}
}
for (int i = 0; i < n - 1; i++) {
cout << answer[i] + 1 << " ";
}
cout << answer[n - 1] + 1 << endl;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
long long int invmod(long long int x, long long int n, long long int mod) {
if (n == 0) return 1 % mod;
long long int half = invmod(x, n / 2, mod);
half = (half * half) % mod;
if (n % 2 == 1) half = (half * (x % mod)) % mod;
return half;
}
long long int bin(long long int a[], long long int l, long long int r,
long long int x) {
if (l <= r) {
long long int m = l + (r - l) / 2;
if (a[m] == x)
return m;
else if (a[m] > x)
return bin(a, l, m - 1, x);
else
return bin(a, m + 1, r, x);
} else
return -1;
}
long long int power(long long int b, long long int e, long long int m) {
if (e == 0) return 1;
if (e % 2)
return b * power(b * b % m, (e - 1) / 2, m) % m;
else
return power(b * b % m, e / 2, m);
}
long long int power(long long int b, long long int e) {
if (e == 0) return 1;
if (e % 2)
return b * power(b * b, (e - 1) / 2);
else
return power(b * b, e / 2);
}
long long int ncr(long long int n, long long int r, long long int x) {
if (r == 0) return 1;
long long int fac[n + 1];
fac[0] = 1;
for (long long int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % x;
return (fac[n] * power(fac[r], x - 2, x) % x * power(fac[n - r], x - 2, x) %
x) %
x;
}
long long int ncr(long long int n, long long int p) {
long long int r = min(p, n - p), rf = 1, ln = 1;
for (long long int i = 1; i <= r; i++) rf = rf * i;
for (long long int i = 0; i < r; i++) ln = ln * (n - i);
return ln / rf;
}
bool sbs(pair<long long int, long long int> &a,
pair<long long int, long long int> &b) {
return (a.second < b.second);
}
bool sbds(pair<long long int, long long int> &a,
pair<long long int, long long int> &b) {
return (a.second > b.second);
}
bool sdf(pair<long long int, long long int> &a,
pair<long long int, long long int> &b) {
return (a.first > b.first);
}
long long int SUM(long long int a[], long long int n) {
long long int sum = 0;
for (long long int i = 0; i < n; i++) sum += a[i];
return sum;
}
long long int chkprm(long long int n) {
long long int x = 5, s = sqrt(n);
if (n < 2) return 0;
if (n < 4) return 1;
if ((n & 1) == 0) return 0;
if (n % 3 == 0) return 0;
while (x <= s) {
if (n % x == 0) return 0;
x += 2;
if (n % x == 0) return 0;
x += 4;
}
return 1;
}
long long int search(long long int mx, long long int i, long long int n) {
if (i == n) return i;
long long int x = (n - i + 1) / 2, m;
cout << "? " << x << " ";
for (long long int j = i; j <= i + x - 1; j++) cout << j << " ";
cout << "\n";
cout.flush();
cin >> m;
if (m == mx)
return search(mx, i, i + x - 1);
else
return search(mx, i + x, n);
}
void myth() {
long long int n;
cin >> n;
long long int k;
cin >> k;
set<long long int> a[k];
for (long long int i = 0; i < k; i++) {
long long int x;
cin >> x;
for (long long int j = 0; j < x; j++) {
long long int y;
cin >> y;
a[i].insert(y);
}
}
cout << "? " << n << " ";
for (long long int i = 0; i < n; i++) cout << i + 1 << " ";
cout << "\n";
cout.flush();
long long int mx1, mx2;
cin >> mx1;
long long int ind = search(mx1, 1, n);
vector<long long int> ans;
for (long long int i = 0; i < k; i++) {
if (a[i].find(ind) != a[i].end()) {
cout << "? " << n - a[i].size() << " ";
for (long long int j = 1; j <= n; j++)
if (a[i].find(j) == a[i].end()) cout << j << " ";
cout << "\n";
cout.flush();
cin >> mx2;
ans.push_back(mx2);
} else
ans.push_back(mx1);
}
cout << "! ";
for (auto i : ans) cout << i << " ";
cout << "\n";
cout.flush();
string s;
cin >> s;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int test_case = 1;
cin >> test_case;
while (test_case--) {
myth();
cout << "\n";
}
cerr << "\n"
<< "Time Elasped : " << 1.0 * clock() / CLOCKS_PER_SEC << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char p[1100000], s[1100000];
int n, m, k, l, ans[1100000], now[1100000];
bool check(int x, int y) {
if (!y) return 0;
int i, j;
for (i = x, j = y - 1; j < m; i += k, j += l) {
if (p[i] != s[j]) return 0;
}
if (i < n) return 0;
return 1;
}
bool cmp() {
for (int i = 0; i < k; i++) {
if (now[i] != ans[i]) {
return ans[i] > now[i];
}
}
return 0;
}
int main() {
int i, j;
bool flag;
gets(p);
gets(s);
scanf("%d", &k);
n = strlen(p), m = strlen(s);
flag = 0;
for (l = 1; l <= k; l++) {
for (i = k - 1, j = l; i >= 0; i--) {
if (check(i, j))
now[i] = 1, j--;
else
now[i] = 0;
}
if (j == 0) {
if (!flag || cmp()) {
for (i = 0; i < k; i++) ans[i] = now[i];
}
flag = 1;
}
}
if (!flag)
puts("0");
else {
for (i = 0; i < k; i++) printf("%d", ans[i]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, aux, halp = 1;
map<long long, long long> gud;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> x;
while (n > 0 && m > 0) {
if ((n * m) % 2 == 0) {
aux = (n * m) / 2;
} else
aux = ((n * m) / 2) + 1;
gud[halp] = aux;
n -= 2, m -= 2, halp++;
}
aux = gud[x] - gud[x + 1];
cout << aux;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define i64 int64_t
#define i32 int32_t
#define ll long long int
#define pb push_back
#define all(x) x.begin(),x.end()
#define ff first
#define ss second
#define pii pair<int,int>
#define sz(x) ((int)x.size())
template<typename T, typename U> inline void amin(T &a,U b) { a = (a > b ? b : a);}
template<typename T, typename U> inline void amax(T &a,U b) { a = (a > b ? a : b);}
const int mod = 1e9 + 7, N = 1006;
i64 dp[N][N][2], n, k;
i64 solve(int i, int age, int dir) {
if(i < 1 or i > n) {
return 0;
}
/* age = 1 particle produces 0 new particles */
if(age == 1) {
return dp[i][age][dir] = 0;
}
if(dp[i][age][dir] != -1) {
return dp[i][age][dir];
}
if(dir == 0) {
/* | ->| | => |<= | ->| (|: plane, -> D(age), <= D(age - 1)) */
return (dp[i][age][dir] = 1 + (solve(i - 1, age - 1, dir^1)) + solve(i + 1, age, dir))% mod;
} else {
/* | |<- | => |<- | =>| (|: plane, -> D(age), <= D(age - 1)) */
return (dp[i][age][dir] = 1 + (solve(i + 1, age - 1, dir^1)) + solve(i - 1, age, dir))% mod;
}
}
void solve(){
cin >> n >> k;
memset(dp, -1, sizeof dp);
cout << solve(1, k, 0) + 1 << '\n';
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tests = 1;
cin >> tests;
while(tests--){
solve();
}
#ifdef LOCAL_DEFINE
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
}
/* stuff you should look for
* int overflow, array bounds
* special cases (n=1?)
* DON'T GET STUCK ON ONE APPROACH
*/ | 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 5;
const int mod = 1000000007;
vector<int> v;
int a[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= 2 * n; i++) scanf("%d", &a[i]);
int ans = mod;
for (int i = 1; i <= n + n; i++)
for (int j = i + 1; j <= n + n; j++) {
v.clear();
for (int k = 1; k <= n + n; k++) {
if (k == i || k == j) continue;
v.push_back(a[k]);
}
sort(v.begin(), v.end());
int temp = 0;
for (int k = 0; k < v.size(); k += 2) temp += v[k + 1] - v[k];
ans = min(temp, ans);
}
printf("%d ", ans);
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
char buf[1 << 23], *p1 = buf, *p2 = buf, obuf[1 << 23], *O = obuf;
inline int read() {
int x = 0, sign = 0;
char s =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 22, stdin), p1 == p2)
? EOF
: *p1++);
while (!isdigit(s))
sign |= s == '-',
s = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, 1 << 22, stdin), p1 == p2)
? EOF
: *p1++);
while (isdigit(s))
x = (x << 1) + (x << 3) + (s - '0'),
s = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 22, stdin), p1 == p2)
? EOF
: *p1++);
return sign ? -x : x;
}
inline void print(int x) {
if (x > 9) print(x / 10);
(*O++ = x % 10 + '0');
}
} // namespace IO
namespace math {
const int mod = 1e9 + 7;
const int maxn = 1e6 + 5;
long long ksm(long long a, long long b) {
long long s = 1, m = a;
while (b) {
if (b & 1) s = s * m % mod;
m = m * m % mod, b >>= 1;
}
return s;
}
long long inv(long long x) { return ksm(x, mod - 2); }
long long fc[maxn], ifc[maxn];
void init_m(int n) {
fc[0] = 1;
for (int i = 1; i <= n; i++) fc[i] = fc[i - 1] * i % mod;
ifc[n] = inv(fc[n]);
for (int i = n - 1; i >= 0; i--) ifc[i] = ifc[i + 1] * (i + 1) % mod;
}
long long C(long long n, long long m) {
return fc[n] * ifc[m] % mod * ifc[n - m] % mod;
}
} // namespace math
using namespace IO;
const int N = 1e5 + 5;
int n, p[N], pre[N], cnt, pr[N], res, pd[N];
int gt, qu, ori;
void del(int x) {
for (int j = x; j <= ori; j += x)
if (!pd[j]) res--, pd[j] = 1;
}
void pa(int x) {
qu++;
assert(qu < 1e4);
cout << "A " << x << endl;
cin >> gt;
}
void emplace_back(int x) {
qu++;
assert(qu < 1e4 && x > 1);
cout << "B " << x << endl;
cin >> gt;
}
int find(int st) {
if (st == 0) return 1;
int lim = st / 2;
for (int i = st; i > lim; i--) emplace_back(pr[i]), del(pr[i]);
pa(1);
if (gt != res) {
int ans = 1;
for (int i = st; i > lim; i--) {
long long tmp = pr[i];
while (tmp <= n) {
pa(tmp);
if (!gt) {
tmp /= pr[i];
break;
}
tmp *= pr[i];
}
if (tmp > n) tmp /= pr[i];
if (tmp > 1) ans *= tmp, n /= tmp;
}
return ans * find(min(lim, pre[n]));
} else
return find(lim);
}
void solve() {
cin >> n, res = ori = n;
int cal = 0;
for (int i = 2; i <= n; i++) {
if (!p[i]) {
pr[++cnt] = i;
for (int j = i + i; j <= n; j += i) p[j] = 1;
}
pre[i] = pre[i - 1] + !p[i];
}
cout << "C " << find(cnt) << endl, assert(qu < 1e4);
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
| 9 |
// iostream is too mainstream
#include <cstdio>
// bitch please
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <chrono>
#include <random>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cstring>
#include <iomanip>
#define dibs reserve
#define OVER9000 1234567890
#define tisic 47
#define soclose 1e-8
#define patkan 9
#define ff first
#define ss second
using uint = unsigned int;
using cat = long long;
using dbl = long double;
constexpr dbl pi = 3.14159265358979323846;
using namespace std;
#ifdef DONLINE_JUDGE
// palindromic tree is better than splay tree!
#define lld I64d
#endif
template <typename T>
T abs(T x) { return (x < 0) ? (-x) : x; }
cat pw(cat a, cat e, cat mod) {
if(e <= 0) return 1;
cat x = pw(a, e/2, mod);
x = x * x % mod;
return (e&1) ? x * a % mod : x;
}
template <typename T>
class fin {
vector<T> node_val;
int lastone(int x) { return x & (x ^ (x-1)); }
public:
fin(int N, T init_val) {
node_val.resize(N+10, init_val);
}
void put(int pos, T val) {
for(int i = pos+1; i < (int)node_val.size(); i += lastone(i))
node_val[i] += val;
}
T get(int pos) {
T ret = 0;
for(int i = pos+1; i > 0; i -= lastone(i))
ret += node_val[i];
return ret;
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(12);
int T;
cin >> T;
while(T--) {
int N;
cin >> N;
int l = 0;
vector<int> A(N, 0);
while(l < N-1) {
cout << "? 1 " << N-1-l << "\n" << l+1 << "\n";
for(int i = l+1; i < N; i++) cout << i+1 << ((i == N-1) ? "" : " ");
cout << endl;
int F;
cin >> F;
if(F == 0) {
l++;
continue;
}
A[l] = 1;
for(int i = l+1; i < N-1; i++) {
cout << "? 1 1\n" << i+1 << "\n" << l+1 << endl;
cin >> A[i];
}
A[N-1] = F;
for(int i = l+1; i < N-1; i++) A[N-1] -= A[i];
break;
}
int nl = 0;
if(l) {
cout << "? 1 " << l << "\n" << l+1 << "\n";
for(int i = 0; i < l; i++) cout << i+1 << ((i == l-1) ? "" : " ");
cout << endl;
cin >> nl;
}
if(nl) {
int l1 = 0, r1 = l;
int r = l;
while(A[r]+A[l] != 0) r++;
if(A[l] != nl) swap(l, r);
while(r1-l1 > 1) {
int m1 = (2 * l1 + r1 + 2) / 3;
int m2 = (m1 + r1 + 1) / 2;
cout << "? " << 1+m1-l1 << " " << 1+m2-m1 << "\n" << l+1;
for(int i = l1; i < m1; i++) cout << " " << i+1;
cout << "\n" << r+1;
for(int i = m1; i < m2; i++) cout << " " << i+1;
cout << endl;
int F;
cin >> F;
if(F == 0) l1 = m1, r1 = m2;
else if(F == -2) r1 = m1;
else l1 = m2;
}
A[l1] = nl;
}
vector<int> ans;
for(int i = 0; i < N; i++) if(A[i] == 0) ans.push_back(i);
cout << "! " << ans.size();
for(int i = 0; i < (int)ans.size(); i++) cout << " " << ans[i]+1;
cout << endl;
}
}
// look at my code
// my code is amazing
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 9;
const int maxn = 105;
int in[maxn], ma[maxn][maxn], root, n, m, vis[maxn], dp[maxn][maxn], nm[maxn],
now[maxn], siz[maxn], ans[maxn], c[maxn][maxn], inv[maxn], pp[maxn][maxn];
queue<int> q;
inline void add(int &x, int y) { x + y >= mod ? x = x + y - mod : x += y; }
void dfs(int u, int pre, int opt) {
siz[u] = 1;
dp[u][0] = 1;
dp[u][1] = 0;
if (opt) vis[u] = 2;
if (root < u) root = u;
for (int i = 1; i <= n; ++i) {
if ((!ma[u][i]) || i == pre || vis[i] != 1) continue;
dfs(i, u, opt);
for (int j = 0; j <= siz[u] + siz[i]; ++j) {
now[j] = 0;
}
for (int j = 0; j <= siz[u]; ++j) {
for (int k = 0; k <= siz[i]; ++k) {
add(now[j + k], 1LL * c[k + j][j] * dp[u][j] % mod * dp[i][k] % mod);
}
}
siz[u] += siz[i];
for (int j = 0; j <= siz[u]; ++j) dp[u][j] = now[j];
}
add(dp[u][siz[u]], dp[u][siz[u] - 1]);
}
int main() {
scanf("%d%d", &n, &m);
c[0][0] = 1;
for (int i = 1; i <= 100; ++i) {
c[i][0] = 1;
for (int j = 1; j <= i; ++j) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
if (c[i][j] >= mod) c[i][j] -= mod;
}
}
inv[1] = 1;
ans[0] = 1;
for (int i = 2; i <= 100; ++i)
inv[i] = mod - 1LL * inv[mod % i] * (mod / i) % mod;
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
in[x]++;
in[y]++;
ma[x][y] = ma[y][x] = 1;
}
for (int i = 1; i <= n; ++i) {
if (in[i] <= 1) q.push(i), vis[i] = 1;
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 1; i <= n; ++i) {
if (ma[u][i]) {
in[i]--;
if (in[i] <= 1 && (!vis[i])) q.push(i), vis[i] = 1;
}
}
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
for (int to = 1; to <= n; ++to) {
if (ma[i][to] && (vis[to] == 1)) {
dfs(to, 0, 1);
for (int j = n; j >= 0; --j) {
ans[j] = 1LL * ans[j] * dp[to][0] % mod;
for (int k = min(siz[to], j); k >= 1; --k) {
add(ans[j], 1LL * ans[j - k] * dp[to][k] % mod * c[j][k] % mod);
}
}
}
}
}
}
for (int i = 1; i <= n; ++i) {
if (vis[i] == 1) {
root = 0;
dfs(i, 0, 0);
nm[root] = 1;
for (int j = 0; j <= siz[i]; ++j)
add(pp[root][j],
1LL * dp[i][j] * inv[siz[i] == j ? 1 : siz[i] - j] % mod);
}
}
for (int i = 1; i <= n; ++i) {
if (nm[i]) {
for (int j = n; j >= 0; --j) {
ans[j] = 1LL * ans[j] * pp[i][0] % mod;
for (int k = min(siz[i], j); k >= 1; --k) {
add(ans[j], 1LL * ans[j - k] * pp[i][k] % mod * c[j][k] % mod);
}
}
}
}
for (int i = 0; i <= n; ++i) printf("%d\n", ans[i]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bitset<2000005> bs;
vector<int> p;
void build() {
bs[0] = bs[1] = 1;
for (int i = 2; i < 2000005; i++) {
if (!bs[i]) p.push_back(i);
for (int j = 0; i * p[j] < 2000005; j++) {
bs[i * p[j]] = 1;
if (i % p[j] == 0) break;
}
}
}
int in[1005];
bitset<1005> G[1005], now;
int main() {
{
cin.tie(0);
ios_base::sync_with_stdio(false);
};
int tt = clock();
build();
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) cin >> in[i], v.push_back(i);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i != j && !bs[in[i] + in[j]]) {
G[i][j] = G[j][i] = 1;
}
int ans = 0;
bitset<1005> best;
while ((clock() - tt) * 1.0 / CLOCKS_PER_SEC < 0.95) {
random_shuffle(v.begin(), v.end());
now.reset();
int r = 0;
for (int i : v)
if ((G[i] & now) == now) {
now[i] = 1;
r++;
}
if (ans < r) {
ans = r;
best = now;
}
}
cout << ans << '\n';
for (int i = 0; i < n; i++)
if (best[i]) cout << in[i] << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long long INF = 1e9;
const long long MOD = 1e9 + 7;
const long long zero = 0;
const long long N = 1e5 + 5;
using namespace std;
int main() {
long long n, ans(1);
cin >> n;
long long a[n];
bool v[200001] = {};
for (int i = 0; i < n; i++) {
cin >> a[i];
if (v[a[i]]) ans++;
v[a[i]] = 1;
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int N = 105;
const int M = 1005;
const int INF = 1e9;
int n, m, st, ed;
struct edge {
int x, f, nxt;
} e[M * 10];
int h[N], tot;
struct EDGE {
int x, y, g;
} eg[M];
int que[N];
int dis[N];
struct ANSWER {
int f, c;
} ans[M];
int be[M * 10];
int d[N];
int St, Ed, points;
void addedge(int x, int y, int f) {
e[++tot].x = y;
e[tot].f = f;
e[tot].nxt = h[x];
h[x] = tot;
}
void inse(int x, int y, int f) {
addedge(x, y, f);
addedge(y, x, 0);
}
bool bfs() {
for (int i = 1; i <= points; i++) dis[i] = -1;
int he = 0, ta = 1;
dis[que[1] = st] = 0;
for (; he < ta;) {
int x = que[++he];
for (int p = h[x]; p; p = e[p].nxt)
if (e[p].f && dis[e[p].x] == -1) {
dis[e[p].x] = dis[x] + 1;
que[++ta] = e[p].x;
}
}
return dis[ed] != -1;
}
int aug(int x, int f) {
if (x == ed) return f;
int ret = 0;
for (int p = h[x]; p; p = e[p].nxt)
if (e[p].f && dis[e[p].x] == dis[x] + 1) {
int tmp = aug(e[p].x, min(f, e[p].f));
f -= tmp, ret += tmp;
e[p].f -= tmp, e[p ^ 1].f += tmp;
if (!f) return ret;
}
return ret;
}
int main() {
n = get();
m = get();
st = get();
ed = get();
tot = 1, points = n;
for (int i = 1; i <= m; i++) {
eg[i].x = get();
eg[i].y = get();
eg[i].g = get();
int pretot = tot;
if (eg[i].g)
inse(eg[i].x, eg[i].y, 1), inse(eg[i].y, eg[i].x, INF);
else
inse(eg[i].x, eg[i].y, INF);
for (int x = pretot + 1; x <= tot; x++) be[x] = i;
}
int mxans = 0;
while (bfs()) mxans += aug(st, INF);
cout << mxans << endl;
for (int i = 1; i <= n; i++)
if (dis[i] != -1) {
for (int p = h[i]; p; p = e[p].nxt)
if (dis[e[p].x] == -1) ans[be[p]].f = ans[be[p]].c = 1;
}
for (int i = 0; i <= tot; i++) be[i] = 0;
tot = 1, points = n + 2;
St = st, Ed = ed;
st = n + 1, ed = n + 2;
for (int i = 1; i <= points; i++) h[i] = 0;
for (int i = 1; i <= m; i++)
if (eg[i].g) {
if (ans[i].f)
d[eg[i].x]--, d[eg[i].y]++;
else {
d[eg[i].x]--, d[eg[i].y]++;
be[tot + 1] = i;
inse(eg[i].x, eg[i].y, INF);
}
}
d[St] += 1e5, d[Ed] -= 1e5;
inse(St, Ed, INF);
for (int i = 1; i <= n; i++)
if (d[i] > 0)
inse(st, i, d[i]);
else
inse(i, ed, -d[i]);
while (bfs()) aug(st, INF);
for (int i = 1; i <= points; i++) {
for (int p = h[i]; p; p = e[p].nxt)
if (be[p]) {
ans[be[p]].f = e[p ^ 1].f + 1;
ans[be[p]].c = ans[be[p]].f + 1;
}
}
for (int i = 1; i <= m; i++)
if (!eg[i].g)
printf("0 1\n");
else
printf("%d %d\n", ans[i].f, ans[i].c);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string s;
int T[2345678], A[2345678], B[2345678], C[2345678];
void build(int v, int tl, int tr) {
if (tl == tr) {
if (s[tl] == '(') {
A[v] = 1;
} else {
B[v] = 1;
}
return;
}
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
int tmp = min(A[2 * v], B[2 * v + 1]);
T[v] = T[2 * v] + T[2 * v + 1] + 2 * tmp;
A[v] = A[2 * v] + A[2 * v + 1] - tmp;
B[v] = B[2 * v] + B[2 * v + 1] - tmp;
}
pair<int, pair<int, int> > query(int v, int tl, int tr, int l, int r) {
if (l > tr || r < tl) {
return pair<int, pair<int, int> >(0, pair<int, int>(0, 0));
}
if (tl >= l && tr <= r) {
return pair<int, pair<int, int> >(T[v], pair<int, int>(A[v], B[v]));
}
int tmt = (tl + tr) / 2;
pair<int, pair<int, int> > f = query(2 * v, tl, tmt, l, r);
pair<int, pair<int, int> > s = query(2 * v + 1, tmt + 1, tr, l, r);
int t = min(f.second.first, s.second.second);
int tree = f.first + s.first + 2 * t;
int a = f.second.first + s.second.first - t;
int b = f.second.second + s.second.second - t;
return pair<int, pair<int, int> >(tree, pair<int, int>(a, b));
}
int l, r, m;
int main() {
cin >> s;
build(1, 0, s.size() - 1);
cin >> m;
while (m--) {
scanf("%d %d", &l, &r);
l--;
r--;
printf("%d\n", query(1, 0, s.size() - 1, l, r).first);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long toint(string s) {
long long sum = 0;
for (int i = 0; i < s.size(); ++i) {
sum = sum * 10 + (s[i] - '0');
}
return sum;
}
int sumdigit(long long x) {
int tot = 0;
while (x) {
tot += x % 10;
x /= 10;
}
return tot;
}
int main() {
string s, t;
cin >> s;
int i = 1;
while (i < s.size()) {
i += 1;
t += '9';
}
t += (char((s[0] - '0') - 1) + '0');
reverse(t.begin(), t.end());
cout << sumdigit(toint(t)) + sumdigit(toint(s) - toint(t)) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<int, vector<int>, greater<int> > Q;
int num[200];
map<int, int> mark;
void solve() {
int n, tmp;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
}
int k = 1;
for (int i = 1; i <= n; i++) {
int mi = 0x3f3f3f3f, pos = 0;
for (int j = i; j <= n; j++) {
if (mi > num[j]) {
mi = num[j];
pos = j;
}
}
while (k != pos) {
if (pos > k) {
cout << pos - 1 << " " << pos << endl;
swap(num[pos - 1], num[pos]);
pos--;
} else {
cout << pos << " " << pos + 1 << endl;
swap(num[pos + 1], num[pos]);
pos++;
}
}
k++;
}
}
int main() { solve(); }
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << (n + 1) / 10 << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int a[101], d[3];
int main() {
int n, i, j, k = 0, l = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
int t;
scanf("%d", &a[i]);
k = 0, l = 0;
if (a[i] == 1 && i == 1) {
d[1] = 1;
d[2] = -1;
d[3] = 0;
} else if (a[i] == 2 && i == 1) {
d[1] = -1;
d[2] = 1;
d[3] = 0;
} else if (a[i] == 3 && i == 1) {
printf("NO\n");
return 0;
} else if (d[a[i]] == -1) {
printf("NO\n");
return 0;
} else if (d[a[i]] == 1) {
for (j = 1; j <= 3; j++) {
if (j != a[i]) {
if (!k) {
k = j;
} else {
l = j;
}
}
}
t = d[k];
d[k] = d[l];
d[l] = t;
} else if (d[a[i]] == 0) {
for (j = 1; j <= 3; j++) {
if (j != a[i]) {
if (!k) {
k = j;
} else {
l = j;
}
}
}
t = d[k];
d[k] = d[l];
d[l] = t;
}
}
printf("YES\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m, k, Ans, T;
int B[200010];
char A[200010];
inline int calc(int x, int y) {
int ret = 0;
if (x - 1 > 0 && y + 1 <= m && A[((x - 1 - 1) * m + y)] == '*' &&
A[((x - 1 - 1) * m + y + 1)] == '*')
ret++;
if (x - 1 > 0 && y - 1 > 0 && A[((x - 1 - 1) * m + y)] == '*' &&
A[((x - 1 - 1) * m + y - 1)] == '*')
ret++;
if (x - 1 > 0 && y - 1 > 0 && A[((x - 1) * m + y - 1)] == '*' &&
A[((x - 1 - 1) * m + y - 1)] == '*')
ret++;
if (x - 1 > 0 && y - 1 > 0 && A[((x - 1) * m + y - 1)] == '*' &&
A[((x - 1 - 1) * m + y)] == '*')
ret++;
return ret;
}
inline bool link(int x, int y) {
if (x - 1 > 0 && A[((x - 1 - 1) * m + y)] == '*') return true;
if (x + 1 <= n && A[((x + 1 - 1) * m + y)] == '*') return true;
if (y - 1 > 0 && A[((x - 1) * m + y - 1)] == '*') return true;
if (y + 1 <= m && A[((x - 1) * m + y + 1)] == '*') return true;
return false;
}
bool S(int x, int y, int s) {
if ((++T) > 10 * n * m) return 0;
if (s == k) return 1;
if (x > n) return 0;
if (y > m) return S(x + 1, 1, s);
int now = calc(x, y);
if ((x == 1 && y == 1) || link(x, y))
if (s + now <= k) {
A[((x - 1) * m + y)] = '*';
if (S(x, y + 1, s + now)) return 1;
}
A[((x - 1) * m + y)] = '.';
return S(x, y + 1, s);
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d%d", &n, &m, &k);
T = 0;
int c = 0;
if (n < m) {
c = 1;
swap(n, m);
}
for (int i = 1; i <= n * m; i++) A[i] = '.';
if (!S(1, 1, 0))
puts("-1\n");
else {
int E = 1;
for (int i = 1; i <= n * m; i++)
if (A[i] == '*') E = 0;
if (E) A[1] = '*';
if (!c)
for (int i = 1; i <= n; i++, putchar('\n'))
for (int j = 1; j <= m; j++) putchar(A[((i - 1) * m + j)]);
else
for (int i = 1; i <= m; i++, putchar('\n'))
for (int j = 1; j <= n; j++) putchar(A[((j - 1) * m + i)]);
putchar('\n');
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[100010];
long long int nCr[2010][2010];
long long int two_pow[2010];
long long int k_2_pow[2010];
long long int n, k;
void binomialCoeff() {
int i, j;
for (i = 0; i <= 2000; i++) {
for (j = 0; j <= min(i, 2000); j++) {
if (j == 0 || j == i)
nCr[i][j] = 1;
else
nCr[i][j] =
(nCr[i - 1][j - 1] % 998244353 + nCr[i - 1][j] % 998244353) %
998244353;
}
}
return;
}
void pow_two() {
two_pow[0] = 1;
for (int i = 1; i < 2010; ++i) {
two_pow[i] = (two_pow[i - 1] * 2) % 998244353;
}
}
void pow_k_2() {
k_2_pow[0] = 1;
for (int i = 1; i < 2010; ++i) {
k_2_pow[i] = (k_2_pow[i - 1] * (k - 2)) % 998244353;
}
}
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long int modinv(long long int a) {
return binpow(a, 998244353 - 2, 998244353);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
binomialCoeff();
pow_two();
pow_k_2();
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
if (k == 1) {
cout << 0 << endl;
return 0;
}
long long int x = 0;
for (int i = 0; i < n; ++i) {
if (arr[i] != arr[(i + 1) % n]) {
x++;
}
}
long long int ans = 0;
if (x) {
for (int i = 1; i <= x; ++i) {
if (i % 2) {
ans += (nCr[x][i] * (two_pow[i - 1]) % 998244353 * k_2_pow[x - i]) %
998244353;
ans %= 998244353;
} else {
ans += ((nCr[x][i] * (((two_pow[i] - nCr[i][i / 2] + 998244353) %
998244353 * modinv(2)) %
998244353)) %
998244353 * k_2_pow[x - i]) %
998244353;
ans %= 998244353;
}
}
}
long long int k_pow_n_x = binpow(k, n - x, 998244353);
ans = (ans * k_pow_n_x) % 998244353;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int t,n,x,a[200005];
map<int,int>m;
int main(void)
{
while(scanf("%d",&t)!=EOF)
{
while(t--)
{
scanf("%d %d %d",&a[1],&a[2],&a[3]);
sort(a+1,a+4);
int sum=a[3]+a[2]-a[1]*2;
if(a[1]+a[2]+a[3]<=6)
{
printf("NO\n");
continue;
}
if(sum%3)
{
printf("NO\n");
continue;
}
a[1]-=sum/6;
if(a[1]<0)
{
printf("NO\n");
continue;
}
if(a[1]%3==0 && sum%6==0 || sum%6==3 && a[1]%3==2)
{
printf("YES\n");
}
else
{
printf("NO\n");
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return b < a ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int oo = 0x3f3f3f3f;
const int maxn = 100100;
int n;
int a[maxn + 5];
int pos[maxn + 5];
int dp[maxn + 5];
int main() {
scanf("%d", &n);
for (int i = (0), i_end_ = (n); i < i_end_; ++i)
scanf("%d", a + i), pos[a[i]] = i;
memset(dp, -1, sizeof dp);
for (int i = n; i >= 1; --i) {
dp[pos[i]] = 0;
for (int j = i; j < n; j += i) {
for (int k = (0), k_end_ = (2); k < k_end_; ++k) {
int nxt = k ? pos[i] + j : pos[i] - j;
if (nxt >= 0 && nxt < n && a[nxt] > i) {
if (!dp[nxt]) {
dp[pos[i]] = 1;
}
}
}
}
}
for (int i = (0), i_end_ = (n); i < i_end_; ++i)
if (dp[i])
putchar('A');
else
putchar('B');
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[61], b[61];
for (int i = 0; i < n; ++i) {
cin >> a[i];
a[i] += 10000;
}
for (int i = 0; i < m; ++i) {
cin >> b[i];
b[i] += 10000;
}
bool chk[40005] = {};
bitset<120> cnt[40005];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int x = a[i] + b[j];
cnt[x].set(i + 60);
cnt[x].set(j);
}
int MAX = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int x = a[i] + b[j];
if (chk[x]) continue;
chk[x] = 1;
for (int k = 0; k < n; ++k)
for (int s = 0; s < m; ++s) {
int y = a[k] + b[s];
bitset<120> tmp = cnt[x] | cnt[y];
MAX = max(MAX, (int)tmp.count());
}
}
cout << MAX;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
long long ans = 0;
priority_queue<int> Q;
cin >> n >> a;
Q.push(a);
for (int i = 1; i < n; i++) {
cin >> a;
a -= i;
Q.push(a);
if (Q.top() > a) {
ans += Q.top() - a;
Q.pop();
Q.push(a);
}
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) { return (y ? gcd(y, x % y) : x); }
int main() {
int n, m;
map<int, int> a;
cin >> n;
m = n * n;
for (int i = 0; i < m; i++) {
int temp;
scanf("%d", &temp);
if (a.count(temp))
a[temp]++;
else
a[temp] = 1;
}
vector<pair<int, int> > ans;
while (m > 0) {
map<int, int>::reverse_iterator rhit = a.rbegin();
int cur = rhit->first;
int u = 0, v, k;
for (int i = 0; i < ans.size(); i++) {
if (ans[i].first % cur == 0) u += ans[i].second;
}
k = a[cur];
v = sqrt(0.0 + u * u + k) - u + 0.01;
for (int i = 0; i < ans.size(); i++) {
int g = gcd(ans[i].first, cur);
a[g] -= ans[i].second * v * 2;
m -= ans[i].second * v * 2;
if (a[g] == 0) a.erase(g);
}
a[cur] -= v * v;
m -= v * v;
if (a[cur] == 0) a.erase(cur);
ans.push_back(make_pair(cur, v));
}
for (int i = 0; i < ans.size(); i++)
for (int j = 0; j < ans[i].second; j++) cout << ans[i].first << ' ';
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
int N, M;
vector<pii> cur, nxt;
inline bool Ok(int ni, int nj) {
return ni >= 0 and ni < N and nj >= 0 and nj < M;
}
inline vector<vector<char>> Forward(vector<vector<char>> f, int t) {
cur.clear();
for (int i(0); i < N; ++i) {
for (int j(0); j < M; ++j) {
if (f[i][j]) {
cur.emplace_back(i, j);
}
}
}
while (t--) {
nxt.clear();
for (auto [i, j] : cur) {
for (int di(-1); di <= 1; ++di) {
for (int dj(-1); dj <= 1; ++dj) {
int ni(i + di), nj(j + dj);
if (!Ok(ni, nj) or f[ni][nj]) continue;
f[ni][nj] = true;
nxt.emplace_back(ni, nj);
}
}
}
cur.swap(nxt);
}
return f;
}
inline vector<vector<char>> Backward(vector<vector<char>> f, int t) {
cur.clear();
for (int i(-1); i <= N; ++i) {
cur.emplace_back(i, -1);
cur.emplace_back(i, M);
}
for (int j(-1); j <= M; ++j) {
cur.emplace_back(-1, j);
cur.emplace_back(N, j);
}
for (int i(0); i < N; ++i) {
for (int j(0); j < M; ++j) {
if (f[i][j]) continue;
cur.emplace_back(i, j);
}
}
while (t--) {
nxt.clear();
for (auto [i, j] : cur) {
for (int di(-1); di <= 1; ++di) {
for (int dj(-1); dj <= 1; ++dj) {
int ni(i + di), nj(j + dj);
if (Ok(ni, nj) and f[ni][nj]) {
f[ni][nj] = false;
nxt.emplace_back(ni, nj);
}
}
}
}
cur.swap(nxt);
}
return f;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> N >> M;
vector<vector<char>> f(N, vector<char>(M));
for (int i(0); i < N; ++i) {
for (int j(0); j < M; ++j) {
char c;
cin >> c;
f[i][j] = c == 'X';
}
}
int l(0), r(min(N, M));
while (l + 1 < r) {
int m((l + r) / 2);
if (Forward(Backward(f, m), m) == f)
l = m;
else
r = m;
}
cout << l << '\n';
for (auto& line : Backward(f, l)) {
for (auto x : line) cout << (x ? 'X' : '.');
cout << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios_base::sync_with_stdio(false);
cout << fixed;
cout.precision(10);
int t = 1;
for (int i = 1; i <= t; ++i) {
solve();
}
return 0;
}
int n, m, k, w;
char c[1100][11][11];
vector<pair<int, pair<int, int> > > g;
int par[1100];
int getanc(int x) {
if (par[x] != x) return par[x] = getanc(par[x]);
return x;
}
void uni(int x, int y) {
int a = getanc(x);
int b = getanc(y);
if (rand() & 1) swap(a, b);
par[a] = b;
}
vector<vector<int> > gg;
void dfs(int v, int p) {
if (p != -1) cout << v << " " << p << "\n";
for (int i = 0; i < gg[v].size(); ++i) {
int to = gg[v][i];
if (to != p) {
dfs(to, v);
}
}
}
void solve() {
cin >> n >> m >> k >> w;
for (int i = 1; i <= k; ++i) {
for (int x = 0; x < n; ++x) {
for (int y = 0; y < m; ++y) {
cin >> c[i][x][y];
}
}
}
for (int i = 0; i <= k; ++i) par[i] = i;
gg.resize(k + 1);
for (int i = 1; i <= k; ++i) g.push_back(make_pair(n * m, make_pair(0, i)));
for (int i = 1; i <= k; ++i)
for (int j = i + 1; j <= k; ++j) {
int sum = 0;
for (int x = 0; x < n; ++x)
for (int y = 0; y < m; ++y) {
if (c[i][x][y] != c[j][x][y]) ++sum;
}
g.push_back(make_pair(sum * w, make_pair(i, j)));
}
sort(g.begin(), g.end());
int sum = 0;
for (int i = 0; i < g.size(); ++i) {
if (getanc(g[i].second.first) != getanc(g[i].second.second)) {
sum += g[i].first;
uni(g[i].second.first, g[i].second.second);
gg[g[i].second.first].push_back(g[i].second.second);
gg[g[i].second.second].push_back(g[i].second.first);
}
}
cout << sum << endl;
dfs(0, -1);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < (n); i++) cin >> A[i];
int mini = 1000000005;
int miniT = -1;
for (int t = 1; t <= 100; t++) {
int total = 0;
for (int i = 0; i < (n); i++) {
if (A[i] > t + 1) {
total += A[i] - t - 1;
} else if (A[i] < t - 1) {
total += t - 1 - A[i];
} else {
total += 0;
}
}
if (total < mini) {
mini = total;
miniT = t;
}
}
cout << miniT << " " << mini;
}
| 1 |
#include <bits/stdc++.h>
const long long max9 = 10 + 1e9, max6 = 10 + 1e6, max12 = 10 + 1e12,
max15 = 10 + 1e15;
const long long min6 = -1 * max6, min9 = -1 * max9, min12 = -1 * max12,
min15 = -1 * max15;
const long long R = 7 + 1e9, NN = 10 + 1e5;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, a, b;
cin >> n >> m >> a >> b;
long long ans1 = n / m + (bool)(n % m);
ans1 *= m;
ans1 -= n;
ans1 *= a;
long long ans2 = n / m;
ans2 *= m;
ans2 -= n;
ans2 = abs(ans2);
ans2 *= b;
cout << min(ans1, ans2);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1;
string s2;
string temp;
cin >> s1 >> s2;
for (int i = s2.length() - 1; i >= 0; i--) {
temp = temp + s2[i];
}
if (s1 == temp) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 1e6 + 1;
const long long INF = 1e9 + 7;
const long long MOD = 1e2;
const double EPS = 1e-9;
long double n, m;
int main() {
cin >> n >> m;
long double x = 1.000000011;
x = pow(x, m);
cout << fixed << setprecision(6) << x * n;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l[100000];
int r[100000];
long n;
cin >> n;
int SL = 0, SR = 0;
for (int i = 0; i < n; ++i) {
cin >> l[i] >> r[i];
SL += l[i];
SR += r[i];
}
int p = -1;
int max = abs(SL - SR);
for (int i = 0; i < n; ++i) {
if (abs((SL - l[i] + r[i]) - (SR - r[i] + l[i])) > max) {
max = abs((SL - l[i] + r[i]) - (SR - r[i] + l[i]));
p = i;
}
}
cout << p + 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, sum = 0;
cin >> n;
long long fact = 1;
while (n != (long long)1) {
if (n % (long long)2 == (long long)0) {
n = n / (long long)2;
sum += fact * n;
} else {
n = n / (long long)2 + (long long)1;
sum += fact * (n - 1);
}
fact *= (long long)2;
}
cout << sum;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 100 * 1000 + 10;
const long long MIN = 1000ll * 1000 * 1000 * 1000 + 100;
struct arc {
long long fin, poids;
};
vector<arc> adj[MAXN];
long long val[MAXN];
bool vu[MAXN];
void faire(long long noeud) {
vu[noeud] = true;
for (auto arrete : adj[noeud]) {
faire(arrete.fin);
if (val[arrete.fin] > 0) {
val[noeud] += val[arrete.fin];
} else {
val[noeud] += val[arrete.fin] * arrete.poids;
if (val[noeud] <= -MIN) {
cout << "NO" << endl;
exit(0);
}
}
}
}
int32_t main() {
long long N;
cin >> N;
long long debut[N];
long long fin[N];
for (long long i = 0; i < N; i++) {
cin >> debut[i];
}
for (long long i = 0; i < N; i++) {
cin >> fin[i];
val[i] = debut[i] - fin[i];
}
for (long long i = 1; i < N; i++) {
long long a, b;
cin >> a >> b;
a--;
adj[a].push_back({i, b});
}
for (long long i = 0; i < N; i++) {
if (!vu[i]) {
faire(i);
if (val[i] < 0) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s, t;
cin >> s >> t;
for (int i = 0; i <= s.size() - 1; i++) {
int c = i;
for (int j = s.size() - 1; j > i; j--) {
if (s[j] < s[c]) {
c = j;
}
}
if (c != i) {
swap(s[i], s[c]);
break;
}
}
if (s >= t)
cout << "---\n";
else
cout << s << endl;
}
}
| 4 |
#include <bits/stdc++.h>
const int N = 200000 + 7;
int Cases;
int n;
char s[N];
void step1();
void step2();
void step3();
void erase(int x, int y);
int main() {
scanf("%d", &Cases);
while (Cases--)
scanf("%s", s + 1), n = strlen(s + 1), erase(-1, 0), step1(), step2(),
step3();
return 0;
}
void step1() {
static int cnt[31], sm, mx;
static int pos[N], pt;
static int sta[N], top;
std::fill(cnt, cnt + 26, 0), sm = mx = pt = top = 0;
for (int i = 1; i < n; ++i)
if (s[i] == s[i + 1]) ++cnt[s[i] - 'a'], ++sm;
mx = *std::max_element(cnt, cnt + 26);
printf("%d\n", std::max(sm + 1 >> 1, mx) + 1);
if (mx >= sm + 1 >> 1) return;
for (int i = 1; i < n; ++i)
if (s[i] == s[i + 1]) pos[++pt] = i;
for (int i = 1; i <= pt; ++i)
if (!top || s[sta[top]] == s[pos[i]])
sta[++top] = pos[i];
else {
--cnt[s[pos[i]] - 'a'], --cnt[s[sta[top]] - 'a'];
erase(sta[top] + 1, pos[i]), --top;
sm -= 2, mx = *std::max_element(cnt, cnt + 26);
if (mx >= sm + 1 >> 1) return;
}
}
void step2() {
static int cnt[31], sm, mx;
static int pos[N], pt;
static int sta[N], top;
std::fill(cnt, cnt + 26, 0), sm = mx = pt = top = 0;
for (int i = 1; i < n; ++i)
if (s[i] && s[i] == s[i + 1]) ++cnt[s[i] - 'a'], ++sm;
int x = std::max_element(cnt, cnt + 26) - cnt;
mx = cnt[x];
if (mx == sm) return;
for (int i = 1; i < n; ++i)
if (s[i] && s[i] == s[i + 1]) pos[++pt] = i;
for (int i = 1; i <= pt; ++i) {
if (!top || (s[sta[top]] == 'a' + x) + (s[pos[i]] == 'a' + x) != 1)
sta[++top] = pos[i];
else {
--cnt[s[pos[i]] - 'a'], --cnt[s[sta[top]] - 'a'];
erase(sta[top] + 1, pos[i]), --top;
sm -= 2, mx = *std::max_element(cnt, cnt + 26);
if (mx == sm) return;
}
}
}
void step3() {
for (int i = 1, j = 1; i < n; ++i)
if (s[i] && s[i] == s[i + 1]) erase(j, i), j = i + 1;
erase(1, n);
}
void erase(int x, int y) {
static int fa[N], bit[N];
std::function<int(int)> getfa = [&](int x) {
return fa[x] == x ? x : fa[x] = getfa(fa[x]);
};
auto add = [&](int i) {
for (; i <= n; i += i & -i) ++bit[i];
};
auto sum = [&](int i) {
int t = 0;
for (; i; i -= i & -i) t += bit[i];
return t;
};
if (x == -1) {
for (int i = 1; i <= n + 1; ++i) fa[i] = i, bit[i] = 0;
return;
}
if (getfa(x) > y) return;
printf("%d %d\n", x - sum(x - 1), y - sum(y - 1));
for (int i = getfa(x); i <= y; i = fa[i] = getfa(i + 1)) s[i] = 0, add(i);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, bool> vis;
vector<vector<int> > row(1001), col(1001);
void dfs(int x, int y) {
vis[make_pair(x, y)] = true;
for (int i = 0; i < int(row[x].size()); i++)
if (!vis[make_pair(x, row[x][i])]) dfs(x, row[x][i]);
for (int i = 0; i < int(col[y].size()); i++)
if (!vis[make_pair(col[y][i], y)]) dfs(col[y][i], y);
}
void solution() {
int n, x, y, res = 0;
cin >> n;
for (int i = 0; i < int(n); i++) {
cin >> x >> y;
row[x].push_back(y);
col[y].push_back(x);
}
for (int i = 0; i < int(1001); i++) {
for (int j = 0; j < int(row[i].size()); j++)
if (!vis[make_pair(i, row[i][j])]) dfs(i, row[i][j]), res++;
for (int j = 0; j < int(col[i].size()); j++)
if (!vis[make_pair(col[i][j], i)]) dfs(col[i][j], i), res++;
}
cout << res - 1 << endl;
}
int main() {
double beg = clock();
ios::sync_with_stdio(false);
solution();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double inf = 1e20;
const double pi = acos(-1.0);
int sgn(double x) {
if (fabs(x) < eps) return 0;
if (x < 0)
return -1;
else
return 1;
}
double mysqrt(double x) { return sqrt(max(x, 0.0)); }
struct point {
double x, y;
point(double x = 0, double y = 0) : x(x), y(y) {}
bool operator==(const point &b) const {
return sgn(x - b.x) == 0 && sgn(y - b.x) == 0;
}
bool operator<(const point &b) const {
return sgn(x - b.x) == 0 ? sgn(y - b.y) < 0 : sgn(x - b.x) < 0;
}
point operator+(const point &b) const { return point(x + b.x, y + b.y); }
point operator-(const point &b) const { return point(x - b.x, y - b.y); }
point operator*(const double &k) const { return point(x * k, y * k); }
point operator/(const double &k) const { return point(x / k, y / k); }
double operator^(const point &b) const { return x * b.y - y * b.x; }
double operator*(const point &b) const { return x * b.x + y * b.y; }
double dist(point b) { return hypot(x - b.x, y - b.y); }
double rad(point a, point b) {
point p = *this;
return fabs(atan2(fabs((a - p) ^ (b - p)), (a - p) * (b - p)));
}
point trunc(double r) {
double l = hypot(x, y);
if (!sgn(l)) return *this;
r /= l;
return point(x * r, y * r);
}
point rotleft() { return point(-y, x); }
point rotright() { return point(y, -x); }
point rotate(point p, double angle) {
point v = (*this) - p;
double c = cos(angle), s = sin(angle);
return point(p.x + v.x * c - v.y * s, p.y + v.x * s + v.y * c);
}
void input() { scanf("%lf%lf", &x, &y); }
};
struct line {
point s, e;
line() {}
line(point s, point e) : s(s), e(e) {}
bool operator==(const line &v) { return (s == v.s) && (e == v.e); }
line(point p, double angle) {
s = p;
if (sgn(angle - pi / 2) == 0) {
e = (s + point(0, 1));
} else {
e = (s + point(1, tan(angle)));
}
}
line(double a, double b, double c) {
if (sgn(a) == 0) {
s = point(0, -c / b);
e = point(1, -c / b);
} else if (sgn(b) == 0) {
s = point(-c / a, 0);
e = point(-c / a, 1);
} else {
s = point(0, -c / b);
e = point(1, (-c - a) / b);
}
}
void adjust() {
if (e < s) swap(s, e);
}
double length() { return s.dist(e); }
double dispointtoline(point p) { return fabs((p - s) ^ (e - s)) / length(); }
double dispointtoseg(point p) {
if (sgn((p - s) * (e - s)) < 0 || sgn((p - e) * (s - e) < 0))
return min(p.dist(s), p.dist(e));
return dispointtoline(p);
}
};
const int N = 1e5 + 10;
point pp[N];
int main() {
int n;
point p;
scanf("%d", &n);
p.input();
double minn = inf, maxx = 0;
for (int i = 1; i <= n; i++) {
pp[i].input();
}
for (int i = 1; i <= n; i++) {
maxx = max(p.dist(pp[i]), maxx);
int j = i == n ? 1 : i + 1;
line line1 = line(pp[i], pp[j]);
minn = min(minn, line1.dispointtoseg(p));
}
printf("%lf\n", pi * (maxx * maxx - minn * minn));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long N, K;
int A[1010101];
long long cnt[10101010];
long long cnt2[10101010];
int solve() {
for (int i = 0; i < N; i++) cnt[A[i]]++;
long long sm = 0;
for (int i = 10101010; i >= 1; i--) {
sm += cnt[i];
if (K <= sm) return i;
cnt[i] += cnt2[i];
cnt2[(i + 1) / 2] += cnt[i];
cnt[i / 2] += cnt[i];
}
return -1;
}
int main() {
cin >> N >> K;
for (int i = 0; i < N; i++) scanf("%d", &A[i]);
sort(A, A + N, greater<int>());
cout << solve() << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int solve(long long int max, long long int min) {
long long int val = floor((sqrt(1 + 8 * (max - min)) - 1) / 2);
min += ((val * (val + 1)) / 2);
if (min == max) return (val);
if (((val + 1) - (max - min)) % 2 == 0) return (val + 1);
min += (val + 1);
if (((val + 2) - (max - min)) % 2 == 0) return (val + 2);
return (val + 3);
}
int main() {
int tests;
long long int a, b;
cin >> tests;
while (tests--) {
cin >> a >> b;
if (a == b)
cout << 0 << endl;
else
cout << solve((a > b) ? a : b, (a < b) ? a : b) << endl;
}
return (0);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool f = false;
string s;
cin >> s;
int n;
cin >> n;
vector<string> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
for (int i = 0; i < n; i++)
if (v[i].substr(0, s.size()) == s) {
cout << v[i] << endl;
f = true;
break;
}
if (f == false) cout << s << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 9223372036854775807;
const long long int mod = (long long int)1e9 + 7;
#pragma GCC target("avx2")
#pragma GCC optimization("unroll-loops")
int MOD(int a, int b) {
if (a > b)
return a - b;
else
return b - a;
}
long long int max3(long long int a, long long int b, long long int c) {
return max(c, max(a, b));
}
long long int min3(long long int a, long long int b, long long int c) {
return min(a, min(b, c));
}
long long int power(long long int x, long long int y, long long int mod1) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % mod1;
y = y >> 1;
x = (x * x) % mod1;
}
return res;
}
long long int logg(long long int a) {
long long int x = 0;
while (a > 1) {
x++;
a /= 2;
}
return x;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int abso(long long int x) {
if (x < 0) {
return -x;
}
return x;
}
long long int ceiling(long long int a, long long int b) {
if (a % b == 0) {
return a / b;
} else {
return a / b + 1;
}
}
long long int modinv(long long int x, long long int p) {
return power(x, p - 2, p);
}
struct point {
long long int x;
long long int y;
};
long long int cross(point a, point b) { return a.x * b.y - b.x * a.y; }
bool ccw(point p1, point p2) {
if (cross(p1, p2) > 0) {
return true;
} else {
return false;
}
}
void ccw_sort(vector<point> &v) {
vector<point> v1, v2;
for (int i = 0; i < v.size(); i++) {
if (v[i].y > 0) {
v1.push_back(v[i]);
} else {
v2.push_back(v[i]);
}
}
sort(v1.begin(), v1.end(), ccw);
sort(v2.begin(), v2.end(), ccw);
for (int i = 0; i < v2.size(); i++) {
v1.push_back(v2[i]);
}
v = v1;
}
int rt(int i, vector<int> &par) {
if (par[i] == i) {
return i;
} else {
par[i] = rt(par[i], par);
return par[i];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum == 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
sort(a.begin(), a.end());
if (sum > 0) {
reverse(a.begin(), a.end());
}
for (int i = 0; i < n; i++) {
cout << a[i] << ' ';
}
cout << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int k = (n / 2) + 1;
int t = 1;
char a[105][105];
int x = 0, y = 0;
for (int i = 1; i <= n / 2; i++) {
int c = 0;
for (int j = 1; j <= n; j++) {
if (c == n) break;
if (k == j)
for (int l = 0; l < t; l++) {
c++;
cout << "D";
}
else {
c++;
cout << "*";
}
}
cout << endl;
t += 2;
k--;
}
for (int i = 1; i <= n; i++) cout << "D";
cout << endl;
k = 2;
t = n - 2;
for (int i = 1; i <= n / 2; i++) {
int c = 0;
for (int j = 1; j <= n; j++) {
if (c == n) break;
if (k == j)
for (int l = 0; l < t; l++) {
c++;
cout << "D";
}
else {
c++;
cout << "*";
}
}
cout << endl;
t -= 2;
k++;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const double eps = 1e-9;
const int int_inf = 1 << 31 - 1;
const long long i64_inf = 1ll << 63 - 1;
const double pi = acos(-1.0);
using namespace std;
int n;
long long k;
int res = 0;
int a[20];
int b[20];
long long fac[20];
vector<int> L;
void gen(int a = 0, int len = 0) {
L.push_back(a);
if (len == 9) return;
gen(a * 10 + 4, len + 1);
gen(a * 10 + 7, len + 1);
}
int lucky(int a) {
if (a < 4) return 0;
int l = 0;
int r = L.size();
while (l != r - 1) {
int m = (l + r) >> 1;
if (L[m] <= a)
l = m;
else
r = m;
}
return l;
}
bool isluck(int a) { return *lower_bound(L.begin(), L.end(), a) == a; }
int main() {
fac[1] = 1ll;
for (int i = 2; i < 15; i++) fac[i] = fac[i - 1] * 1ll * (long long)i;
gen();
sort(L.begin(), L.end());
cin >> n >> k;
if (n <= 13 && fac[n] < k) {
puts("-1");
return 0;
}
int sz = min(n, 13);
for (int i = sz - 1; i >= 0; i--) a[i] = n - (sz - i - 1);
for (int i = 0; i < sz; i++) {
sort(a + i, a + sz);
for (int j = i; j < sz; j++) {
long long m = j - i;
if (k <= fac[sz - i - 1] * (m + 1)) {
swap(a[i], a[j]);
k -= fac[sz - i - 1] * m;
break;
}
}
}
for (int i = sz - 1; i >= 0; i--) b[i] = n - (sz - i - 1);
res = lucky(n - 13);
for (int i = 0; i < sz; i++) res += isluck(a[i]) && isluck(b[i]);
cout << res << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int rev(int n) {
int res = 0;
while (n) {
res = res * 10 + n % 10;
n /= 10;
}
return res;
}
int main() {
int a1, a2;
cin >> a1 >> a2;
cout << a1 + rev(a2) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, last = 'A';
char c[9][9], s[9][9];
void calc(int u, int i, int j) {
if (i == n) return;
if (j == m) {
calc(u, i + 1, 0);
return;
}
if (u + ((n - i) * (m - j) + (n - i) * j) / 5 - 1 < ans) return;
if (j + 2 < m && c[i][j] == '.' && c[i][j + 1] == '.' && c[i][j + 2] == '.')
if (i + 1 < n && i - 1 > -1) {
if (c[i + 1][j] == '.' && c[i - 1][j] == '.') {
c[i][j] = c[i][j + 1] = c[i][j + 2] = c[i - 1][j] = c[i + 1][j] =
last++;
if (u + 1 > ans) {
ans = u + 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) s[i][j] = c[i][j];
}
calc(u + 1, i, j + 1);
c[i][j] = c[i][j + 1] = c[i][j + 2] = c[i - 1][j] = c[i + 1][j] = '.';
last--;
}
if (c[i + 1][j + 2] == '.' && c[i - 1][j + 2] == '.') {
c[i][j] = c[i][j + 1] = c[i][j + 2] = c[i - 1][j + 2] =
c[i + 1][j + 2] = last++;
if (u + 1 > ans) {
ans = u + 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) s[i][j] = c[i][j];
}
calc(u + 1, i, j + 1);
c[i][j] = c[i][j + 1] = c[i][j + 2] = c[i - 1][j + 2] =
c[i + 1][j + 2] = '.';
last--;
}
}
if (i - 1 > -1 && i + 1 < n && c[i - 1][j] == '.' && c[i][j] == '.' &&
c[i + 1][j] == '.')
if (j + 1 < m && j - 1 > -1) {
if (c[i - 1][j - 1] == '.' && c[i - 1][j + 1] == '.') {
c[i][j] = c[i - 1][j + 1] = c[i - 1][j - 1] = c[i - 1][j] =
c[i + 1][j] = last++;
if (u + 1 > ans) {
ans = u + 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) s[i][j] = c[i][j];
}
calc(u + 1, i, j + 1);
c[i][j] = c[i - 1][j + 1] = c[i - 1][j - 1] = c[i - 1][j] =
c[i + 1][j] = '.';
last--;
}
if (c[i + 1][j - 1] == '.' && c[i + 1][j + 1] == '.') {
c[i][j] = c[i + 1][j + 1] = c[i + 1][j - 1] = c[i - 1][j] =
c[i + 1][j] = last++;
if (u + 1 > ans) {
ans = u + 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) s[i][j] = c[i][j];
}
calc(u + 1, i, j + 1);
c[i][j] = c[i + 1][j + 1] = c[i + 1][j - 1] = c[i - 1][j] =
c[i + 1][j] = '.';
last--;
}
}
calc(u, i, j + 1);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) c[i][j] = s[i][j] = '.';
calc(0, 0, 0);
printf("%d\n", ans);
for (int i = 0; i < n; i++, puts(""))
for (int j = 0; j < m; j++) cout << s[i][j];
}
| 7 |
#include <bits/stdc++.h>
using LL = long long;
using namespace std;
LL p;
int k;
vector<int> solve(LL p, int k) {
vector<int> vec;
if (0 <= p && p < k) {
vec.push_back(p);
return vec;
}
if (-k < p && p < 0) {
vec.push_back(1);
vec.push_back(p + k);
return vec;
}
LL cos = -1;
if (p >= 0)
cos = p % k;
else
cos = k - (-p) % k;
if (cos == k) cos = 0;
LL v1 = (p - cos) / (-k);
auto vecs = solve(v1, k);
vecs.push_back(cos);
return vecs;
}
int main() {
scanf("%lld%d", &p, &k);
auto vec = solve(p, k);
int d = vec.size();
printf("%d\n", d);
reverse(vec.begin(), vec.end());
while (!vec.empty() && vec.back() == 0) vec.pop_back();
for (int c : vec) printf("%d ", c);
puts("");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 1000 * 1000;
int n;
long long int a, b;
long long int v[maxn];
struct ghost {
long long int x;
long long int vx;
long long int vy;
long long int number;
void set() { number = vx * a * (-1) + vy; }
bool operator<(const ghost& g) const { return number < g.number; }
bool operator==(const ghost& g) const { return number == g.number; }
};
ghost g[maxn];
void read();
void initialize();
long long int ans();
long long int f(int, int);
int main() {
read();
initialize();
sort(g, g + n);
cout << ans() << endl;
return 0;
}
void read() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> a >> b;
for (int i = 0; i < n; i++) cin >> g[i].x >> g[i].vx >> g[i].vy;
}
void initialize() {
for (int i = 0; i < n; i++) g[i].set();
}
long long int ans() {
long long int res = 0;
long long int c = 1;
for (int i = 1; i < n; i++) {
if (g[i] == g[i - 1])
c++;
else {
res += f(i - c, i - 1);
c = 1;
}
}
res += f(n - c, n - 1);
return res * 2;
}
long long int f(int l, int r) {
long long int size = r - l + 1;
for (int i = 0; i < size; i++) v[i] = g[i + l].vx;
sort(v, v + size);
long long int all = size * (size - 1) / 2;
long long int c = 1;
long long int bad = 0;
for (int i = 1; i < size; i++) {
if (v[i] == v[i - 1])
c++;
else {
bad += c * (c - 1) / 2;
c = 1;
}
}
bad += c * (c - 1) / 2;
return all - bad;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
const int inf = INT_MAX;
const long long inff = 1e18;
const long long mod = 1e9 + 7;
int n, q;
int a[maxn], l[maxn], r[maxn], cnt[maxn];
vector<pair<int, int> > v;
set<int> s;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
for (int i = 1; i <= 200000; i++) l[i] = inf, r[i] = -inf;
for (int i = 1; i <= n; i++) {
cin >> a[i];
cnt[a[i]]++;
l[a[i]] = min(l[a[i]], i);
r[a[i]] = max(r[a[i]], i);
}
for (int i = 1; i <= 200000; i++) {
if (l[i] == inf) continue;
v.push_back(make_pair(l[i], -i));
v.push_back(make_pair(r[i], i));
}
sort((v).begin(), (v).end());
int now = 0, ans = 0, minn = inf, maxx = -inf;
for (pair<int, int> i : v) {
s.insert(cnt[abs(i.second)]);
minn = min(minn, i.first);
maxx = max(maxx, i.first);
if (i.second > 0)
now--;
else
now++;
if (now == 0) {
ans += (maxx - minn + 1 - (*(--s.end())));
minn = inf, maxx = -inf;
s.clear();
}
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
const int b = 130000;
int f[2*b+5], s[2*b+5], g[2*b+5], ans[N];
int n, mod;
void solve(){
for (int i = b; i <= 2 * b + 4; ++i) s[i]=1;
for (int i = 1; i <= n; ++i) {
//cout<<"i="<< i<<'\n';
int tmp = i * (i - 1) / 2;
//for(int i=-3; i<=3; ++i) cout<<"i,s="<<i<<' '<<s[i+b]<<'\n';
for (int k = - tmp + b; k <= tmp + b; ++k) {
f[k] = (0ll + f[k - 1] - (s[k - 1] - s[k - i - 1]) + s[k + i - 1] - s[k - 1] + 3ll * mod) % mod;
//cout<<"k,f="<<k-b<<' '<<f[k]<<'\n';
}
for (int k = tmp + b; k >= - tmp + b; --k) {
g[k] = (g[k + 1] + f[k]) % mod;
//cout<<"k,g[k]="<<k-b<<' '<<g[k]<<'\n';
}
for(int j = 1; j <= i; ++j) {
ans[i + 1] = (ans[i + 1] + (1ll * (i + 1 - j) * g[j + 1 + b]) % mod) % mod;
}
memset(s, 0, sizeof(s));
tmp = (i + 1) * i / 2;
for (int k = - tmp - i - 1 + b; k <= tmp + b+ i + 1; ++k) {
//cout<<"ki, f="<<k<<' '<<f[k]<<'\n';
s[k] = (s[k - 1] + f[k]) % mod;
}
}
for (int i = 1; i <= n; ++i) ans[i] = (ans[i] + (1ll * i * ans[i-1]) % mod) % mod;
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
cin >> n >> mod;
solve();
cout << ans[n];
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int H[30][100003];
int pos[30];
int main() {
int i, j;
char str[1000000];
cin >> str;
for (i = 0; i < 30; i++) pos[i] = 0;
for (i = 0; str[i] != 0; i++) {
H[str[i] - 'a'][pos[str[i] - 'a']++] = i;
}
int ap = -1;
for (char ch = 'z'; ch >= 'a'; ch--) {
for (i = 0; i < pos[ch - 'a']; i++) {
if (H[ch - 'a'][i] > ap) {
ap = H[ch - 'a'][i];
printf("%c", ch);
}
}
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << "25";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const double EPS = 1e-8;
const double PI = acos(-1.0);
const int MOD = 1e9 + 7;
const long long LINF = 3e18;
int n, m, s, d;
vector<int> a;
vector<pair<int, int> > sections;
int dst(int x, int y) { return y - x; }
void add_section(int x, int y) {
if (dst(x + 1, y - 1) >= s) {
sections.push_back(make_pair(x + 1, y - 1));
}
}
int main() {
cin >> n >> m >> s >> d;
a.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
a.push_back(m + 1);
sort((a).begin(), (a).end());
for (int i = 0; i < n + 1; i++) {
if (i == 0) {
add_section(-1, a[i]);
} else {
add_section(a[i - 1], a[i]);
}
}
if (sections.empty() || sections[0].first != 0) {
cout << "IMPOSSIBLE";
return 0;
}
vector<pair<int, int> > actions;
for (int i = 0; i < sections.size(); i++) {
actions.push_back(make_pair(1, dst(sections[i].first, sections[i].second)));
if (i == sections.size() - 1) {
if (sections[i].second == m) {
continue;
}
if (dst(sections[i].second, m) > d) {
cout << "IMPOSSIBLE";
return 0;
}
actions.push_back(make_pair(2, dst(sections[i].second, m)));
continue;
}
if (dst(sections[i].second, sections[i + 1].first) > d) {
cout << "IMPOSSIBLE";
return 0;
}
actions.push_back(
make_pair(2, dst(sections[i].second, sections[i + 1].first)));
}
for (int i = 0; i < actions.size(); i++) {
if (actions[i].first == 1) {
cout << "RUN " << actions[i].second << '\n';
} else {
cout << "JUMP " << actions[i].second << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long i, j, k, l, m, n, a = INT_MIN, b = 0;
string s = "";
cin >> s;
n = (long long int)s.size();
long long prea[n + 1], preb[n + 1], suff[n + 1];
memset(prea, 0, sizeof(prea));
memset(preb, 0, sizeof(preb));
memset(suff, 0, sizeof(suff));
prea[0] = (s[0] == 'a'), preb[0] = (s[0] == 'b');
for (i = 1; i < n; i++) {
prea[i] = prea[i - 1] + (s[i] == 'a');
preb[i] = preb[i - 1] + (s[i] == 'b');
}
if (s[n - 1] == 'a') suff[n - 1] = 1;
for (i = n - 2; i >= 0; i--) suff[i] = suff[i + 1] + (s[i] == 'a');
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
if ((i - 1) >= 0)
a = max(a, prea[i] + preb[j] - preb[i - 1] + suff[j]);
else
a = max(a, prea[i] + preb[j] + suff[j]);
}
}
a = max({a, preb[n - 1], prea[n - 1]});
cout << a;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cin.sync_with_stdio(0), cout.tie(0),
cout.sync_with_stdio(0);
long long t = 1;
while (t--) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int MAX = 5e5 + 5;
const long long MAX2 = 11;
const long long MOD = 1000000007;
const long long MOD2 = 1000005329;
const long long INF = 2e18;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1, 0};
const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1, 0};
const double pi = acos(-1);
const double EPS = 1e-9;
const int block = 2000;
int q, n, k, cnt[MAX], a, b, c;
long long dp[MAX][2];
vector<pair<int, int> > v[MAX];
inline bool cmp(int aa, int bb) { return aa > bb; }
long long f(int nw, bool st, int par) {
if (dp[nw][st] != -1) return dp[nw][st];
long long ret = 0;
vector<long long> z;
for (auto i : v[nw]) {
if (i.first == par) continue;
ret += f(i.first, 0, nw);
z.push_back(f(i.first, 1, nw) + i.second - dp[i.first][0]);
}
sort(z.begin(), z.end(), cmp);
int tmp = k - st;
if (z.size() < tmp) {
for (auto i : z) {
if (i < 0) break;
ret += i;
}
} else {
for (int i = 0; i < tmp; ++i) {
if (z[i] < 0) break;
ret += z[i];
}
}
return dp[nw][st] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> q;
while (q--) {
cin >> n >> k;
for (long long i = 1; i <= n; ++i) {
v[i].clear();
for (long long j = 0; j <= 1; ++j) dp[i][j] = -1;
}
for (long long i = 2; i <= n; ++i) {
cin >> a >> b >> c;
v[a].push_back({b, c});
v[b].push_back({a, c});
}
cout << f(1, 0, 0) << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int c = 0;
int m = 0;
int a1, a2, a3, b1, b2, b3;
int sumall = 0;
;
cin >> a1 >> a2 >> a3 >> b1 >> b2 >> b3 >> n;
c = a1 + a2 + a3;
m = b1 + b2 + b3;
if (c % 5 == 0)
sumall += c / 5;
else
sumall += c / 5 + 1;
if (m % 10 == 0)
sumall += m / 10;
else
sumall += m / 10 + 1;
if (sumall > n)
cout << "NO";
else
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using pii = pair<int, int>;
using pi3 = pair<pii, int>;
const int N = 1e6 + 10;
int n;
int root[N];
int find_root(int u) { return u == root[u] ? u : root[u] = find_root(root[u]); }
int xn;
int first[N];
int a[N >> 1], b[N >> 1];
int ans[N], deg[N];
int U[N], V[N];
vector<int> path;
set<pii> adj[N];
set<pii>::iterator it;
void find_path(int u) {
stack<int> s, e;
path.clear();
while (1) {
if (adj[u].empty()) {
if (!e.empty()) path.push_back(e.top()), e.pop();
if (s.empty()) break;
u = s.top();
s.pop();
} else {
it = adj[u].begin();
int v = it->first, id = it->second;
s.push(u);
e.push(id);
adj[u].erase(it);
adj[v].erase(pii(u, -id));
u = v;
}
}
}
bool can(int k) {
int mask = (1 << k) - 1;
xn = 0;
for (int i = 0; i < n; i++) {
first[xn++] = a[i] & mask;
first[xn++] = b[i] & mask;
}
sort(first, first + xn);
xn = unique(first, first + xn) - first;
for (int i = 0; i < xn; i++) {
root[i] = i;
deg[i] = 0;
}
for (int i = 0; i < n; i++) {
int u = U[i] = lower_bound(first, first + xn, a[i] & mask) - first;
int v = V[i] = lower_bound(first, first + xn, b[i] & mask) - first;
deg[u]++;
deg[v]++;
u = find_root(u);
v = find_root(v);
root[u] = v;
}
for (int i = 0; i < xn; i++) {
if (deg[i] & 1) {
return false;
}
if (find_root(i) != find_root(0)) {
return false;
}
}
for (int i = 0; i < n; i++) {
int u = U[i];
int v = V[i];
adj[u].insert({v, 1 + i});
adj[v].insert({u, -1 - i});
}
find_path(0);
for (int i = 0; i < n; i++) {
int id = path[i];
ans[i * 2 + 1] = abs(id) * 2 - 1;
ans[i * 2 + 2] = abs(id) * 2;
if (id > 0) {
swap(ans[i * 2 + 1], ans[i * 2 + 2]);
}
}
return true;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", a + i, b + i);
}
for (int i = 20; i > 0; i--) {
if (can(i)) {
printf("%d\n", i);
for (int i = 1; i <= n + n; i++) {
printf("%d ", ans[i]);
}
puts("");
return 0;
}
}
puts("0");
for (int i = 1; i <= n + n; i++) {
printf("%d ", i);
}
puts("");
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main(int argc, const char* argv[]) {
int n;
std::cin >> n;
std::string s;
std::cin >> s;
int count = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1')
count++;
else
break;
}
if (count == n)
std::cout << count << std::endl;
else
std::cout << count + 1 << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200015];
char s[200015];
vector<pair<int, int> > ans;
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); i++) scanf("%d", &a[i]);
scanf("%s", s + 1);
sort(a + 1, a + n + 1);
int lp = 1, rp = n;
for (int i = (1); i <= (n); i++)
if (i == 1 || s[i] != s[i - 1]) rp--;
lp = rp++;
bool flag = 0;
for (int l = 1, r; l <= n; l = r + 1) {
r = l;
while (r < n && s[r + 1] == s[l]) r++;
int len = r - l + 1;
ans.push_back(make_pair(a[rp++], s[l] == 'R'));
for (int _ = (1); _ <= (len - 1); _++) {
ans.push_back(make_pair(a[lp--], (s[1] == 'L') ^ flag));
flag ^= 1;
}
}
for (auto x : ans) {
printf("%d %c\n", x.first, x.second == 0 ? 'L' : 'R');
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, c, d, i, j, k, l, n, m, x, y;
cin >> n >> m;
long long int v[n + 8], s[n + 8];
k = 0;
l = 0;
x = 0;
j = 0;
for (i = 0; i < n; i++) {
cin >> s[i];
l += s[i];
}
for (i = 0; i < n - 1; i++) {
k += s[i];
a = k % m;
b = l - k;
b = b % m;
c = b + a;
x = max(x, c);
}
cout << x;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int T;
int n, l[10005], t;
int s[10005];
int spa;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
spa = 0;
int it = 0;
memset(l, 0, sizeof(l));
memset(s, 0, sizeof(s));
for (int i = 0; i < n; i++) {
scanf("%d", &t);
l[t]++;
if (l[t] == 2)
s[it++] = t;
else if (l[t] == 4)
spa = spa == 0 ? t : min(spa, t);
}
int cl, cr, cd;
if (spa != 0)
printf("%d %d %d %d\n", spa, spa, spa, spa);
else {
sort(s, s + it);
cl = s[0];
cr = s[1];
for (int i = 2; i < it; i++) {
if ((float)s[i] / (float)s[i - 1] < (float)cr / (float)cl) {
cl = s[i - 1];
cr = s[i];
}
}
printf("%d %d %d %d\n", cl, cl, cr, cr);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
string s;
cin >> n >> s;
if (count((s).begin(), (s).end(), '(') ^ count((s).begin(), (s).end(), ')'))
return cout << "-1\n", 0;
int ans = 0;
for (int i = 0; i < n;) {
int sum = s[i] == '(' ? 1 : -1;
int nxtI = i + 1;
bool neg = false;
while (nxtI < n && sum) {
neg |= (sum < 0);
sum += s[nxtI] == '(' ? 1 : -1;
++nxtI;
}
if (neg) ans += nxtI - i;
i = nxtI;
}
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const long long MOD = 998244353;
const long long inv2 = (MOD + 1) / 2;
int h[N];
long long pw2[N];
long long fac[N], inv[N];
long long pw(long long a, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = ans * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return ans;
}
void init() {
fac[0] = inv[0] = 1;
pw2[0] = 1;
for (int i = 1; i < N; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = pw(fac[i], MOD - 2);
pw2[i] = pw2[i - 1] * 2 % MOD;
}
}
long long C(int n, int m) { return fac[n] * inv[m] % MOD * inv[n - m] % MOD; }
long long cal(int n) {
if (n & 1)
return pw2[n - 1];
else
return (pw2[n] - C(n, n / 2)) * inv2 % MOD;
}
void solve() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", h + i);
if (k == 1) {
printf("0\n");
return;
}
int a = 0;
for (int i = 0; i < n; i++) {
if (h[i] == h[(i + 1) % n]) a++;
}
long long ans = 0;
int b = n - a;
for (int i = 0; i < b; i++) {
ans += C(b, i) * pw(k - 2, i) % MOD * cal(b - i);
ans %= MOD;
}
ans *= pw(k, a);
ans %= MOD;
if (ans < 0) ans += MOD;
printf("%lld\n", ans);
}
int main() {
init();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long max3 = 1003;
const long long max4 = 10004;
const long long max5 = 100005;
const long long max6 = 1000006;
const long long max7 = 10000007;
const long long lg4 = 13;
const long long lg5 = 17;
const long long lg6 = 20;
const long long INF = 2LL * 1000000000;
const long long INFLL = 9LL * 1000000000 * 1000000000;
const long long M = 1e9 + 7;
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
}
return res;
}
int n;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n, s;
cin >> n >> s;
if (n == 1)
cout << "0" << '\n';
else if (n <= 2)
cout << s << '\n';
else
cout << 2 * s << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
inline void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
inline void writes(string s) { puts(s.c_str()); }
inline void writeln() { writes(""); }
inline void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
int n, m, i, j, dfn[2005], low[2005], ti, col[2005], dep[2005], mx, v,
vis[2005], c, all, ans, cc;
vector<int> e[2005], ee[2005];
stack<int> stk;
void tarjan(int x, int fa) {
dfn[x] = low[x] = ++ti;
stk.push(x);
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++)
if (*it != fa) {
if (!dfn[*it]) {
tarjan(*it, x);
low[x] = min(low[x], low[*it]);
} else
low[x] = min(low[x], dfn[*it]);
}
if (low[x] == dfn[x]) {
cc++;
while (stk.top() != x) {
col[stk.top()] = cc;
stk.pop();
}
col[stk.top()] = cc;
stk.pop();
}
}
void dfs(int x, int fa) {
vis[x] = 1;
if (dep[x] > mx) {
mx = dep[x];
v = x;
}
if (ee[x].size() == 1) c++;
all++;
for (__typeof((ee[x]).begin()) it = (ee[x]).begin(); it != (ee[x]).end();
it++)
if (*it != fa) {
dep[*it] = dep[x] + 1;
dfs(*it, x);
}
}
int main() {
read(n);
read(m);
while (m--) {
int x, y;
read(x);
read(y);
e[x].push_back(y);
e[y].push_back(x);
}
for (((i)) = (1); ((i)) <= ((n)); ((i))++)
if (!dfn[i]) tarjan(i, 0);
for (((i)) = (1); ((i)) <= ((n)); ((i))++)
for (__typeof((e[i]).begin()) it = (e[i]).begin(); it != (e[i]).end(); it++)
if (col[i] != col[*it]) {
ee[col[i]].push_back(col[*it]);
}
ans = n - cc;
ans--;
for (((i)) = (1); ((i)) <= ((cc)); ((i))++)
if (!vis[i]) {
ans++;
mx = v = -1;
dep[i] = 1;
dfs(i, 0);
mx = 1;
all = c = 0;
dep[v] = 1;
dfs(v, 0);
if (all != 1) ans += all - c - mx + 2;
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
cout << min((m + n) / 3, min(m, n));
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], x;
long long ans;
int main() {
scanf("%d%d", &n, &x);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
ans += abs(a[(n + 1) / 2] - x);
for (int i = 1; i < (n + 1) / 2; i++)
if (a[i] > x) ans += a[i] - x;
for (int i = (n + 1) / 2 + 1; i <= n; i++)
if (a[i] < x) ans += x - a[i];
printf("%lld\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gh;
long long n, a, akt, lb, licz, ret, p, k, s;
vector<long long> v;
void pri(long long x) { cout << "? " << x << endl; }
int main() {
cin >> gh;
for (int hg = 0; hg < gh; ++hg) {
cin >> n;
a = n;
lb = 0;
while (a) {
++lb;
a >>= 1;
}
p = 1;
k = n + 1;
s = (p + k) >> 1;
v.clear();
while (p < s) {
v.push_back(s);
p = s;
s = (p + k) >> 1;
}
reverse(v.begin(), v.end());
akt = 1;
licz = 0;
for (auto i : v) {
if (licz) {
akt -= i - 1;
} else {
akt += i - 1;
}
licz ^= 1;
}
pri(akt);
cin >> licz;
if (akt <= n / 2) {
licz = 0;
} else {
licz = 1;
}
p = 1;
k = n + 1;
s = (p + k) >> 1;
while (p < s) {
if (licz) {
akt -= s - 1;
} else {
akt += s - 1;
}
pri(akt);
cin >> ret;
if (ret) {
k = s;
} else {
p = s;
}
s = (p + k) >> 1;
licz ^= 1;
}
cout << "= " << p << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[2][3];
int b[8], x[8];
int lo[7], hi[7];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
int t;
cin >> t;
while (t--) {
for (int k = 0; k < 2; k++)
for (int j = 0; j < 3; j++) cin >> a[k][j];
for (int i = 0; i < 7; i++) cin >> b[i];
int found = 0;
for (x[0] = 0; x[0] <= b[0] && !found; x[0]++) {
for (int p = 0; p <= b[1] + b[2] + b[4]; p++) {
lo[4] = max({0, x[0] + p - a[0][0]});
hi[4] = min({b[4], a[1][0] + x[0] + p - b[0] - b[1] - b[2]});
lo[2] = max({0, x[0] + p - a[0][1]});
hi[2] = min({b[2], a[1][1] + x[0] + p - b[0] - b[1] - b[4]});
lo[1] = max({0, x[0] + p - a[0][2]});
hi[1] = min({b[1], a[1][2] + x[0] + p - b[0] - b[4] - b[2]});
if (lo[1] <= hi[1] && lo[2] <= hi[2] && lo[4] <= hi[4]) {
if (lo[1] + lo[2] + lo[4] <= p && p <= hi[1] + hi[2] + hi[4]) {
x[1] = lo[1];
x[2] = lo[2];
x[4] = lo[4];
for (int i : {1, 2, 4}) {
if (x[1] + x[2] + x[4] < p) {
int d = p - x[1] - x[2] - x[4];
d = min(d, hi[i] - lo[i]);
x[i] += d;
}
}
x[3] = min(b[3], a[0][0] + x[4] - x[0] - p);
x[5] = min(b[5], a[0][1] + x[2] - x[0] - p);
x[6] = min(b[6], a[0][2] + x[1] - x[0] - p);
int moze = 1;
if (x[3] - x[4] < b[0] + b[1] + b[2] + b[3] - a[1][0] - x[0] - p)
moze = 0;
if (x[5] - x[2] < b[0] + b[1] + b[4] + b[5] - a[1][1] - x[0] - p)
moze = 0;
if (x[6] - x[1] < b[0] + b[2] + b[4] + b[6] - a[1][2] - x[0] - p)
moze = 0;
if (min({x[3], x[5], x[6]}) < 0) moze = 0;
if (!moze) continue;
for (int i = 0; i < 7; i++) cout << x[i] << " \n"[i == 6];
found = 1;
break;
}
}
}
}
if (!found) cout << "-1\n";
}
}
| 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.