solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, pos, l, r, res;
res = 0;
cin >> n >> pos >> l >> r;
if (abs(pos - l) <= abs(pos - r)) {
if (l != 1) {
res = abs(pos - l);
pos = l;
}
if (l != 1) res++;
if (r != n) res += abs(pos - r);
if (r != n) res++;
cout << res;
exit(0);
} else {
if (r != n) {
res = abs(pos - r);
pos = r;
}
if (r != n) res++;
if (l != 1) res += abs(pos - l);
if (l != 1) res++;
cout << res;
exit(0);
}
}
| 2 |
#include <bits/stdc++.h>
char ex[2 * (1 << 22)];
int nd[2 * (1 << 22) + 22];
int nxt[2 * (1 << 22)];
int ut[2 * (1 << 22) + 22], dr;
char fol[2 * (1 << 22)];
int n2;
int q[2 * (1 << 22) + 22], sq, dq;
void bfs(int x) {
dq = 1;
q[0] = x;
fol[x] = 1;
sq = 0;
while (sq < dq) {
x = q[sq];
sq++;
int p = ut[x];
while (p != -1) {
if (!fol[nd[p]]) {
fol[nd[p]] = 1;
q[dq++] = nd[p];
}
p = nxt[p];
}
if (x < n2) {
int y = x, z;
while (y > 0) {
z = y & (-y);
y = y & (y - 1);
if (!fol[x ^ z]) {
fol[x ^ z] = 1;
q[dq++] = x ^ z;
}
}
}
}
}
inline void add(int x, int y) {
nd[dr] = y;
nxt[dr] = ut[x];
ut[x] = dr;
dr++;
}
int main() {
memset(ut, -1, sizeof ut);
int n, m, i, x, rez = 0, nt;
scanf("%d%d", &n, &m);
n2 = (1 << n);
nt = n2 - 1;
for (i = 0; i < m; i++) {
scanf("%d", &x);
ex[x + n2] = 1;
add(n2 + x, nt ^ x);
add(x, n2 + x);
}
for (i = n2; i < 2 * n2; i++) {
if (ex[i] && !fol[i]) {
rez++;
bfs(i);
}
}
printf("%d", rez);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n, len, tot, sum;
int f[1100], a[1100];
int main() {
cin >> s;
len = s.size();
for (int i = 0; i < len; i++) {
if (s[i] != ',')
tot = tot * 10 + int(s[i] - '0');
else {
if (!f[tot]) {
a[++n] = tot;
f[tot] = 1;
}
tot = 0;
}
if (i == len - 1) {
if (!f[tot]) {
a[++n] = tot;
f[tot] = 1;
}
tot = 0;
}
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
int total = 0, begin = a[i];
while (a[i] == begin + total && i <= n) {
i++;
total++;
}
i--;
if (total + begin != a[i]) total--;
if (total == 0) {
if (!sum)
cout << a[i];
else
cout << ',' << a[i];
} else {
if (!sum)
cout << begin << '-' << begin + total;
else
cout << ',' << begin << '-' << begin + total;
}
sum++;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, sum;
int a[N];
int st[N];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) scanf("%d", a + i), sum += a[i];
for (int i = n; i; --i) {
st[i] = st[i + 1] + a[i];
}
for (int i = 1; i <= n; ++i) {
a[i] += a[i - 1];
}
for (int i = n; i; --i) st[i] = min(st[i + 1], st[i]);
int ans = sum;
for (int i = 0; i <= n; ++i) {
ans = max(ans, sum - 2 * (a[i] + st[i + 1]));
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
double a, b, Sig1, Sig2;
inline int gcd(int x, int y) {
if (!y) return x;
return gcd(y, x % y);
}
inline int read(int &x) {
char ch;
int N = 1;
while ((ch = getchar()) && (!((ch >= '0') && (ch <= '9'))) && (!(ch == '-')))
;
if ((ch == '-')) {
N = -1;
while ((ch = getchar()) && (!((ch >= '0') && (ch <= '9'))))
;
}
x = ch - 48;
while ((ch = getchar()) && (((ch >= '0') && (ch <= '9'))))
x = x * 10 + ch - 48;
x *= N;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lf %lf", &a, &b);
Sig1 += a;
Sig2 += b;
}
Sig1 += 0.1;
printf("%lf\n", Sig2 / n + Sig2 / Sig1 / 10000 + 5);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, l, r;
char c1, c2;
string s;
cin >> n >> m;
cin >> s;
for (int i = 0; i < m; ++i) {
cin >> l >> r >> c1 >> c2;
for (int j = l - 1; j < r; ++j) {
if (s[j] == c1) {
s[j] = c2;
}
}
}
cout << s;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool vowel(char a) {
a = toupper(a);
if ((a == 'A') || (a == 'E') || (a == 'I') || (a == 'O') || (a == 'U'))
return 1;
return 0;
}
long long int n, m, q, a, b, c, sum = 0, cnt = 0;
long long int arr[500055];
map<long long int, bool> mp;
string str;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int j = 0; j < m; j++) {
cin >> a >> b >> c;
long long int tk = arr[c];
int bg = 0, sm = 0;
for (int i = a; i <= b; i++) {
if (arr[i] > tk) bg++;
}
int pos = b - bg;
if (pos == c) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007, N = 1000010;
long long gcd(long long a, long long b) {
return (a % b == 0) ? b : gcd(b, a % b);
}
int n, f[N], g[N], fa[N];
long long sz[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &sz[i]);
for (int i = 2; i <= n; i++) scanf("%d", &fa[i]);
for (int i = n; i > 1; i--) sz[fa[i]] += sz[i];
for (int i = 1; i <= n; i++) {
long long k = sz[1] / gcd(sz[1], sz[i]);
if (k <= n) g[k]++;
}
for (int i = n; i; i--)
for (int j = i * 2; j <= n; j += i) g[j] += g[i];
for (int i = n; i; i--)
if (g[i] >= i) {
f[i] = 1;
for (int j = i * 2; j <= n; j += i) (f[i] += f[j]) %= mod;
}
printf("%d", f[1]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j;
string str;
cin >> n >> m;
for (i = 1; i <= n; i++) {
if (i % 2) {
str = "";
for (j = 1; j <= m; j++) str += '#';
} else if ((i % 2 == 0) && (i % 4 == 0)) {
str = "#";
for (j = 2; j <= m; j++) str += '.';
} else {
str = "";
for (j = 2; j <= m; j++) str += '.';
str += '#';
}
cout << str << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXMEM = 210;
const int CHARSET = 21;
const int MOD = 1000000007;
struct node {
short id;
int value;
node *fail, *next[CHARSET];
void *operator new(size_t);
} * root, *null, mem[MAXMEM], *top;
void *node::operator new(size_t) {
memset(top, 0, sizeof(*top));
top->id = top - mem;
return top++;
}
void init() {
top = mem;
null = new node;
root = new node;
}
void insert(int *s, int len, int t) {
node *p = root;
for (int i, j = 0; j < len; p = p->next[i], j++) {
i = *s++;
if (!p->next[i]) {
p->next[i] = new node;
}
}
p->value += t;
}
void build_ac(int charset) {
typedef node *pnode;
static pnode queue[MAXMEM], *l, *r;
node *p, *q;
l = r = queue;
*r++ = root;
for (int i = 0; i < charset; i++) {
null->next[i] = root;
}
root->fail = null;
while (l != r) {
p = *l++;
if (p->fail->value) {
p->value += p->fail->value;
}
for (int i = 0; i < charset; i++) {
q = p->fail;
if (p->next[i]) {
p->next[i]->fail = q->next[i];
*r++ = p->next[i];
} else {
p->next[i] = q->next[i];
}
}
}
}
const int MAXLEN = 210;
long long dp[MAXMEM][MAXLEN][505];
int digit[MAXLEN];
int m, k;
long long dfs(node *root, int pos, bool bound, bool preIsZero, int value) {
if (!root) return 0;
value += root->value;
if (value > k) return 0;
if (pos == -1) {
return 1LL;
}
if (dp[root->id][pos][value] != -1 && !bound && !preIsZero) {
return dp[root->id][pos][value];
}
long long ans = 0;
int end = bound ? digit[pos] : m - 1;
if (preIsZero && pos > 0) {
ans = (ans + dfs(root, pos - 1, bound && end == 0, true, value)) % MOD;
} else {
ans = (ans + dfs(root->next[0], pos - 1, bound && end == 0, false, value)) %
MOD;
}
for (int i = 1; i <= end; i++) {
ans = (ans + dfs(root->next[i], pos - 1, bound && i == end, false, value)) %
MOD;
}
if (!preIsZero && !bound) {
dp[root->id][pos][value] = ans;
}
return ans;
}
long long gao(int *s, int len) {
for (int i = len - 1; i >= 0; i--) {
digit[len - 1 - i] = s[i];
}
return dfs(root, len - 1, true, true, 0);
}
int la, lb, lv;
int a[MAXLEN], b[MAXLEN], v[MAXLEN];
int main() {
int n;
int *pa, *pb, *ea, *eb;
scanf("%d %d %d", &n, &m, &k);
scanf("%d", &la);
for (int i = 0; i < la; i++) {
scanf("%d", &a[i]);
}
scanf("%d", &lb);
for (int i = 0; i < lb; i++) {
scanf("%d", &b[i]);
}
pa = a;
ea = a + la;
for (int i = la - 1; i >= 0; i--) {
if (pa[i] == 0) {
pa[i] = m - 1;
} else {
pa[i]--;
break;
}
}
if (*pa == 0 && *(pa + 1) != 0) {
pa++;
}
la = ea - pa;
pb = b;
eb = b + lb;
init();
for (int i = 0; i < n; i++) {
scanf("%d", &lv);
for (int j = 0; j < lv; j++) {
scanf("%d", &v[j]);
}
int val;
scanf("%d", &val);
insert(v, lv, val);
}
build_ac(m);
memset(dp, -1, sizeof dp);
long long ans = ((gao(pb, lb) - gao(pa, la)) % MOD + MOD) % MOD;
printf("%I64d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define gap " "
#define endl "\n"
#define pie acos(-1)
#define mod 1000000007
using namespace std;
int main()
{
ios_base::sync_with_stdio(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll test;
cin >> test;
while (test--)
{
ll a, b;
cin >> a >> b;
if (b == 1)
cout << "NO" << endl;
else
{
cout << "YES" << endl;
if (b != 2)
cout << a << gap << a * (b - 1) << gap << a * b << endl;
else
cout << a * 7 << gap << a * 3 << gap << a * b * 5 << endl;
}
}
}
// Roxy Sarkar
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
map<string, int> m;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
++m[s];
}
int b = 0;
string ans;
for (auto a : m) {
if (a.second > b) {
b = a.second;
ans = a.first;
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 2e9;
const long long LINF = 4e18;
const long long delta = 24659;
const int N = 5e5 + 5;
int n, m, q, p[N], par[N], st[N], ft[N];
vector<int> G[N];
pair<int, int> E[N], Q[N], seg[4 * N];
bool rem[N];
int getPar(int x) {
if (par[x] == x) return x;
return par[x] = getPar(par[x]);
}
void unite(int x, int y) {
x = getPar(x);
y = getPar(y);
if (x == y) return;
n++;
G[n].push_back(x);
G[n].push_back(y);
par[x] = n;
par[y] = n;
par[n] = n;
}
int dtime;
void dfs(int v) {
st[v] = dtime++;
for (int u : G[v]) dfs(u);
ft[v] = dtime;
}
void update(int x, int val, int id = 1, int l = 0, int r = n) {
if (x < l || r <= x) return;
if (r - l == 1) {
seg[id] = make_pair(val, x);
return;
}
int mid = (l + r) / 2;
update(x, val, 2 * id, l, mid);
update(x, val, 2 * id + 1, mid, r);
seg[id] = max(seg[2 * id], seg[2 * id + 1]);
}
pair<int, int> get(int x, int y, int id = 1, int l = 0, int r = n) {
if (y <= l || r <= x) return make_pair(-1, -1);
if (x <= l && r <= y) return seg[id];
int mid = (l + r) / 2;
return max(get(x, y, 2 * id, l, mid), get(x, y, 2 * id + 1, mid, r));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
par[i] = i;
}
for (int i = 1; i <= m; i++) {
int v, u;
scanf("%d %d", &v, &u);
E[i] = make_pair(v, u);
}
for (int i = 1; i <= q; i++) {
int type, x;
scanf("%d %d", &type, &x);
Q[i] = make_pair(type, x);
if (type == 2) rem[x] = 1;
}
for (int i = 1; i <= m; i++)
if (!rem[i]) {
unite(E[i].first, E[i].second);
}
for (int i = q; i >= 1; i--) {
if (Q[i].first == 1) {
Q[i].second = getPar(Q[i].second);
}
if (Q[i].first == 2) {
int v = E[Q[i].second].first, u = E[Q[i].second].second;
unite(v, u);
}
}
for (int i = 1; i <= n; i++)
if (par[i] == i) dfs(i);
for (int i = 1; i <= n; i++) update(st[i], p[i]);
for (int i = 1; i <= q; i++) {
int type = Q[i].first, v = Q[i].second;
if (type == 1) {
pair<int, int> tmp = get(st[v], ft[v]);
printf("%d\n", tmp.first);
update(tmp.second, 0);
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long w[111111], ww[111111];
long long sum[111111];
int main() {
long long n, l, r, ql, qr;
scanf("%I64d%I64d%I64d%I64d%I64d", &n, &l, &r, &ql, &qr);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &w[i]);
sum[i] = sum[i - 1] + w[i];
}
long long ans = 111111111111111ll;
for (int i = 0; i <= n; i++) {
int t = 0;
if (i > n - i)
t = (2 * i - n - 1) * ql;
else if (i < n - i)
t = (n - 2 * i - 1) * qr;
ans = min(ans, sum[i] * l + (sum[n] - sum[i]) * r + t);
}
printf("%I64d", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100010];
int A[100010];
int main() {
int n, x, y, a;
cin >> n;
for (x = 0; x < n; x++) {
cin >> a;
v[n - a].push_back(x);
}
int s = 0;
for (x = 1; x <= n; x++) s += (v[x].size() / x) * x;
if (s != n)
cout << "Impossible\n";
else {
cout << "Possible\n";
int i = 1;
for (x = 1; x <= n; x++) {
for (y = 0; y < v[x].size(); y++) {
A[v[x][y]] = i;
i += ((y + 1) % x) == 0;
}
}
for (x = 0; x < n; x++) cout << A[x] << " ";
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string s = "";
if (n > m) {
if (n - m == 1) {
for (int i = 0; i < (n + m); i++) {
if (i % 2 == 0) {
s += '0';
} else {
s += '1';
}
}
cout << s << endl;
} else {
cout << -1;
}
} else {
if (m > (2 * n + 2)) {
cout << -1;
} else {
if (m >= (2 * n)) {
for (int i = 0; i < (n + m); i++) {
if (i % 3 == 0) {
s += '1';
} else if (i % 3 == 1) {
s += '1';
} else {
s += '0';
}
}
} else {
int c = (m - n);
for (int i = 0; i < (3 * c); i++) {
if (i % 3 == 0) {
s += '0';
} else if (i % 3 == 1) {
s += '1';
} else {
s += '1';
}
}
int l = (2 * n - m);
for (int i = 0; i < 2 * l; i++) {
if (i % 2 == 0) {
s += '0';
} else {
s += '1';
}
}
}
}
cout << s << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n][m], b[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
b[i][j] = 0;
}
}
bool f = 1;
vector<pair<int, int> > ans;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < m - 1; j++) {
if (a[i][j] == 0) continue;
if (a[i][j]) {
for (int k = i; k <= i + 1 && k < n; k++) {
for (int l = j; l <= j + 1 && l < m; l++) {
if (!a[k][l]) {
f = 0;
break;
}
}
}
if (f) {
ans.push_back(make_pair(i, j));
for (int k = i; k <= i + 1 && k < n; k++) {
for (int l = j; l <= j + 1 && l < m; l++) {
b[k][l] = 1;
}
}
} else {
f = 1;
}
}
}
}
f = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] != b[i][j]) {
f = 0;
break;
}
}
if (!f) break;
}
if (!f)
cout << -1 << endl;
else {
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first + 1 << " " << ans[i].second + 1 << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[105];
int lef[105];
int rig[105];
int maxs[105];
int dp[10005];
int main() {
ios::sync_with_stdio(false);
int row;
int ti;
int i;
int j;
int k;
int n;
memset(a, 0, sizeof(a));
memset(dp, 0, sizeof(dp));
cin >> row >> ti;
for (i = 1; i <= row; i++) {
cin >> n;
for (j = 1; j <= n; j++) cin >> a[j];
memset(lef, 0, sizeof(lef));
memset(rig, 0, sizeof(rig));
memset(maxs, 0, sizeof(maxs));
for (j = 1; j <= n; j++) lef[j] = lef[j - 1] + a[j];
for (j = n; j >= 1; j--) rig[n - j + 1] = rig[n - j] + a[j];
for (j = 1; j <= n; j++) {
for (k = 0; k <= j; k++) {
maxs[j] = max(maxs[j], lef[k] + rig[j - k]);
}
}
for (j = ti; j >= 1; j--) {
for (k = 1; k <= min(j, n); k++) {
dp[j] = max(dp[j], dp[j - k] + maxs[k]);
}
}
}
cout << dp[ti] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
bool val = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int a;
scanf("%d", &a);
if (i == j) {
val ^= a;
}
}
}
int q;
scanf("%d", &q);
while (q--) {
int t;
scanf("%d", &t);
if (t == 3) {
printf("%d", val);
} else {
int i;
scanf("%d", &i);
val ^= 1;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int q, a, x, y;
vector<int> G[10001];
int main() {
cin >> q;
for (int i = 1; i < q; i++) {
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = 1; i <= q; i++)
for (int j = 0; j < G[i].size(); j++) a += G[G[i][j]].size() - 1;
cout << a / 2;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 21;
int n, m, ii, h, i, j, jj, mk, tot, mx;
int addMask[MAXN][MAXN], cost[MAXN][MAXN], addCost[MAXN][MAXN];
int dp[(1 << (MAXN + 1))];
char s[MAXN][MAXN];
int main() {
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
scanf("%d", &cost[i][j]);
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
mk = tot = mx = 0;
for (ii = 1; ii <= n; ii++) {
if (s[i][j] == s[ii][j]) {
mk |= (1 << (ii - 1));
tot += cost[ii][j];
mx = max(mx, cost[ii][j]);
}
}
addMask[i][j] = mk;
addCost[i][j] = tot - mx;
}
}
h = (1 << n) - 1;
for (i = 0; i <= h; i++) {
dp[i] = (int)1e9;
}
dp[0] = 0;
for (i = 0; i < h; i++) {
for (j = 1; (i & (1 << (j - 1))); j++)
;
for (jj = 1; jj <= m; jj++) {
dp[i ^ (1 << (j - 1))] = min(dp[i ^ (1 << (j - 1))], dp[i] + cost[j][jj]);
dp[i | addMask[j][jj]] =
min(dp[i | addMask[j][jj]], dp[i] + addCost[j][jj]);
}
}
printf("%d\n", dp[h]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<string, string> > arr(n);
for (int i = 0; i < n; i++) cin >> arr[i].first >> arr[i].second;
for (int i = 0; i < n; i++)
if (arr[i].second == "rat") cout << arr[i].first << endl;
for (int i = 0; i < n; i++)
if (arr[i].second == "woman" || arr[i].second == "child")
cout << arr[i].first << endl;
for (int i = 0; i < n; i++)
if (arr[i].second == "man") cout << arr[i].first << endl;
for (int i = 0; i < n; i++)
if (arr[i].second == "captain") cout << arr[i].first << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, s;
cin >> a >> b >> s;
a = abs(a);
b = abs(b);
if (a + b <= s) {
if (((a + b) & 1) && (s & 1))
cout << "Yes\n";
else if ((a + b) % 2 == 0 && (s % 2 == 0))
cout << "Yes\n";
else
cout << "No\n";
} else
cout << "No\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m, n, idx = 0, mem[110] = {};
char op[20];
scanf("%d%d", &t, &m);
while (t--) {
scanf("%s", op);
if (op[0] == 'a') {
scanf("%d", &n);
int flg = 0;
for (int i = 1, j; i <= m; i = j) {
if (mem[i] != 0) {
j = i + 1;
continue;
}
for (j = i; j <= m && mem[j] == 0; j++)
;
if (j - i >= n) {
idx++;
flg = 1;
for (int k = 0; k < n; k++) mem[i + k] = idx;
break;
}
}
if (flg)
printf("%d\n", idx);
else
puts("NULL");
} else if (op[0] == 'e') {
scanf("%d", &n);
int flg = 0;
if (n < 1 || n > idx) {
puts("ILLEGAL_ERASE_ARGUMENT");
continue;
}
for (int i = 1; i <= m; i++)
if (mem[i] == n) mem[i] = 0, flg = 1;
if (flg == 0) puts("ILLEGAL_ERASE_ARGUMENT");
} else if (op[0] == 'd') {
for (int i = 1, j = 1; i <= m; i++)
if (mem[i] != 0) {
mem[j++] = mem[i];
if (i >= j) mem[i] = 0;
}
} else
puts("QQ");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 10000100;
vector<int> v[30];
long long d[30] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97};
long long pri[4000100];
long long cnt;
bool b[N];
long long n, m;
long long power(long long a, long long b, long long c) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % c;
a = a * a % c;
b >>= 1;
}
return ret;
}
void getp() {
for (long long i = 2; i <= 2000000; i++) {
if (!b[i]) {
pri[++cnt] = i;
for (long long j = 0; j < 25; j++)
if (i >= m && (i - 1) % d[j] == 0) v[j].push_back(i);
}
for (long long j = 1; 1ll * i * pri[j] <= 2000000 && j <= cnt; j++) {
b[i * pri[j]] = 1;
if (i % pri[j] == 0) break;
}
}
}
long long f1[100];
string s1, s2;
void solve(long long w) {
memset(f1, 0, sizeof(f1));
for (long long i = 0; i < n; i++) f1[i % d[w]] += s1[i] - s2[i];
long long xx = v[w].size();
for (long long i = 0; i < xx; i++) {
long long p = v[w][i];
for (long long j = 2; j < p - 2; j++) {
long long kk = power(j, (p - 1) / d[w], p);
if (kk != 1) {
for (long long ww = 1; ww <= d[w]; ww++) {
long long l = power(kk, ww, p);
if (l < 2 || l > p - 2) continue;
long long tmp = 1, ret1 = 0;
for (long long k = 0; k < d[w]; k++) {
ret1 = (ret1 + tmp * f1[k]) % p;
tmp = tmp * l % p;
}
if (ret1 < 0) ret1 += p;
if (ret1 == 0) {
printf("%I64d %I64d\n", p, l);
exit(0);
}
}
break;
}
}
}
}
int main() {
cin >> n >> m;
cin >> s1 >> s2;
getp();
for (long long j = 0; j < 25; j++) solve(j);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, M = 51;
int rd() {
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * w;
}
int to[N << 2], nt[N << 2], hd[N << 1], tot = 1;
void adde(int x, int y) {
++tot, to[tot] = y, nt[tot] = hd[x], hd[x] = tot;
++tot, to[tot] = x, nt[tot] = hd[y], hd[y] = tot;
}
int n, e[N][2], dg[N << 1];
bool vs[N << 1], fx[N << 1], ban[N << 1];
void dfs(int x) {
vs[x] = 1;
for (int &i = hd[x]; i; i = nt[i]) {
if (ban[i >> 1]) continue;
ban[i >> 1] = 1, fx[i >> 1] = i & 1;
int y = to[i];
dfs(y);
}
}
int main() {
n = rd();
for (int i = 1; i <= n; ++i) {
e[i][0] = rd(), e[i][1] = rd();
adde(e[i][0], e[i][1] + 200000);
++dg[e[i][0]], ++dg[e[i][1] + 200000];
}
int las = 0;
for (int i = 1; i <= 400000; ++i)
if (dg[i] & 1) {
if (!las)
las = i;
else
adde(i, las), las = 0;
}
for (int i = 1; i <= 400000; ++i)
if (!vs[i]) dfs(i);
for (int i = 1; i <= n; ++i) putchar(fx[i] ? 'r' : 'b');
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100001];
long long ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) ans += max(0, a[i] - a[i + 1]);
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int b[55555];
int suff(string s1, int t1) {
string s2;
if (s1[t1] == 'l') {
if (s1[t1 + 4] == ' ') {
s2 = s1.substr(t1, 4);
if (s2 == "lios") {
return 0;
}
}
if (s1[t1 + 5] == ' ') {
s2 = s1.substr(t1, 5);
if (s2 == "liala") {
return 1;
}
}
}
if (s1[t1] == 'e') {
if (s1[t1 + 3] == ' ') {
s2 = s1.substr(t1, 3);
if (s2 == "etr") {
return 2;
}
}
if (s1[t1 + 4] == ' ') {
s2 = s1.substr(t1, 4);
if (s2 == "etra") {
return 3;
}
}
}
if (s1[t1] == 'i') {
if (s1[t1 + 6] == ' ') {
s2 = s1.substr(t1, 6);
if (s2 == "initis") {
return 4;
} else if (s2 == "inites") {
return 5;
}
}
}
return -1;
}
int main() {
string s;
int w = 0;
getline(cin, s);
s += ' ';
for (int t = 0; t < s.size(); t++) {
if (s[t] == ' ') {
if (w != 0 && (b[w] < b[w - 1] || b[w] % 2 != b[w - 1] % 2)) {
cout << "NO";
return 0;
}
if (b[w] == -1) {
cout << "NO";
return 0;
}
w++;
}
b[w] = suff(s, t);
if (b[w] == 0) {
t += 3;
} else if (b[w] == 1) {
t += 4;
} else if (b[w] == 2) {
t += 2;
} else if (b[w] == 3) {
t += 3;
} else if (b[w] != -1) {
t += 5;
}
}
w--;
if (w == 0) {
cout << "YES";
return 0;
}
for (int t = 0; t <= w; t++) {
if (b[t] == 2 || b[t] == 3) {
if (b[t + 1] != b[t]) {
cout << "YES";
return 0;
}
break;
}
}
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct sa {
double x;
double y;
double sr;
} s[100005];
int main() {
double r, d, n;
cin >> r >> d >> n;
double pr = r - d;
for (int i = 0; i < n; i++) {
scanf("%lf %lf %lf", &s[i].x, &s[i].y, &s[i].sr);
}
int cnt = 0;
for (int i = 0; i < n; i++) {
double dis = pow(s[i].x, 2) + pow(s[i].y, 2);
dis = sqrtl(dis);
cnt += (dis - pr >= s[i].sr) && (dis + s[i].sr <= r);
}
cout << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void null() { return; }
const long long INF = 3e18 + 9237;
const long long maxn = 1e5 + 7;
const long long mod = 1e9 + 7;
const long long sqN = 320;
const long long lgN = 20;
vector<string> vec;
char a[1 << 9][1 << 9];
string nagh(string s) {
for (long long i = 0; i < s.size(); i++)
if (s[i] == '+')
s[i] = '*';
else
s[i] = '+';
return s;
}
void check(long long n) {
for (long long i = 0; i < n; i++)
for (long long j = 0; j < n; j++) a[i][j] = vec[i][j];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < n; j++) {
if (i == j) continue;
long long sum = 0;
for (long long k = 0; k < n; k++)
sum += (a[i][k] == '*' ? -1 : 1) * (a[j][k] == '*' ? -1 : 1);
if (sum) return cout << i << " " << j << " you have been haked!", null();
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vec.push_back("+");
for (long long i = 0; i < n; i++) {
long long sz = vec.size();
for (long long j = 0; j < sz; j++) {
string tmp = vec[j] + nagh(vec[j]);
vec.push_back(tmp);
vec[j] = vec[j] + vec[j];
}
}
for (auto u : vec) cout << u << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 600010, mod = 1e9 + 7, P = 19260817;
long long n, m, T, k, x, cnt, y, b[N], vis[N], a[N], ans, t, sum;
string s;
int main() {
scanf("%lld", &T);
while (T--) {
scanf("%lld%lld", &n, &k);
sum = cnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &x);
sum += x;
if (x == k) cnt++;
}
if (cnt == n)
puts("0");
else if (sum == k * n || cnt)
puts("1");
else
puts("2");
}
}
| 3 |
#include <bits/stdc++.h>
inline int reads(char s[]) {
char c;
int len = 0;
while ((c = getchar()) != ' ' && c != '\n') s[len++] = c;
return len;
}
inline int read() {
char c;
int sgn = 1;
do {
c = getchar();
} while ((c < '0' || c > '9') && c != '-');
int ret = 0;
if (c == '-')
sgn = -1;
else
ret = c - '0';
while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return ret;
}
inline long long readl() {
char c;
int sgn = 1;
do {
c = getchar();
} while ((c < '0' || c > '9') && c != '-');
long long ret = 0;
if (c == '-')
sgn = -1;
else
ret = c - '0';
while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return ret;
}
template <typename T>
inline void write(T x) {
char F[60];
if (x < 0) putchar('-'), x = -x;
F[0] = x % 10 + '0';
x /= 10;
int cnt = 1;
while (x) {
F[cnt++] = x % 10 + '0';
x /= 10;
}
while (cnt) putchar(F[--cnt]);
putchar(10);
}
template <typename T>
inline bool read(T &ret) {
char c;
ret = 0;
T sgn = 1;
do {
c = getchar();
if (c == EOF) return false;
} while ((c < '0' || c > '9') && c != '-');
if (c == '-')
sgn = -1;
else
ret = c - '0';
while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return true;
}
template <typename T>
inline void _max(T &a, const T b) {
if (a < b) a = b;
}
template <typename T>
inline void _min(T &a, const T b) {
if (a > b) a = b;
}
template <typename T>
inline void _add(T &a, const T b) {
a = a + b;
}
template <typename T>
inline void _add(T &a, const T b, const T MOD) {
a = (a + b) % MOD;
}
template <typename T>
inline T _pow(T a, T b, const T MOD) {
T ans = 1;
while (b) {
if (b & 1) ans = ans * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ans;
}
using namespace std;
const int N = 200010;
const int INF = 1e9;
const long long MOD = 1e9 + 7;
struct P {
int m;
long long p;
bool operator<(const P &rhs) const { return p > rhs.p; }
} ps[N];
bool cmp(const P &a, const P &b) { return a.m > b.m; }
priority_queue<P> q;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
while (!q.empty()) q.pop();
for (int i = 0; i < n; i++) {
cin >> ps[i].m >> ps[i].p;
}
sort(ps, ps + n, cmp);
long long res = 0;
int l = 0, r = 0;
while (l < n) {
while (l < n && ps[l].m == ps[r].m) {
q.push(ps[l]);
l++;
}
while (n - ps[r].m < q.size()) {
res += q.top().p;
q.pop();
}
r = l;
}
cout << res << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> app[15];
bitset<5005> in[200005];
int arr[15][100005];
int main() {
int n, k, q;
scanf("%d%d%d", &n, &k, &q);
for (int i = 0; i < k; i++) {
for (int j = 0; j < 1 << 12; j++) {
if (j & (1 << i)) in[i].set(j);
}
for (int j = 0; j < n; j++) scanf("%d", arr[i] + j);
}
int cur = k;
while (q--) {
int tp, x, y;
scanf("%d%d%d", &tp, &x, &y);
x--;
y--;
if (tp == 1)
in[cur++] = in[x] & in[y];
else if (tp == 2)
in[cur++] = in[x] | in[y];
else {
int cnt = 0;
for (int i = 0; i < k; i++) app[cnt++] = make_pair(arr[i][y], i);
sort(app, app + cnt);
int ans = 0;
for (int i = 0; i < k; i++) {
ans |= 1 << app[i].second;
if (in[x][ans]) {
printf("%d\n", app[i].first);
break;
}
}
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
#define fi first
#define se second
#define ll long long
#define dl double long
using namespace std;
const int N = 3e4 + 7;
const long long mod = 998244353;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int n,c,q;
int p[N];
ll d[N][5];
ll L[N][5];
ll R[N][5];
vector < int > v[N][5];
void solve()
{
cin >> n >> c >> q;
for( int i = 1; i <= n; i++ ){
cin >> p[i];
}
for( int i = 0; i <= c; i++ )d[n + 1][i] = 1;
for( int i = 0; i <= n; i++ ){
for( int j = 0; j <= c; j++ ){
L[i][j] = R[i][j] = 0;
v[i][j].clear();
}
}
for( int i = n; i >= 1; i-- ){
for( int j = 0; j <= c; j++ ){
d[i][j] = d[i + 1][j];
vector < pair < int , int > > g;
g.push_back({ p[i] , 0 });
for( int h = 1; h <= j; h++ ){
if( i + h <= n ){
g.push_back({ p[i + h] , h });
d[i][j] += d[i + h + 1][j - h];
}
}
sort( g.begin() , g.end() );
for( auto x : g ){
v[i][j].push_back(x.se);
}
}
}
for( int i = 0; i <= c; i++ ){
for( int j = 1; j <= n; j++ ){
for( auto x : v[j][i] ){
if( x == 0 ){
R[j][i] += d[j + 1][i];
break;
}else{
L[j][i] += d[j + x + 1][i - x];
R[j][i] += d[j + x + 1][i - x];
}
}
}
}
for( int i = 0; i <= c; i++ ){
for( int j = 1; j <= n; j++ ){
L[j][i] += L[j - 1][i];
}
}
while( q-- ){
int i;
ll j;
cin >> i >> j;
if( j > d[1][c] ){
cout << "-1\n";
continue;
}
int st = 1;
int nc = c;
int ans = p[i];
while( st <= n ){
int l = st , r = n + 1;
while( l < r ){
int m = (l + r) / 2;
if( L[m][nc] - L[st - 1][nc] < j && j <= L[m - 1][nc] - L[st - 1][nc] + R[m][nc] ){
l = m + 1;
}else r = m;
}
if( l == n + 1 )break;
j -= L[l - 1][nc] - L[st - 1][nc];
st = l;
for( auto x : v[st][nc] ){
if( j > d[st + x + 1][nc - x] ){
j -= d[st + x + 1][nc - x];
}else{
if( st <= i && i <= st + x ){
ans = p[st + st + x - i];
}
st += x + 1;
nc -= x;
break;
}
}
}
cout << ans << "\n";
}
}
int main()
{
ios_base::sync_with_stdio(0);
//freopen( "input.txt" , "r" , stdin );
//freopen( "output.txt" , "w" , stdout );
int T;
cin >> T;
while( T-- ){
solve();
}
}
| 12 |
#include <bits/stdc++.h>
int main() {
int t, a, b, r;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &a, &b);
if (a == b)
printf("%d\n", (a * a * 4));
else if (a > b) {
r = 2 * b;
if (r > a)
printf("%d\n", r * r);
else
printf("%d\n", a * a);
} else {
r = 2 * a;
if (r > b)
printf("%d\n", r * r);
else
printf("%d\n", b * b);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, s;
constexpr int M = 6000;
int T[151][M];
int main() {
fill((int*)T, (int*)T + 151 * M, INT_MAX);
T[0][0] = 0;
cin.sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k >> s;
for (int i = 0; i < n; ++i) {
int q;
cin >> q;
for (int ch = k - 1; ch >= 0; --ch) {
int add = i - ch;
if (add < 0) continue;
for (int sw = 0; sw + add < M; ++sw) {
if (T[ch][sw] == INT_MAX) continue;
T[ch + 1][sw + add] = min(T[ch + 1][sw + add], T[ch][sw] + q);
}
}
}
int ret = INT_MAX;
for (int i = 0; i <= s && i < M; ++i) {
ret = min(ret, T[k][i]);
}
cout << ret << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
char c;
for (long long i = 0; i < n; i++) {
if (i % 2 == 0)
c = 'W';
else
c = 'B';
for (long long j = 0; j < n; j++) {
printf("%c", c);
if (c == 'B')
c = 'W';
else
c = 'B';
}
printf("\n");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
if (n == 1 && m == 1)
cout << 0;
else {
char a[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
int c = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i][m - 1] != 'D') c++;
}
for (int i = 0; i < m - 1; i++) {
if (a[n - 1][i] != 'R') c++;
}
cout << c;
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
long long n, k, N, i = 1, t = 0;
cin >> n >> k;
N = n;
for (long long res = 1; res <= N; ++res) {
long long a;
cin >> a;
long long d = t - (n - i) * a * (i - 1);
if (d >= k) {
t += a * (i - 1);
i += 1;
} else {
n -= 1;
cout << res << '\n';
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long q;
cin >> q;
long long r = 0, l = 0;
map<long long, long long> p;
long long x;
char y;
while (q--) {
cin >> y >> x;
if (y == 'L') {
l--;
p[x] = l;
} else if (y == 'R') {
r++;
p[x] = r;
} else {
if (p[x] < 0) {
cout << min(abs(l - p[x]), r - p[x] - 1) << "\n";
} else {
cout << min(r - p[x], abs(l - p[x]) - 1) << "\n";
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
string s;
cin >> s;
long long int x = 0, sum = 0;
for (int i = 0; i < n / 2; i++) {
if (s[i] == '?')
x++;
else
sum += s[i] - '0';
}
for (int i = n / 2; i < n; i++) {
if (s[i] == '?')
x--;
else
sum -= s[i] - '0';
}
if (x == 0 && sum == 0) {
cout << "Bicarp";
return 0;
} else if (x * sum < 0 && 2 * abs(sum) == 9 * abs(x)) {
cout << "Bicarp";
return 0;
}
cout << "Monocarp";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int num[100005];
int main() {
double n, m;
while (scanf("%lf%lf", &n, &m) != EOF) {
double ans = 0;
double jiang = 0;
for (int i = 1; i <= n; i++) {
double now = pow(i * 1.0 / n, m);
ans += i * (now - jiang);
jiang = now;
}
printf("%.7lf\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
cin >> n;
string arr[n];
for (int i = 0; i < n; ++i) cin >> arr[i];
for (int i = 0; i < n; ++i)
if (arr[i][0] == '+' || arr[i][2] == '+') {
ans++;
} else if (arr[i][0] == '-' || arr[i][2] == '-') {
ans--;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int hash[1001];
int a[1001];
int n, k;
int tot = 0;
int flag = 0;
int main() {
int i;
scanf("%d%d", &n, &k);
for (i = 1; i <= k; i++) {
scanf("%d", &a[i]);
hash[a[i]] = 1;
}
flag = 1;
for (i = 1; i <= k; i++) {
printf("%d", a[i]);
tot = 1;
while (tot < n) {
while (hash[flag]) flag++;
hash[flag] = 1;
printf(" %d", flag);
tot++;
}
printf("\n");
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
const int N=5e5+10,block=720;
int a[N],lsh[N],at[N],belong[N],cnt[N],f[block][block],n,m,last;
vector<int>in[N];
struct Block{
int l,r;
}b[block];
struct nodee{
struct node{
int l;
int r;
int w;
int key;
int siz;
bool flag;
}e[100010];
int cnt,rt;
int newnode(int w){
cnt ++;
e[cnt].w = w;
e[cnt].siz = 1;
return cnt;
}
void update(int i){
e[i].siz = e[e[i].l].siz + e[e[i].r].siz + 1;
}
void pushdown(int i){
swap(e[i].l,e[i].r);
e[e[i].l].flag ^= 1;
e[e[i].r].flag ^= 1;
e[i].flag = false;
}
void split(int i,int siz,int &x,int &y){
if(!i){
x = y = 0;
return ;
}
if(e[i].flag)pushdown(i);
if(e[e[i].l].siz < siz){
x = i;
split(e[i].r,siz - e[e[i].l].siz - 1,e[i].r,y);
}
else {
y = i;
split(e[i].l,siz,x,e[i].l);
}
update(i);
}
int merge(int x,int y){
if(!x || !y)return x + y;
if(e[x].key < e[y].key){
if(e[x].flag)pushdown(x);
e[x].r = merge(e[x].r,y);
update(x);
return x;
}
else {
if(e[y].flag)pushdown(y);
e[y].l = merge(x,e[y].l);
update(y);
return y;
}
}
};
int read(){
int s = 0,w = 1;
char ch = getchar();
while(ch < '0' || ch > '9'){if(ch == '-')w = -1;ch = getchar();}
while(ch >= '0' && ch <= '9')s = s * 10 + ch - '0',ch = getchar();
return s * w;
}
int query(int len,int x){
if (x<=(len+1)/2) return 1;
int t=len-x;
len-=2*t+1;
return len+1;
}
inline int ask(int l,int r){
int bl=belong[l],br=belong[r],ans=0;
if(bl==br){
for(int i=l;i<=r;i++){
ans=max(ans,++cnt[a[i]]);
}
for(int i=l;i<=r;i++){
cnt[a[i]]=0;
}
}else{
ans=f[bl+1][br-1];
for(int i=l;i<=b[bl].r;i++){
for(int pos=at[i];pos+ans<in[a[i]].size()&&in[a[i]][pos+ans]<=r;ans++);
}
for(int i=b[br].l;i<=r;i++){
for(int pos=at[i];pos-ans>=0&&in[a[i]][pos-ans]>=l;ans++);
}
}
return ans;
}
int main(){
n=read(),m=read();
for(int i=1;i<=n;i++){
a[i]=lsh[i]=read();
}
sort(lsh+1,lsh+n+1);
int sz=unique(lsh+1,lsh+n+1)-lsh;
for(int i=1;i<=n;i++){
a[i]=lower_bound(lsh+1,lsh+sz,a[i])-lsh;
in[a[i]].push_back(i);
at[i]=in[a[i]].size()-1;
}
int c=0;
for(int i=1;i<=n;i+=block){
c++;
b[c].l=i;
b[c].r=min(i+block-1,n);
}
for(int i=1;i<=c;i++){
int ans=0;
for(int j=b[i].l;j<=b[i].r;j++){
belong[j]=i;
}
for(int j=i;j<=c;j++){
for(int k=b[j].l;k<=b[j].r;k++){
ans=max(ans,++cnt[a[k]]);
}
f[i][j]=ans;
}
for(int j=i;j<=c;j++){
for(int k=b[j].l;k<=b[j].r;k++){
cnt[a[k]]=0;
}
}
}
while(m--){
int l=read(),r=read();
printf("%d\n",query(r - l + 1,ask(l,r)));
}
return 0;
} | 6 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using vi = vector<int>;
const int mxn = 12000;
const int mod = 998244353;
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) {
res = res * a % mod;
res %= mod;
}
a = a * a % mod;
a %= mod;
b /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n, p, h;
cin >> n >> p >> h;
long long nupto = (1ll << n);
vector<vi> a(2);
for (int i = 0; i < nupto / 2; i++) {
a[0].push_back(i);
}
for (int i = nupto / 2; i < nupto; i++) {
a[1].push_back(i);
}
const int m = nupto / 2 - 1;
auto magicalhash = [&](vi score) -> long long {
long long nowh = 0;
for (int i = 0; i < nupto; i++) {
if (score[i] == -1) continue;
long long now = (i + 1) % mod;
now *= binpow(p, score[i]) % mod;
nowh += now;
nowh %= mod;
}
return nowh;
};
auto f = [&](int t1, int t2) -> void {
vi rbt = a[t1], rbe = a[t2];
std::map<long long, vi> mp;
for (int msk = 0; msk < (1 << m); msk++) {
int now = 0;
vi game = rbt;
vi score(32, -1);
int depth = n - 1;
while ((int)(game).size() != 1) {
vi negame;
for (int i = 0; i < (int)(game).size(); i += 2) {
if (msk & (1 << now)) {
negame.push_back(game[i + 1]);
score[game[i]] = (1 << depth) + 1;
} else {
negame.push_back(game[i]);
score[game[i + 1]] = (1 << depth) + 1;
}
now++;
}
depth--;
swap(game, negame);
}
score[game[0]] = 1;
long long h1 = (magicalhash(score) + mod) % mod;
mp[h1] = score;
}
for (int msk = 0; msk < (1 << m); msk++) {
int now = 0;
vi game = rbe;
vi score(32, -1);
int depth = n - 1;
while ((int)(game).size() != 1) {
vi negame;
for (int i = 0; i < (int)(game).size(); i += 2) {
if (msk & (1 << now)) {
negame.push_back(game[i + 1]);
score[game[i]] = (1 << depth) + 1;
} else {
negame.push_back(game[i]);
score[game[i + 1]] = (1 << depth) + 1;
}
now++;
}
depth--;
swap(game, negame);
}
score[game[0]] = 2;
long long h1 = (magicalhash(score) + mod) % mod;
long long h2 = (h - h1 + mod) % mod;
if (mp.find(h2) != mp.end()) {
vi score1 = mp[h2];
for (int i = 0; i < nupto; i++) {
if (score[i] == -1) {
cout << score1[i] << " ";
} else {
cout << score[i] << " ";
}
}
cout << "\n";
exit(0);
}
}
};
f(0, 1);
f(1, 0);
cout << "-1\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[105];
signed main() {
int n;
cin >> n;
int sum = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
for (int k = 0; k <= 300; k++) {
bool ok = 1;
int tmp = 0;
for (int i = 1; i <= n; i++) {
if (a[i] > k) {
ok = 0;
break;
}
tmp += k - a[i];
}
if (tmp <= sum || ok == 0)
continue;
else {
cout << k;
return 0;
}
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;const int N=1e2+7;int T_T,n,m,i,j,x[N],y[N],flag;
int main(){
for(cin>>T_T;T_T--;){
for(cin>>n>>m,flag=0,i=1;i<=n;++i)cin>>x[i]>>y[i];
for(i=1;i<=n;++i){
for(j=1;j<=n;++j)if(j!=i&&abs(x[i]-x[j])+abs(y[i]-y[j])>m)break;
if(j==n+1)flag=1;
}
cout<<(flag?1:-1)<<endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
int n, m;
int x[N];
long long res;
int step;
vector<int> g[N];
int pos[N];
int used[N];
void update(int p, bool add) {
if (p < 1 || p >= m) return;
if (used[p] == step) return;
used[p] = step;
int val = abs(pos[x[p]] - pos[x[p + 1]]);
if (add)
res += val;
else
res -= val;
}
void proc(int x, bool add) {
for (int pos : g[x]) {
update(pos - 1, add);
update(pos, add);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d", &x[i]);
res = 0;
for (int i = 1; i <= n; i++) pos[i] = i;
for (int i = 1; i <= m; i++) g[x[i]].push_back(i);
for (int i = 1; i < m; i++) res += abs(pos[x[i]] - pos[x[i + 1]]);
cout << res << " ";
step = 0;
for (int i = 2; i <= n; i++) {
step++;
proc(i, 0);
proc(i - 1, 0);
step++;
swap(pos[i], pos[i - 1]);
proc(i, 1);
proc(i - 1, 1);
cout << res << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
char a[110];
int vis[110];
int main() {
int i, j, k, n = 0;
scanf("%s", a);
k = strlen(a);
for (i = 0; i < k - 1; i++) {
if (a[i] == 'V' && a[i + 1] == 'K') {
vis[i] = 1;
vis[i + 1] = 1;
n++;
}
}
for (i = 0; i < k - 1; i++) {
if (vis[i] == 0 && vis[i + 1] == 0) {
if (a[i] == 'V' && a[i + 1] == 'V') {
n++;
break;
}
if (a[i] == 'K' && a[i + 1] == 'K') {
n++;
break;
}
}
}
printf("%d\n", n);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> q(3);
cin >> q[0] >> q[1] >> q[2];
sort(q.begin(), q.end());
if (q[0] == 1)
cout << "YES" << endl;
else if (q[0] == 2 && q[1] == 2)
cout << "YES" << endl;
else if (q[0] == 2 && q[1] == 4 && q[2] == 4)
cout << "YES" << endl;
else if (q[0] == 3 && q[1] == 3 && q[2] == 3)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, it;
int sz[300030];
pair<int, int> ans;
vector<int> node;
struct Node {
int can[26];
int mx;
} bor[300030], t[300030];
void dfs(int v) {
sz[v]++;
for (int i = 0; i < 26; i++) {
int to = bor[v].can[i];
if (to == 0) continue;
dfs(to);
sz[v] += sz[to];
}
}
void update(int v, int w) {
for (int i = 0; i < 26; i++) {
if (!bor[w].can[i]) continue;
if (!t[v].can[i]) t[v].can[i] = ++it;
update(t[v].can[i], bor[w].can[i]);
}
}
void update_mx(int v, int w) {
for (int i = 0; i < 26; i++) {
if (!bor[w].can[i]) continue;
if (!t[v].can[i])
it += sz[bor[w].can[i]];
else
update_mx(t[v].can[i], bor[w].can[i]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i < n; i++) {
int x, y;
char c;
cin >> x >> y >> c;
bor[x].can[c - 'a'] = y;
}
dfs(1);
node.push_back(1);
for (int i = 1; i <= n; i++) {
int mx = 0;
for (int j = 0; j < 26; j++)
if (sz[bor[i].can[j]] > sz[bor[i].can[mx]]) mx = j;
bor[i].mx = mx;
}
int l = 0, r = 1;
for (int p = 0; p < n && node.size(); p++) {
int NewSize = 0;
for (int i = l; i < r; i++) {
int v = node[i];
for (int j = 0; j < 26; j++) {
if (!bor[v].can[j]) continue;
node.push_back(bor[v].can[j]);
if (j != bor[v].mx) update(0, bor[v].can[j]);
}
int it_mn = it;
update_mx(0, bor[v].can[bor[v].mx]);
NewSize += sz[v] - it - 1;
for (int q = 0; q < it_mn + 5; q++) {
for (int qq = 0; qq < 26; qq++) t[q].can[qq] = 0;
t[q].mx = 0;
}
it = 0;
}
l = r;
r = node.size();
if (NewSize > ans.first) {
ans.first = NewSize;
ans.second = p + 1;
}
}
cout << sz[1] - ans.first << endl << ans.second << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int g, w, gv[1001] = {}, wv[1001] = {}, s = 0, min;
scanf("%d%d", &g, &w);
for (int i = 1; i <= g; i++) scanf("%d", &gv[i]);
for (int j = 1; j <= w; j++) scanf("%d", &wv[j]);
for (int k = 1; k <= g; k++) {
if (wv[1] >= gv[1]) {
s++;
for (int m = 1; m <= w; m++) wv[m] = wv[m + 1];
}
for (int l = 1; l <= g; l++) gv[l] = gv[l + 1];
}
printf("%d", s);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double EPS = 1e-11;
void fast() { std::ios_base::sync_with_stdio(0); }
int n;
vector<int> arr;
string s;
vector<vector<int>> dp;
int calc(int i, int state) {
if (i == n) return 0;
int &ret = dp[i][state];
if (ret != -1) {
return ret;
}
if (state == 1) return ret = calc(i + 1, 1) + arr[i];
if (s[i] == '0') return ret = calc(i + 1, 0);
int x = calc(i + 1, 0) + arr[i];
int y = calc(i + 1, 1);
return ret = max(x, y);
}
int main() {
scanf("%d", &n);
arr.resize(n);
dp.resize(n);
for (int i = 0; i < n; i++) dp[i].resize(2, -1);
for (int &i : arr) scanf("%d", &i);
cin >> s;
reverse(arr.begin(), arr.end());
reverse(s.begin(), s.end());
printf("%d\n", calc(0, 0));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int i, j, k, n, m, p, q, t, d = 0, x, y;
cin >> n;
int a[n][4], b[n][2], c[n][2];
for (i = 0; i < n; i++) {
cin >> a[i][0] >> a[i][1] >> a[i][2] >> a[i][3];
}
for (i = n - 1; i >= 0; i--) {
if (i == n - 1) {
b[i][0] = a[i][0];
b[i][1] = a[i][2];
} else {
b[i][0] = max(b[i + 1][0], a[i][0]);
b[i][1] = min(b[i + 1][1], a[i][2]);
}
}
for (i = n - 1; i >= 0; i--) {
if (i == n - 1) {
c[i][0] = a[i][1];
c[i][1] = a[i][3];
} else {
c[i][0] = max(c[i + 1][0], a[i][1]);
c[i][1] = min(c[i + 1][1], a[i][3]);
}
}
int l1, r1, l2, r2;
for (i = 0; i < n; i++) {
if (i == 0) {
if (b[i + 1][0] <= b[i + 1][1] && c[i + 1][0] <= c[i + 1][1]) {
cout << b[i + 1][0] << " " << c[i + 1][0];
exit(0);
}
l1 = a[i][0];
r1 = a[i][2];
l2 = a[i][1];
r2 = a[i][3];
} else if (i == n - 1) {
if (l1 <= r1 && l2 <= r2) {
cout << l1 << " " << l2;
exit(0);
}
} else {
int x1, y1, x2, y2;
x1 = max(b[i + 1][0], l1);
y1 = min(b[i + 1][1], r1);
x2 = max(c[i + 1][0], l2);
y2 = min(c[i + 1][1], r2);
if (x1 <= y1 && x2 <= y2) {
cout << x1 << " " << x2;
exit(0);
}
l1 = max(a[i][0], l1);
r1 = min(a[i][2], r1);
l2 = max(a[i][1], l2);
r2 = min(a[i][3], r2);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int P = 31623;
const int MAXN = 1e5 + 5;
const int maxn = 1 << 21;
const int mod = 1e9 + 7;
const double PI = acos(-1.0);
long long n;
int k, fac[MAXN], Inv[MAXN], f[MAXN], g[MAXN], N, rev[maxn];
inline int qpow(int x, int k) {
int Ans = 1;
for (; k; k >>= 1, x = 1ll * x * x % mod)
if (k & 1) Ans = 1ll * Ans * x % mod;
return Ans;
}
struct Complex {
double x, r;
Complex() : x(0), r(0) {}
Complex(double x, double r) : x(x), r(r) {}
inline Complex operator+(const Complex &a) const {
return Complex(x + a.x, r + a.r);
}
inline Complex operator-(const Complex &a) const {
return Complex(x - a.x, r - a.r);
}
inline Complex operator*(const Complex &a) const {
return Complex(x * a.x - r * a.r, x * a.r + r * a.x);
}
} A[maxn], B[maxn], C[maxn], D[maxn], wn[maxn], ni[maxn];
inline void Init(int n) {
for (N = 1; N < (n << 1); N <<= 1)
;
for (int i = 0; i < N; ++i)
if (i & 1)
rev[i] = rev[i >> 1] >> 1 | (N >> 1);
else
rev[i] = rev[i >> 1] >> 1;
for (int i = 0; i <= N; ++i)
wn[i] = Complex(cos(2 * PI / N * i), sin(2 * PI / N * i)),
ni[i] = Complex(cos(2 * PI / N * i), -sin(2 * PI / N * i));
}
inline void fft(Complex *f, int type, Complex *wn) {
register Complex *l, *r, *w, t;
register int i, j, k, len;
for (i = 0; i < N; ++i)
if (i < rev[i]) std::swap(f[i], f[rev[i]]);
for (k = 2, len = N >> 1; k <= N; k <<= 1, len >>= 1)
for (j = 0; j < N; j += k) {
l = f + j, r = l + (k >> 1), w = wn;
for (i = 0; i < (k >> 1); ++i)
t = *r * *w, *r = *l - t, *l = *l + t, ++l, ++r, w += len;
}
if (type == -1)
for (i = 0; i < N; ++i) f[i].x /= N;
}
inline void FFT(int *a, int *b, int *Ans, int p) {
for (int i = 0; i < N; ++i)
A[i] = Complex(), B[i] = Complex(), C[i] = Complex(), D[i] = Complex();
int tot = 1;
for (int i = 0; i <= k; ++i) {
A[i].x = (1ll * a[i] * fac[k - i] % mod) / P;
B[i].x = (1ll * a[i] * fac[k - i] % mod) % P;
C[i].x = (1ll * (1ll * b[i] * fac[k - i] % mod) * tot % mod) / P;
D[i].x = (1ll * (1ll * b[i] * fac[k - i] % mod) * tot % mod) % P;
tot = 1ll * tot * p % mod;
}
fft(A, 1, wn), fft(B, 1, wn), fft(C, 1, wn), fft(D, 1, wn);
for (int i = 0; i < N; ++i) {
register Complex Ai = A[i], Bi = B[i], Ci = C[i], Di = D[i];
A[i] = Ai * Ci, B[i] = Ai * Di + Bi * Ci, C[i] = Bi * Di;
}
fft(A, -1, ni), fft(B, -1, ni), fft(C, -1, ni);
for (int i = 0; i <= k; ++i) {
Ans[i] = (((long long)round(A[i].x) % mod * P % mod * P % mod +
(long long)round(B[i].x) % mod * P % mod) %
mod +
(long long)round(C[i].x) % mod) %
mod;
Ans[i] = 1ll * Ans[i] * Inv[k] % mod * Inv[k - i] % mod;
}
}
inline int Comb(int n, int m) {
if (n == m || !m) return 1;
if (n < m) return 0;
return 1ll * fac[n] * Inv[n - m] % mod * Inv[m] % mod;
}
int main() {
scanf("%lld%d", &n, &k);
if (n > k) return puts("0"), 0;
fac[0] = 1;
Inv[0] = 1;
for (int i = 1; i <= k; ++i) fac[i] = 1ll * fac[i - 1] * i % mod;
Inv[k] = qpow(fac[k], mod - 2);
for (int i = k - 1; i; --i) Inv[i] = 1ll * Inv[i + 1] * (i + 1) % mod;
for (int i = 1; i <= k; ++i) g[i] = Comb(k, i);
f[0] = 1;
Init(k + 1);
int t = 2;
for (; n; n >>= 1, FFT(g, g, g, t), t = 1ll * t * t % mod)
if (n & 1) FFT(g, f, f, t);
int Ans = 0;
for (int i = 0; i <= k; ++i) (Ans += f[i]) %= mod;
printf("%d\n", Ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<int> u;
vector<vector<int>> edge;
long long ans = 0;
int k;
long long dfs(int v, int p) {
long long c = u[v];
for (int i = 0; i < edge[v].size(); ++i)
if (edge[v][i] != p) {
long long x = dfs(edge[v][i], v);
c += x;
ans += min(x, (long long)2 * k - x);
}
return c;
}
int main() {
int n;
cin >> n >> k;
edge.resize(n);
u.resize(n);
for (int i = 0; i < 2 * k; ++i) {
int c;
cin >> c;
u[c - 1] = 1;
}
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
edge[u].push_back(v);
edge[v].push_back(u);
}
dfs(0, -1);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, r;
cin >> n >> r;
vector<int> arr(n);
for (auto &i : arr) cin >> i;
vector<pair<double, int> > records[1001];
for (int i = 0; i < n; ++i) {
double y = r;
for (int x = max(1, arr[i] - 2 * r); x <= min(1000, arr[i] + 2 * r); ++x)
if (records[x].size() > 0) {
y = max(y, records[x].back().first +
sqrt((double)(4 * r * r - (arr[i] - x) * (arr[i] - x))));
}
records[arr[i]].push_back(make_pair(y, i));
}
vector<double> ans(n, 0);
for (int i = 1; i < 1001; ++i)
for (auto j : records[i]) ans[j.second] = j.first;
cout << fixed << setprecision(10);
for (auto i : ans) cout << i << ' ';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int NIL = -1;
template <class T>
inline T mx(T a, T b) {
return a > b ? a : b;
}
template <class T>
inline T mi(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline void sw(T &a, T &b) {
T t = a;
a = b;
b = t;
}
template <class T>
inline T mabs(T x) {
return x < 0 ? -x : x;
}
inline char gc() {
char ret;
while ((ret = getchar()) == ' ' || ret == '\n' || ret == '\t')
;
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
string str[2];
cin >> str[0] >> str[1];
string u, v;
int n;
cin >> n;
cout << str[0] << ' ' << str[1] << '\n';
while (n--) {
cin >> u >> v;
for (int i = 0; i < 2; i++) {
if (str[i] == u) str[i] = v;
}
cout << str[0] << ' ' << str[1] << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
if (a % b == 0) {
cout << 0 << endl;
} else {
cout << b - a % b << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> A;
int n;
vector<int> order;
vector<vector<int>> dist;
int p[300][300];
vector<int> ans;
void dfs(int start, int parent, int orig) {
for (int i = 0; i < A[start].size(); i++) {
int where = A[start][i];
if (where != parent) {
dist[orig][where] = dist[orig][start] + 1;
p[orig][where] = start;
dfs(where, start, orig);
}
}
}
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
A = vector<vector<int>>(n);
for (long long int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
A[a].push_back(b);
A[b].push_back(a);
}
int x = 0;
vector<int> leaf;
for (long long int i = 1; i < n; i++) {
if (A[i].size() == 1) {
x++;
}
}
while (x--) {
int y;
cin >> y;
order.push_back(--y);
}
dist = vector<vector<int>>(n, vector<int>(n, 0));
for (long long int i = 0; i < n; i++) {
p[i][i] = -1;
dfs(i, -1, i);
}
int start = 0;
int val = 0;
for (long long int i = 0; i < order.size(); i++) {
val += dist[start][order[i]];
start = order[i];
}
val += dist[order[order.size() - 1]][0];
if (val != 2 * n - 2) {
cout << "-1\n";
exit(0);
} else {
order.insert(order.begin(), 0);
order.push_back(0);
start = 0;
cout << "1 ";
for (long long int i = 1; i < order.size(); i++) {
start = order[i];
int where = order[i - 1];
vector<int> temp;
while (start != where) {
temp.push_back(start);
start = p[where][start];
}
reverse(temp.begin(), temp.end());
for (long long int i = 0; i < temp.size(); i++) {
cout << temp[i] + 1 << " ";
}
}
cout << endl;
}
return (0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int isSubsequence(char *a, char *b) {
while (*b != '\0') {
if (*a == '\0') return 0;
if (*a == *b) {
a++;
b++;
} else
a++;
}
return 1;
}
int main() {
char a[105], b[105];
int len1, len2, i;
scanf("%s", a);
scanf("%s", b);
len1 = strlen(a);
len2 = strlen(b);
if (len1 == len2) {
sort(a, a + len1);
sort(b, b + len2);
if (strcmp(a, b) == 0)
printf("array");
else
printf("need tree");
} else {
if (isSubsequence(a, b))
printf("automaton");
else {
sort(a, a + len1);
sort(b, b + len2);
if (isSubsequence(a, b))
printf("both");
else
printf("need tree");
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f *= -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
inline char gchar() {
char s = getchar();
while (s != 'X' && s != '.') s = getchar();
return s;
}
int n = read(), m = read(), d[8][2] = {{0, -1}, {-1, -1}, {-1, 0}, {-1, 1},
{0, 1}, {1, 1}, {1, 0}, {1, -1}};
int main() {
bool p[n + 5][m + 5], h[n + 5][m + 5], l[n + 5][m + 5], e[n + 5][m + 5],
f[n + 5][m + 5];
int v[n + 5][m + 5];
memset(p, 0, sizeof(p));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (gchar() == 'X') p[i][j] = 1;
h[i][j] = l[i][j] = e[i][j] = f[i][j] = 0;
}
}
int s = min(n, m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (p[i][j] && !h[i][j]) {
if (!p[i][j - 1]) {
int len;
for (len = 1; j + len - 1 < m; len++) {
h[i][j + len - 1] = 1;
if (!p[i][j + len]) break;
}
s = min(len, s);
j += len;
}
}
}
}
for (int j = 1; j <= m; j++) {
for (int i = 1; i <= n; i++) {
if (p[i][j] && !l[i][j]) {
if (!p[i - 1][j]) {
int len;
for (len = 1; i + len - 1 < n; len++) {
l[i + len - 1][j] = 1;
if (!p[i + len][j]) break;
}
s = min(len, s);
i += len;
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (p[i][j] && !e[i][j]) {
if (!p[i - 1][j - 1] && !p[i][j - 1] && !p[i - 1][j]) {
int len;
for (len = 1; j + len - 1 < m && i + len - 1 < n; len++) {
e[i + len - 1][j + len - 1] = 1;
if (!p[i + len][j + len]) break;
}
s = min(len, s);
}
if (!p[i + 1][j + 1] && !p[i + 1][j] && !p[i][j + 1]) {
int len;
for (len = 1; j - len > 0 && i - len > 0; len++) {
e[i - len + 1][j - len + 1] = 1;
if (!p[i - len][j - len]) break;
}
s = min(len, s);
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = m; j > 0; j--) {
if (p[i][j] && !f[i][j]) {
if (!p[i - 1][j + 1] && !p[i][j + 1] && !p[i - 1][j]) {
int len;
for (len = 1; j - len > 0 && i + len - 1 < n; len++) {
f[i + len - 1][j - len + 1] = 1;
if (!p[i + len][j - len]) break;
}
s = min(len, s);
}
if (!p[i + 1][j - 1] && !p[i][j - 1] && !p[i + 1][j]) {
int len;
for (len = 1; j + len - 1 < m && i - len > 0; len++) {
f[i - len + 1][j + len - 1] = 1;
if (!p[i - len][j + len]) break;
}
s = min(len, s);
}
}
}
}
int t = (s - 1) >> 1;
printf("%d\n", t);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (p[i][j]) v[i][j] = max(n, m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (p[i][j]) {
for (int k = 0; k < 4; k++) {
if (!p[i + d[k][0]][j + d[k][1]])
v[i][j] = min(v[i][j], 1);
else
v[i][j] = min(v[i][j], v[i + d[k][0]][j + d[k][1]] + 1);
}
}
}
for (int i = n; i > 0; i--)
for (int j = m; j > 0; j--) {
if (p[i][j]) {
for (int k = 4; k < 8; k++) {
if (!p[i + d[k][0]][j + d[k][1]])
v[i][j] = min(v[i][j], 1);
else
v[i][j] = min(v[i][j], v[i + d[k][0]][j + d[k][1]] + 1);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!p[i][j])
putchar('.');
else if (v[i][j] <= t)
putchar('.');
else
putchar('X');
}
putchar('\n');
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x;
int count1 = 0;
cin >> n >> x;
if (x == 1) {
cout << 1;
return 0;
}
if (x <= n) count1 = 2;
for (int i = 2; i <= n && i < x; i++)
if (x % i == 0 && i * n >= x) count1++;
cout << count1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n;
int i;
int main() {
cin >> s;
n = s.length();
int vt;
for (i = n - 1; i >= 0; i--)
if (s[i] == '#') {
vt = i;
break;
}
int hieu = 0, dem = 0;
for (i = 0; i < n; i++) {
if (s[i] == '#') dem++;
if (s[i] == '(')
hieu++;
else
hieu--;
if (hieu < 0) {
cout << -1;
return (0);
}
}
int hieucu = hieu;
hieu = 0;
for (i = 0; i < n; i++) {
if (s[i] == '(')
hieu++;
else
hieu--;
if (i == vt) hieu -= hieucu;
if (hieu < 0) {
cout << -1;
return (0);
}
}
for (i = 1; i < dem; i++) cout << 1 << endl;
cout << hieucu + 1 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e2 + 10;
const long long mod = 1e9 + 7;
mt19937 mtrand(time(0));
int n, m;
char s[mx][mx];
int a[mx][mx];
int c[mx][mx];
vector<pair<int, int> > vec;
struct Node {
int x1, y1, x2, y2, x3, y3;
};
vector<Node> ans;
void out(int x1, int y1, int x2, int y2, int x3, int y3) {
a[x1][y1] ^= 1;
a[x2][y2] ^= 1;
a[x3][y3] ^= 1;
ans.push_back(Node{x1, y1, x2, y2, x3, y3});
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= m; ++j) {
a[i][j] = s[i][j] - '0';
}
}
int nn = n / 2 * 2, mm = m / 2 * 2;
for (int i = nn + 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (a[i][j] == 1) {
if (j != m) {
out(i, j, i - 1, j, i - 1, j + 1);
} else {
out(i, j, i - 1, j, i - 1, j - 1);
}
}
}
}
for (int i = mm + 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
if (a[j][i] == 1) {
if (j != 1) {
out(j, i, j, i - 1, j - 1, i - 1);
} else {
out(j, i, j, i - 1, j + 1, i - 1);
}
}
}
}
for (int i = 1; i <= nn; i += 2) {
for (int j = 1; j <= mm; j += 2) {
int cnt = 0;
for (int k = 0; k < 2; ++k) {
for (int kk = 0; kk < 2; ++kk) {
cnt += a[i + k][j + kk];
}
}
if (cnt == 2) {
int fg = 1;
vec.clear();
for (int k = 0; k < 2; ++k) {
for (int kk = 0; kk < 2; ++kk) {
if (a[i + k][j + kk] == 1)
vec.push_back(make_pair(i + k, j + kk));
else if (fg)
vec.push_back(make_pair(i + k, j + kk)), fg = 0;
}
}
out(vec[0].first, vec[0].second, vec[1].first, vec[1].second,
vec[2].first, vec[2].second);
cnt = 1;
} else if (cnt == 4) {
out(i, j, i + 1, j, i, j + 1);
out(i + 1, j + 1, i + 1, j, i, j + 1);
out(i, j, i, j + 1, i + 1, j + 1);
out(i, j, i + 1, j, i + 1, j + 1);
} else if (cnt == 3) {
if (a[i][j] == 0)
out(i + 1, j + 1, i + 1, j, i, j + 1);
else if (a[i + 1][j + 1] == 0)
out(i, j, i + 1, j, i, j + 1);
else if (a[i][j + 1] == 0)
out(i, j, i + 1, j, i + 1, j + 1);
else
out(i, j, i, j + 1, i + 1, j + 1);
}
if (cnt == 1) {
if (a[i][j] == 1) {
out(i, j, i + 1, j, i + 1, j + 1);
out(i, j, i, j + 1, i + 1, j + 1);
out(i, j, i, j + 1, i + 1, j);
} else if (a[i + 1][j + 1] == 1) {
out(i, j, i + 1, j, i + 1, j + 1);
out(i, j, i, j + 1, i + 1, j + 1);
out(i + 1, j + 1, i, j + 1, i + 1, j);
} else if (a[i + 1][j] == 1) {
out(i, j, i + 1, j, i, j + 1);
out(i + 1, j + 1, i + 1, j, i, j + 1);
out(i, j, i + 1, j, i + 1, j + 1);
} else {
out(i, j, i + 1, j, i, j + 1);
out(i + 1, j + 1, i + 1, j, i, j + 1);
out(i, j, i, j + 1, i + 1, j + 1);
}
}
}
}
printf("%d\n", ans.size());
for (Node &it : ans) {
printf("%d %d %d %d %d %d\n", it.x1, it.y1, it.x2, it.y2, it.x3, it.y3);
c[it.x1][it.y1] ^= 1;
c[it.x2][it.y2] ^= 1;
c[it.x3][it.y3] ^= 1;
}
ans.clear();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 987654321;
const int MOD = 1000000007;
int N, K;
int A[200005];
vector<int> adj[200005];
int siz[200005], sum[200005], len[200005];
int sub[200005], dp[200005];
void dfs(int n, int par, int mid) {
siz[n] = 1;
for (int nxt : adj[n]) {
if (nxt != par) {
dfs(nxt, n, mid);
siz[n] += siz[nxt];
if (siz[nxt] == sub[nxt])
sum[n] += sub[nxt];
else
len[n] = max(len[n], sub[nxt]);
}
}
sub[n] = sum[n] + len[n] + 1;
if (A[n] < mid) sub[n] = 0;
}
void dfs2(int n, int par, int par_sub, int mid) {
if (par_sub == N - siz[n])
dp[n] = sum[n] + par_sub + len[n] + 1;
else
dp[n] = sum[n] + max(len[n], par_sub) + 1;
if (A[n] < mid) dp[n] = 0;
int cnt = adj[n].size();
vector<int> l_sum(cnt + 2);
vector<int> l_len(cnt + 2);
for (int i = 1; i <= cnt; i++) {
int nxt = adj[n][i - 1];
l_sum[i] = l_sum[i - 1];
l_len[i] = l_len[i - 1];
if (nxt != par) {
if (siz[nxt] == sub[nxt])
l_sum[i] += sub[nxt];
else
l_len[i] = max(l_len[i], sub[nxt]);
}
}
vector<int> r_sum(cnt + 2);
vector<int> r_len(cnt + 2);
for (int i = cnt; i >= 1; i--) {
int nxt = adj[n][i - 1];
r_sum[i] = r_sum[i + 1];
r_len[i] = r_len[i + 1];
if (nxt != par) {
if (siz[nxt] == sub[nxt])
r_sum[i] += sub[nxt];
else
r_len[i] = max(r_len[i], sub[nxt]);
}
}
for (int i = 1; i <= cnt; i++) {
int nxt = adj[n][i - 1];
if (nxt != par) {
int nxt_par_sub = 0;
int p_sum = l_sum[i - 1] + r_sum[i + 1];
int p_len = max(l_len[i - 1], r_len[i + 1]);
if (par_sub == N - siz[n])
nxt_par_sub = p_sum + par_sub + p_len + 1;
else
nxt_par_sub = p_sum + max(p_len, par_sub) + 1;
if (A[n] < mid) nxt_par_sub = 0;
dfs2(nxt, n, nxt_par_sub, mid);
}
}
}
bool foo(int mid) {
memset(siz, 0, sizeof(siz));
memset(sum, 0, sizeof(sum));
memset(len, 0, sizeof(len));
memset(sub, 0, sizeof(sub));
memset(dp, 0, sizeof(dp));
dfs(1, 0, mid);
dfs2(1, 0, 0, mid);
int best = 0;
for (int i = 1; i <= N; i++) best = max(best, dp[i]);
return best >= K;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> K;
for (int i = 1; i <= N; i++) cin >> A[i];
for (int i = 0; i < N - 1; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
int lo = 0, hi = 1000005;
while (lo + 1 < hi) {
int mid = (lo + hi) / 2;
if (foo(mid))
lo = mid;
else
hi = mid;
}
cout << lo << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string str;
int dp;
int cp;
int ans[10];
void solve() {
int i = cp;
while (i >= 0 && i < str.size()) {
if (str[i] <= '9' && str[i] >= '0') {
ans[str[i] - '0']++;
if (str[i] == '0') {
str = str.substr(0, i) + str.substr(i + 1);
if (dp < 0) i += dp;
} else {
str[i]--;
i += dp;
}
} else if (str[i] == '<') {
dp = -1;
if (i + dp < 0 || i + dp >= str.size()) break;
if (str[i + dp] == '<' || str[i + dp] == '>')
str = str.substr(0, i) + str.substr(i + 1);
i += dp;
} else if (str[i] == '>') {
dp = 1;
if (i + dp < 0 || i + dp >= str.size()) break;
if (str[i + dp] == '<' || str[i + dp] == '>') {
str = str.substr(0, i) + str.substr(i + 1);
} else {
i += dp;
}
}
}
}
int main() {
int n, q;
cin >> n >> q;
string cmd;
cin >> cmd;
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
memset(ans, 0, sizeof ans);
str = cmd.substr(l - 1, r - l + 1);
dp = 1;
cp = 0;
solve();
for (int i = 0; i < 10; i++) cout << ans[i] << " ";
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
vector<int> v(n + 9);
int mn = INT_MAX;
for (int i = 0; i < (n); i++) {
int x;
cin >> x;
v[i] = x;
;
mn = min(mn, x);
}
int lI = 0;
bool f = 1;
int ans = 1000000009;
for (int i = 0; i < (n); i++) {
if (v[i] == mn) {
if (f) {
lI = i;
f = 0;
} else {
ans = min(ans, i - lI);
lI = i;
}
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
char s[200010];
int c[65536];
unsigned a[32][200010], b[32][200010];
int cnt(unsigned x) { return c[x >> 16] + c[x & 65535]; }
int main() {
int m, i, j, x, y, l, r;
scanf("%s", s);
for (j = 0; j < 32; j++) {
for (i = 0; s[j + i]; i++)
a[j][i >> 5] |= s[j + i] == '1' ? 1 << (i & 31) : 0;
}
scanf("%s", s);
for (j = 0; j < 32; j++) {
for (i = 0; s[j + i]; i++)
b[j][i >> 5] |= s[j + i] == '1' ? 1 << (i & 31) : 0;
}
for (i = 0; i < 65536; i++) c[i] = c[i >> 1] + (i & 1);
scanf("%d", &m);
while (m--) {
scanf("%d%d%d", &x, &y, &l);
r = 0;
for (i = x >> 5, j = y >> 5; l > 31; i++, j++, l -= 32)
r += cnt(a[x & 31][i] ^ b[y & 31][j]);
r += cnt((a[x & 31][i] ^ b[y & 31][j]) & ((1 << l) - 1));
printf("%d\n", r);
}
}
| 10 |
#include <bits/stdc++.h>
const int N = 5e5 + 10, Nt = 1 << 20;
const long long inf = 1e18;
int ri() {
char c = getchar();
int x = 0, f = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) - '0' + c;
return x * f;
}
int l[N], r[N], pr[N], nx[N], w[N], m, n, Q;
long long T[Nt], ans[N], D[N];
struct Data {
int l, r, id;
};
std::vector<Data> q[N];
void Dfs1(int u) {
l[u] = r[u] = u;
for (int i = pr[u]; i; i = nx[i]) {
D[i] = D[u] + w[i];
Dfs1(i);
l[u] = std::min(l[u], l[i]);
r[u] = std::max(r[u], r[i]);
}
if (!pr[u])
T[u + m] = D[u];
else
T[u + m] = inf;
}
void Up(int s) {
long long A = std::min(T[s], T[s ^ 1]);
T[s] -= A;
T[s ^ 1] -= A;
T[s >> 1] += A;
}
void Add(int s, int t, int x) {
if (s > t) return;
s += m, t += m;
if (s == t) {
for (T[s] += x; s > 1; s >>= 1) Up(s);
return;
}
for (T[s] += x, T[t] += x; s ^ t ^ 1; s >>= 1, t >>= 1) {
if (~s & 1) T[s ^ 1] += x;
if (t & 1) T[t ^ 1] += x;
Up(s);
Up(t);
}
for (; s > 1; s >>= 1) Up(s);
}
long long Query(int s, int t) {
long long l = 0, r = 0;
if (s == t) {
for (s += m; s; s >>= 1) l += T[s];
return l;
}
for (s += m, t += m; s ^ t ^ 1; s >>= 1, t >>= 1) {
l += T[s];
r += T[t];
if (~s & 1) l = std::min(l, T[s ^ 1]);
if (t & 1) r = std::min(r, T[t ^ 1]);
}
l = std::min(l + T[s], r + T[t]);
for (; s >>= 1;) l += T[s];
return l;
}
void Dfs2(int u) {
for (Data x : q[u]) ans[x.id] = Query(x.l, x.r);
for (int i = pr[u]; i; i = nx[i]) {
Add(l[i], r[i], -w[i]);
Add(1, l[i] - 1, w[i]);
Add(r[i] + 1, n, w[i]);
Dfs2(i);
Add(l[i], r[i], w[i]);
Add(1, l[i] - 1, -w[i]);
Add(r[i] + 1, n, -w[i]);
}
}
int main() {
n = ri();
Q = ri();
for (m = 1; m <= n + 1; m <<= 1)
;
for (int i = 2, u; i <= n; ++i)
u = ri(), nx[i] = pr[u], pr[u] = i, w[i] = ri();
Dfs1(1);
for (int i = m - 1; i; --i)
T[i] = std::min(T[i << 1], T[i << 1 | 1]), T[i << 1] -= T[i],
T[i << 1 | 1] -= T[i];
for (int i = 1; i <= Q; ++i) {
int v = ri(), l = ri(), r = ri();
q[v].push_back((Data){l, r, i});
}
Dfs2(1);
for (int i = 1; i <= Q; ++i) printf("%lld\n", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main()
{
ll t;
cin>>t;
while(t--)
{
ll n;
cin>>n;
ll c[n];
for (int i = 0; i < n; ++i)
{
/* code */
scanf("%lld", &c[i]);
}
ll ans1 = LLONG_MAX, ans2 = LLONG_MAX;
ll ans = LLONG_MAX;
ll oddsum = 0 , evensum = 0;
// ll i1 = -1, i2 = -1;
// ll min1 = 0;
// vector<ll> dp(n,0);
// dp[0]
for (int i = 0; i < n; i++)
{
ll k = 0;
ll u1 = 1, u2 = 1;
if(i&1)
{
evensum += c[i];
ans1 = min(ans1,c[i]);
u1 = 0;
}
else
{
oddsum += c[i];
ans2 = min(ans2,c[i]);
u2 = 0;
}
k = evensum + (n-(i-1)/2-1)*ans1 + oddsum + (n-(i)/2-1)*ans2;
if(i>=1)
ans = min(ans,k);
// prev = k;
}
cout<<ans<<endl;
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 2e3 + 100;
const int base = 2000;
const int s = maxn - 2, t = maxn - 1;
const int inf = 1e9 + 100;
int head[maxn];
pair<int, int> ori[maxn];
int cnt = 1;
struct gg {
int u, v, w, idx, next;
} side[maxn * 4];
void ins(int u, int v, int w, int idx) {
side[++cnt] = (gg){u, v, w, idx, head[u]};
head[u] = cnt;
side[++cnt] = (gg){v, u, 0, idx, head[v]};
head[v] = cnt;
}
int d[maxn];
vector<vector<int> > ans;
int cur[maxn], rk[maxn];
queue<int> q;
bool bfs() {
memset(rk, 0, sizeof(rk));
while (!q.empty()) q.pop();
q.push(s);
rk[s] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = side[i].next) {
int v = side[i].v;
if (rk[v] || !side[i].w) continue;
rk[v] = rk[u] + 1;
q.push(v);
}
}
if (rk[t]) return 1;
return 0;
}
int dfs(int u, int flow) {
if (u == t || !flow) return flow;
int tot = 0;
for (int &i = cur[u]; i; i = side[i].next) {
int v = side[i].v;
if (side[i].w <= 0 || rk[v] != rk[u] + 1) continue;
int sent = dfs(v, min(flow, side[i].w));
flow -= sent, tot += sent;
side[i].w -= sent, side[i ^ 1].w += sent;
if (!flow) break;
}
return tot;
}
void dinic() {
while (bfs()) {
memcpy(cur, head, sizeof(head));
dfs(s, inf);
}
}
int n1, n2, m;
void debug() {
for (int i = (1), iend = (n1); i <= iend; i++)
for (int j = head[i]; j; j = side[j].next)
cout << ">>" << side[j].u << ' ' << side[j].v << ' ' << side[j].w << endl;
for (int i = (1), iend = (n2); i <= iend; i++)
for (int j = head[i + base]; j; j = side[j].next)
cout << ">>" << side[j].u << ' ' << side[j].v << ' ' << side[j].w << endl;
for (int j = head[s]; j; j = side[j].next)
cout << ">>" << side[j].u << ' ' << side[j].v << ' ' << side[j].w << endl;
cout << "END" << endl;
}
int main() {
ios::sync_with_stdio(0);
cin >> n1 >> n2 >> m;
int mi_d = 1e9, mx_d = 0;
for (int i = (1), iend = (m); i <= iend; i++) {
int u, v;
cin >> u >> v;
ori[i] = make_pair(u, v);
d[u]++, d[v + base]++;
ins(u, v + base, 1, i);
}
for (int i = (1), iend = (n1); i <= iend; i++)
mi_d = min(mi_d, d[i]), mx_d = max(mx_d, d[i]);
for (int i = (1), iend = (n2); i <= iend; i++)
mi_d = min(mi_d, d[i + base]), mx_d = max(mx_d, d[i + base]);
for (int i = (1), iend = (n1); i <= iend; i++) {
ins(s, i, d[i] - mi_d - 1, 0);
}
for (int i = (1), iend = (n2); i <= iend; i++) {
ins(i + base, t, d[i + base] - mi_d - 1, 0);
}
for (int k = mi_d; k >= 0; k--) {
for (int i = head[s]; i; i = side[i].next) {
if (!side[i].idx) side[i].w++;
}
for (int i = (1), iend = (n2); i <= iend; i++) {
for (int j = head[i + base]; j; j = side[j].next) {
int v = side[j].v;
if (!side[j].idx && v == t) side[j].w++;
}
}
dinic();
vector<int> tmp;
vector<int> jk;
for (int gg = (base + 1), ggend = (base + n2); gg <= ggend; gg++)
for (int i = head[gg]; i; i = side[i].next)
if (side[i].idx && side[i].v <= n1 && side[i].w)
tmp.push_back(side[i].idx);
sort(tmp.begin(), tmp.end());
int now = 0;
for (int i = (1), iend = (m); i <= iend; i++) {
if (now < tmp.size() && tmp[now] == i) {
now++;
continue;
}
jk.push_back(i);
}
ans.push_back(jk);
}
for (int i = ans.size() - 1; i >= 0; i--) {
vector<int> tmp = ans[i];
cout << tmp.size() << ' ';
for (int j = (0), jend = (tmp.size() - 1); j <= jend; j++)
cout << tmp[j] << ' ';
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n = 0, s = 0, t = 0, x = 0, i = 0, next = 0;
cin >> n >> s >> t;
map<long long int, long long int> p;
for (i = 1; i <= n; i++) {
cin >> x;
p[i] = x;
}
next = s;
long long int flag = 0, ans = 0;
for (i = 0; i < n; i++) {
if (next == t) {
flag = 1;
ans = i;
break;
}
next = p[next];
}
if (flag == 0) {
cout << -1;
} else {
cout << ans;
}
cout << "\n";
;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int h[1100];
int mx = 0;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> h[i];
if (n == 1) {
cout << 1;
return 0;
}
int cnt;
for (int i = 0; i < n; i++) {
cnt = 0;
int j = i - 1;
while (j >= 0 && h[j] <= h[j + 1]) {
cnt++;
j--;
}
j = i + 1;
while (j < n && h[j] <= h[j - 1]) {
cnt++;
j++;
}
if (cnt > mx) mx = cnt;
}
cout << mx + 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, c;
cin >> n >> c;
long long answ = 1;
long long a[n + 1];
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 2; i <= n; i++)
if (a[i] - a[i - 1] <= c)
answ++;
else
answ = 1;
cout << answ << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double x, y;
cin >> x >> y;
if ((long double)y * log(x) < (long double)x * log(y))
cout << "<";
else if ((long double)y * log(x) > (long double)x * log(y))
cout << ">";
else
cout << "=";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
string s1, s2;
cin >> s1 >> s2;
if (s1.length() > s2.length()) {
cout << "NO" << endl;
continue;
}
sort(s1.begin(), s1.end());
int len = s1.length();
int fg = 0;
for (int i = 0; i < s2.length() - len + 1; i++) {
string temp = s2.substr(i, len);
sort(temp.begin(), temp.end());
if (temp == s1) {
fg = 1;
break;
}
}
if (fg == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; ++i) {
cin >> a[i];
}
for (long long i = 0; i < n; ++i) {
if (i < n / 2) {
cout << -a[n - i - 1] << ' ';
} else {
cout << a[n - i - 1] << ' ';
}
}
cout << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 0, temp = 0;
int n, x;
cin >> n >> x;
int l[n], r[n];
for (int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
int sum = 0;
while (1) {
t = t + x;
if (t >= l[i]) {
t = t - x;
sum += r[i] - t;
t += sum;
temp += sum;
break;
}
}
}
cout << temp;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200000 + 2;
const int Mod = (int)1e9 + 7;
int n, P[MAX];
char a[MAX];
long long power(long long a, long long b) {
long long k = 1;
for (; b; b /= 2, a = a * a % Mod)
if (b % 2 == 1) k = k * a % Mod;
return k;
}
int main() {
int i, k;
scanf("%s", a + 1);
scanf("%d", &k);
n = strlen(a + 1);
P[0] = 1;
for ((i) = (1); (i) != (MAX); ++(i)) P[i] = P[i - 1] * 2 % Mod;
int ans = 0;
long long c = power(P[n], k);
long long d = power((P[n] - 1 + Mod) % Mod, Mod - 2);
for ((i) = (1); (i) <= (n); ++(i))
if (a[i] == '0' || a[i] == '5') {
long long t = (long long)P[i - 1] * (c - 1 + Mod) % Mod * d % Mod;
ans = (ans + t) % Mod;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int sub2(long long int n) { return (n + 3 * n * n) / 2; }
int main() {
long long int t;
cin >> t;
vector<long long int> ans;
while (t--) {
long long int k;
cin >> k;
long long int m = 0;
while (k >= 2) {
long long int i = floor((sqrt(1 + 24 * k) - 1) / 6.0);
k = k - sub2(i);
m++;
}
ans.push_back(m);
}
for (long long int k = 0; k < ans.size(); k++) cout << ans[k] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e6 + 5;
const int M = 7;
vector<int> lp, primes, pi;
int phi[MAX + 1][M + 1], sz[M + 1];
void factor_sieve() {
lp.resize(MAX);
pi.resize(MAX);
lp[1] = 1;
pi[0] = pi[1] = 0;
for (int i = 2; i < MAX; i++) {
if (lp[i] == 0) {
lp[i] = i;
primes.emplace_back(i);
}
for (int j = 0; j < primes.size() && primes[j] <= lp[i]; j++) {
int x = i * primes[j];
if (x >= MAX) break;
lp[x] = primes[j];
}
pi[i] = primes.size();
}
}
void init() {
factor_sieve();
for (int i = 0; i <= MAX; i++) {
phi[i][0] = i;
}
sz[0] = 1;
for (int i = 1; i <= M; i++) {
sz[i] = primes[i - 1] * sz[i - 1];
for (int j = 1; j <= MAX; j++) {
phi[j][i] = phi[j][i - 1] - phi[j / primes[i - 1]][i - 1];
}
}
}
int sqrt2(long long x) {
long long r = sqrt(x - 0.1);
while (r * r <= x) ++r;
return r - 1;
}
int cbrt3(long long x) {
long long r = cbrt(x - 0.1);
while (r * r * r <= x) ++r;
return r - 1;
}
long long getphi(long long x, int s) {
if (s == 0) return x;
if (s <= M) {
return phi[x % sz[s]][s] + (x / sz[s]) * phi[sz[s]][s];
}
if (x <= primes[s - 1] * primes[s - 1]) {
return pi[x] - s + 1;
}
if (x <= primes[s - 1] * primes[s - 1] * primes[s - 1] && x < MAX) {
int sx = pi[sqrt2(x)];
long long ans = pi[x] - (sx + s - 2) * (sx - s + 1) / 2;
for (int i = s + 1; i <= sx; ++i) {
ans += pi[x / primes[i - 1]];
}
return ans;
}
return getphi(x, s - 1) - getphi(x / primes[s - 1], s - 1);
}
long long getpi(long long x) {
if (x < MAX) return pi[x];
int cx = cbrt3(x), sx = sqrt2(x);
long long ans = getphi(x, pi[cx]) + pi[cx] - 1;
for (int i = pi[cx] + 1, ed = pi[sx]; i <= ed; i++) {
ans -= getpi(x / primes[i - 1 - 1]) - i + 1;
}
return ans;
}
long long lehmer_pi(long long x) {
if (x < MAX) return pi[x];
int a = (int)lehmer_pi(sqrt2(sqrt2(x)));
int b = (int)lehmer_pi(sqrt2(x));
int c = (int)lehmer_pi(cbrt3(x));
long long sum = getphi(x, a) + (long long)(b + a - 2) * (b - a + 1) / 2;
for (int i = a + 1; i <= b; i++) {
long long w = x / primes[i - 1];
sum -= lehmer_pi(w);
if (i > c) continue;
long long lim = lehmer_pi(sqrt2(w));
for (int j = i; j <= lim; j++) {
sum -= lehmer_pi(w / primes[j - 1]) - (j - 1);
}
}
return sum;
}
long long power(long long a, long long b) {
long long x = 1, y = a;
while (b) {
if (b & 1) x = x * y;
y = y * y;
b >>= 1;
}
return x;
}
void solve(long long n) {
long long ans = 0;
for (int i = 0; i < (int)primes.size(); i++) {
if (power(primes[i], 3) <= n) {
ans += 1;
} else {
break;
}
}
long long cnt = 0;
long long q = 0;
for (int i = 0; i < (int)primes.size(); i++) {
long long x = (long long)primes[i];
q = n / x;
if (q <= x) continue;
if (q == 0) continue;
cnt = lehmer_pi(q);
if (q >= primes[i]) {
cnt -= lehmer_pi(x);
}
if (cnt <= 0) break;
ans += cnt;
}
std::cout << ans << '\n';
}
int main(int argc, char const *argv[]) {
long long n;
init();
std::cin >> n;
solve(n);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> par;
void make_par(long long szz) {
for (long long i = 0; i < szz; i++) {
par[i] = i;
}
}
long long find_par(long long x) {
if (par[x] == x) {
return x;
} else {
long long result = find_par(par[x]);
par[x] = result;
return result;
}
}
void unionn(long long x, long long y) {
long long px = find_par(x);
long long py = find_par(y);
par[px] = py;
}
void solve() {
long long n, m;
cin >> n >> m;
par.resize(n);
make_par(n);
long long cost[n];
for (long long i = 0; i < n; i++) cin >> cost[i];
long long x, y;
for (long long i = 0; i < m; i++) {
cin >> x >> y;
x--, y--;
unionn(x, y);
}
map<long long, long long> mp;
for (long long i = 0; i < n; i++) {
long long k = find_par(i);
long long cst = cost[i];
if (cst == 0)
mp[k] = -1;
else if (mp[k] == 0)
mp[k] = cst;
else
mp[k] = min(mp[k], cst);
}
long long ans = 0;
for (auto &it : mp) {
if (it.second != -1) ans += it.second;
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
long long t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, a, b, x, y;
cin >> n >> m >> a >> b;
long long s[3];
s[0] = n * a;
x = n / m;
y = n % m;
s[1] = (1 + x) * b;
s[2] = x * b + y * a;
sort(s, s + 3);
cout << s[0];
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
int h1, h2, m1, m2;
char ch;
int t = 1;
char s[6];
while (t--) {
cin >> n;
cin >> s;
h1 = s[0] - '0';
h2 = s[1] - '0';
m1 = s[3] - '0';
m2 = s[4] - '0';
if (m1 * 10 + m2 > 59) {
m1 = 0;
}
if (n == 12) {
if ((h1 * 10 + h2) % 10 == 0) {
h1 = 1;
} else {
if (h1 * 10 + h2 > 12) h1 = 0;
}
}
if (n == 24) {
if ((h1 * 10 + h2) % 10 == 0 && h1 > 2) {
h1 = 1;
} else {
if (h1 * 10 + h2 > 23) h1 = 0;
}
}
cout << h1 << h2 << ":" << m1 << m2 << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, a[101], i, j, sum = 0, k, a2[101];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum = sum + a[i];
}
k = sum / (n / 2);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i != j && a[i] + a[j] == k) {
printf("%d %d\n", i + 1, j + 1);
a[i] = 0;
a[j] = 0;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> v(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &v[i]);
}
long long cur = 0, res = 0;
for (int i = 0; i < n; ++i) {
res += abs(v[i] - cur);
cur = v[i];
}
printf("%I64d", res);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long int linf = 0x3f3f3f3f3f3f3f3f;
const long double pi = acos(-1.0);
const int mod = 1e9 + 7;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
int r = 0;
for (int i = 0; i < k; i++) r += v[i];
cout << r << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int n, cnt, good, prime[10000001 / 10], non[10000001], mn[10000001],
phi[10000001], pref_smallest_prime[10000001];
bool bad[10000001];
void pre() {
good = n - 1;
bad[1] = 1;
for (int i = 2; i <= n; ++i) {
if (!mn[i]) {
if (i + i > n) bad[i] = 1, --good;
prime[++cnt] = i;
phi[i] = i - 1;
mn[i] = i;
}
for (int j = 1, k; j <= cnt && (k = i * prime[j]) <= n; ++j) {
if (!mn[k]) mn[k] = prime[j];
if (i % prime[j]) {
phi[k] = phi[i] * phi[prime[j]];
} else {
phi[k] = phi[i] * prime[j];
break;
}
}
}
for (int i = 2; i <= n; ++i)
if (mn[i] == i)
non[i] = 1;
else if (mn[i / mn[i]] == mn[i])
non[i] = non[i / mn[i]];
else
non[i] = non[i / mn[i]] + 1;
}
long long get1() {
long long res = 0;
for (int i = 1; i <= n; ++i)
if (!bad[i]) res += i - 1 - phi[i];
return res;
}
long long get2() {
long long res = 0;
for (int i = 2, j = 1; i <= n; ++i)
if (mn[i] == i)
++j;
else
res += phi[i] - j + non[i];
for (int i = 1; i <= n; ++i) {
if (!bad[i]) {
++pref_smallest_prime[mn[i]];
}
}
for (int i = 1; i <= n; ++i) {
pref_smallest_prime[i] += pref_smallest_prime[i - 1];
}
for (int i = 2; i <= n; ++i) {
if (mn[i] != i || bad[i]) continue;
res += pref_smallest_prime[n / i];
for (int j = i; j <= n; j += i) {
if (mn[j] <= n / i) {
--res;
}
}
}
for (int i = 2; i <= n; ++i) {
int a = mn[i];
int b = i / a;
if (b != 1 && mn[b] == b && a != b) {
--res;
}
}
return res;
}
long long calc() {
pre();
long long cnt1 = get1();
long long cnt2 = get2();
long long cnt3 = good * (good - 1ll) / 2 - cnt1 - cnt2;
return cnt1 + cnt2 * 2 + cnt3 * 3;
}
int main() {
scanf("%d", &n);
printf("%I64d\n", calc());
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int cnt[123];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int k;
cin >> k;
while (k--) {
int x;
cin >> x;
cnt[x]++;
}
}
for (int i = 1; i <= 100; ++i) {
if (cnt[i] == n) {
cout << i << " ";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 50;
const int INF = 1000000000 * 2 + 100000000;
struct stock {
int p, q, pos;
};
int cmp1(stock A, stock B) { return A.p < B.p; }
int cmp2(stock A, stock B) { return A.p > B.p; }
int main() {
stock S[1050], B[1050];
int n, s;
int LS = 0, LB = 0;
scanf("%d%d", &n, &s);
for (int i = 1; i <= n; i++) {
char s[2];
int price, cnt;
scanf("%s%d%d", &s, &price, &cnt);
if (s[0] == 'S') {
S[++LS].p = price;
S[LS].q = cnt;
} else {
B[++LB].p = price;
B[LB].q = cnt;
}
}
sort(S + 1, S + LS + 1, cmp1);
sort(B + 1, B + LB + 1, cmp2);
int ps = LS, pb = LB;
while (ps) {
int temp = ps;
while (S[temp].p == S[ps].p) temp--;
temp++;
for (int i = temp + 1; i <= ps; i++) {
S[temp].q += S[i].q;
S[i].p = INF;
}
ps = temp - 1;
}
while (pb) {
int temp = pb;
while (B[temp].p == B[pb].p && temp) temp--;
temp++;
for (int i = temp + 1; i <= pb; i++) {
B[temp].q += B[i].q;
B[i].p = -1 * INF;
}
pb = temp - 1;
}
sort(S + 1, S + LS + 1, cmp1);
sort(B + 1, B + LB + 1, cmp2);
for (int i = min(s, LS); i >= 1; i--) {
if (S[i].p == INF) continue;
printf("S %d %d\n", S[i].p, S[i].q);
}
for (int i = 1; i <= min(s, LB); i++) {
if (B[i].p == -INF) continue;
printf("B %d %d\n", B[i].p, B[i].q);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using pii = pair<int, int>;
const int MAXN = 1e5 + 5;
const int MAXM = 1e5 + 5;
const int MOD = 1e9 + 7;
const int INF = 2e9;
const ll LLINF = 2e18;
int m, n, k, ans, cnt, x;
int a[MAXN], a1[MAXN], a2[MAXN];
ll ans1, ans2;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int mul = 1;
for (int i = 1; i < n; i++) {
a1[i] = mul * abs(a[i] - a[i + 1]);
a2[i] = -mul * abs(a[i] - a[i + 1]);
mul *= -1;
}
ll sum = 0, min_sum = 0;
ans1 = a1[1];
for (int i = 1; i < n; i++) {
sum += a1[i];
ans1 = max(ans1, sum - min_sum);
min_sum = min(min_sum, sum);
}
sum = 0, min_sum = 0;
ans2 = a2[1];
for (int i = 1; i < n; i++) {
sum += a2[i];
ans2 = max(ans2, sum - min_sum);
min_sum = min(min_sum, sum);
}
cout << max(ans1, ans2) << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long a[n + 1];
vector<long long> ar[200010];
long long dp[200100];
long long ans[200100];
for (long long i = 2; i <= 200000; i++) {
dp[i] = 1;
}
for (long long i = 2; i <= 200000; i++) {
if (dp[i] == 1) {
ans[i] = i;
for (long long j = i; j * i <= 200000; j++) {
ans[j * i] = i;
dp[j * i] = 0;
}
}
}
for (long long i = 1; i <= n; i++) {
cin >> a[i];
long long temp = a[i];
map<long long, long long> m;
while (temp > 1) {
m[ans[temp]] += 1;
temp /= ans[temp];
}
for (auto j = m.begin(); j != m.end(); j++) {
ar[j->first].push_back(j->second);
}
}
long long prod = 1;
for (long long i = 2; i <= 200000; i++) {
if (ar[i].size() == n) {
sort((ar[i]).begin(), (ar[i].end()));
prod = prod * (pow(i, ar[i][1]));
} else if (ar[i].size() == n - 1) {
sort(ar[i].begin(), ar[i].end());
prod = prod * (pow(i, ar[i][0]));
}
}
cout << prod;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
long long r = (k - 1) / 2 / m + 1;
long long x = (k - 1) % (2 * m);
long long d = x / 2 + 1;
cout << r << " " << d << " " << ((x % 2) ? "R" : "L") << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int minx, miny, minz, maxx, maxy, maxz, n, m, Q, x, y, z, mx1, mn1, mx2, mn2,
mx3, mn3, D, cnt;
using namespace std;
struct node {
int l, r, maxx, maxy, maxz, minx, miny, minz, d[3];
} t[2000005];
inline bool cmp(node aa, node bb) {
if (aa.d[D] == bb.d[D]) {
if (aa.d[(D + 1) % 3] == bb.d[(D + 1) % 3])
return aa.d[(D + 2) % 3] < bb.d[(D + 2) % 3];
return aa.d[(D + 1) % 3] < bb.d[(D + 1) % 3];
}
return aa.d[D] < bb.d[D];
}
inline void update(int x, int y) {
t[x].maxx = max(t[x].maxx, t[y].maxx);
t[x].minx = min(t[x].minx, t[y].minx);
t[x].maxy = max(t[x].maxy, t[y].maxy);
t[x].miny = min(t[x].miny, t[y].miny);
t[x].maxz = max(t[x].maxz, t[y].maxz);
t[x].minz = min(t[x].minz, t[y].minz);
}
int build(int l, int r, int d) {
int mid = (l + r) >> 1;
D = d;
nth_element(t + l, t + mid, t + r + 1, cmp);
t[mid].minx = t[mid].maxx = t[mid].d[0];
t[mid].miny = t[mid].maxy = t[mid].d[1];
t[mid].minz = t[mid].maxz = t[mid].d[2];
if (l < mid) t[mid].l = build(l, mid - 1, (d + 1) % 3), update(mid, t[mid].l);
;
if (r > mid) t[mid].r = build(mid + 1, r, (d + 1) % 3), update(mid, t[mid].r);
;
return mid;
}
bool inc(int l1, int r1, int l2, int r2) {
if (l1 > r2 || l2 > r1)
return 0;
else
return 1;
}
bool in(int d) {
if (!inc(t[d].minx, t[d].maxx, mn1, mx1)) return 0;
if (!inc(t[d].miny, t[d].maxy, mn2, mx2)) return 0;
if (!inc(t[d].minz, t[d].maxz, mn3, mx3)) return 0;
return 0 ^ 1;
}
bool check(int l1, int r1, int l2, int r2) { return l2 <= l1 && r2 >= r1; }
bool check(int d) {
if (!check(t[d].minx, t[d].maxx, mn1, mx1)) return 0;
if (!check(t[d].miny, t[d].maxy, mn2, mx2)) return 0;
if (!check(t[d].minz, t[d].maxz, mn3, mx3)) return 0;
return 1;
}
int query(int k) {
if (!k) return 0;
if (!in(k)) return 0;
if (check(k)) return 0 ^ 1;
if (t[k].d[0] >= mn1 && t[k].d[0] <= mx1 && t[k].d[1] >= mn2 &&
t[k].d[1] <= mx2 && t[k].d[2] >= mn3 && t[k].d[2] <= mx3)
return 0 ^ 1;
if (query(t[k].l)) return 1;
if (query(t[k].r)) return 1;
return 0;
}
inline int read() {
char ch = getchar();
int f = 1, w = 0;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) w = w * 10 + ch - '0';
return w * f;
}
int main() {
minx = read();
miny = read();
minz = read();
n = read();
m = read();
Q = read();
maxx = maxy = maxz = 1;
for (int i = 1; i <= n; i++) {
x = read();
y = read();
z = read();
minx = min(minx, x);
maxx = max(maxx, x);
miny = min(miny, y);
maxy = max(maxy, y);
minz = min(minz, z);
maxz = max(maxz, z);
}
for (int i = 1; i <= m; i++) {
x = read();
y = read();
z = read();
if (x >= minx && x <= maxx && y >= miny && y <= maxy && z <= maxz &&
z >= minz)
return puts("INCORRECT"), 0;
t[++cnt].d[0] = x;
t[cnt].d[1] = y;
t[cnt].d[2] = z;
}
puts("CORRECT");
int rt = build(1, cnt, 1);
while (Q--) {
x = read();
y = read();
z = read();
if (minx <= x && x <= maxx && miny <= y && y <= maxy && minz <= z &&
z <= maxz) {
puts("OPEN");
continue;
}
mx1 = max(x, maxx);
mn1 = min(x, minx);
mx2 = max(y, maxy);
mn2 = min(y, miny);
mx3 = max(z, maxz);
mn3 = min(z, minz);
if (query(rt))
puts("CLOSED");
else
puts("UNKNOWN");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n, x;
cin >> n >> x;
vector<int> a(n);
vector<int> b(n);
for (int &ai : a) cin >> ai;
for (int &bi : b) cin >> bi;
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
reverse((b).begin(), (b).end());
bool good = true;
for (int i = 0; i < n; i++) {
good &= (a[i] + b[i] <= x);
}
cout << (good ? "Yes\n" : "No\n");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> A;
A.resize(n + 2);
A[1] = 2;
for (long long i = 2; i <= n + 1; i++) {
long long t = (i - 1) * i;
A[i] = t;
long long a;
a = A[i] / (i - 1);
a = a * A[i];
long long b;
b = A[i - 1] / (i - 1);
cout << a - b << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
vector<int> g[N];
int in[N], n, m, tin[N];
bool check() {
int tt = -1, hh = 0, q[N];
for (int i = 1; i <= n; i++)
if (!in[i]) q[++tt] = i;
while (hh <= tt) {
int t = q[hh++];
for (auto i : g[t]) {
in[i]--;
if (!in[i]) q[++tt] = i;
}
}
if (tt == n - 1)
return 1;
else
return 0;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
in[v]++, tin[v]++;
}
for (int i = 1; i <= n; i++) {
if (!in[i])
continue;
else {
in[i]--;
if (check()) {
puts("YES");
return 0;
}
for (int i = 1; i <= n; i++) in[i] = tin[i];
}
}
puts("NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int i, o, p, j, k, l, n, m, a[100100], b[100100], d[100100], s[1000100][3],
c[100100], ans;
void swapi(int x, int y) {
int t1, t2;
t1 = x;
t2 = y;
d[b[x]] = t2;
d[b[y]] = t1;
m = b[x];
b[x] = b[y];
b[y] = m;
}
int main() {
memset(a, 0, sizeof(a));
p = o = 0;
a[1] = 1;
for (i = 2; i <= 100100; i++)
if (!a[i]) {
b[++o] = i;
for (j = 2 * i; j <= 100100; j += i) a[j] = 1;
}
scanf("%d", &n);
o = 1;
a[1] = 1;
for (i = 1; i <= 100100; i++) {
if (i >= (b[o + 1] - 1)) o++;
a[i] = b[o] - 1;
}
for (i = 1; i <= n; i++) {
scanf("%d", &b[i]);
d[b[i]] = i;
}
for (i = 1; i <= n; i++) {
k = d[i];
while (k - i) {
ans++;
s[ans][1] = k - a[k - i];
s[ans][2] = k;
swapi(s[ans][1], s[ans][2]);
k -= a[k - i];
}
}
printf("%d\n", ans);
for (i = 1; i <= ans; i++) printf("%d %d\n", s[i][1], s[i][2]);
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.