solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2 * 1e5 + 10;
const int inf = 1e9;
int N, K, D;
int A[Maxn];
int lmin[Maxn], lmax[Maxn];
stack<pair<int, int> > S;
void Pre() {
while (!S.empty()) S.pop();
S.push(make_pair(0, INT_MAX));
for (int i = 1; i <= N; i++) {
while (A[i] > S.top().second) S.pop();
lmax[i] = S.top().first + 1;
S.push(make_pair(i, A[i]));
}
while (!S.empty()) S.pop();
S.push(make_pair(0, INT_MIN));
for (int i = 1; i <= N; i++) {
while (A[i] < S.top().second) S.pop();
lmin[i] = S.top().first + 1;
S.push(make_pair(i, A[i]));
}
}
int rt, tot, lc[Maxn * 4], rc[Maxn * 4], Maxc[Maxn * 4], Minc[Maxn * 4],
C[Maxn * 4], ln[Maxn * 4], lx[Maxn * 4];
void Link(int &u, int L, int R, int k) {
if (!u) u = ++tot, lx[u] = INT_MAX, ln[u] = INT_MAX;
if (L == R) return;
int mid = (L + R) >> 1;
if (k <= mid)
Link(lc[u], L, mid, k);
else
Link(rc[u], mid + 1, R, k);
}
void Push_down(int u, int L, int R) {
if (ln[u] != INT_MAX) {
int mid = (L + R) >> 1;
ln[lc[u]] = ln[rc[u]] = ln[u];
Minc[lc[u]] = -ln[u] + L;
Minc[rc[u]] = -ln[u] + mid + 1;
C[lc[u]] = Maxc[lc[u]] - ln[u];
C[rc[u]] = Maxc[rc[u]] - ln[u];
ln[u] = INT_MAX;
}
if (lx[u] != INT_MAX) {
int mid = (L + R) >> 1;
lx[lc[u]] = lx[rc[u]] = lx[u];
Maxc[lc[u]] = lx[u] + L;
Maxc[rc[u]] = lx[u] + mid + 1;
C[lc[u]] = Minc[lc[u]] + lx[u];
C[rc[u]] = Minc[rc[u]] + lx[u];
lx[u] = INT_MAX;
}
}
void Change1(int u, int L, int R, int l, int r, int c) {
if (L == l && R == r) {
Maxc[u] = c + L;
C[u] = c + Minc[u];
lx[u] = c;
return;
}
int mid = (L + R) >> 1;
Push_down(u, L, R);
if (r <= mid)
Change1(lc[u], L, mid, l, r, c);
else if (l > mid)
Change1(rc[u], mid + 1, R, l, r, c);
else {
Change1(lc[u], L, mid, l, mid, c);
Change1(rc[u], mid + 1, R, mid + 1, r, c);
}
Maxc[u] = min(Maxc[lc[u]], Maxc[rc[u]]);
Minc[u] = min(Minc[lc[u]], Minc[rc[u]]);
C[u] = min(C[lc[u]], C[rc[u]]);
}
void Change2(int u, int L, int R, int l, int r, int c) {
if (L == l && R == r) {
Minc[u] = -c + L;
C[u] = Maxc[u] - c;
ln[u] = c;
return;
}
int mid = (L + R) >> 1;
Push_down(u, L, R);
if (r <= mid)
Change2(lc[u], L, mid, l, r, c);
else if (l > mid)
Change2(rc[u], mid + 1, R, l, r, c);
else {
Change2(lc[u], L, mid, l, mid, c);
Change2(rc[u], mid + 1, R, mid + 1, r, c);
}
Maxc[u] = min(Maxc[lc[u]], Maxc[rc[u]]);
Minc[u] = min(Minc[lc[u]], Minc[rc[u]]);
C[u] = min(C[lc[u]], C[rc[u]]);
}
int Dfs(int u, int L, int R, int k) {
int mid = (L + R) >> 1;
if (L == R) {
if (C[u] > k)
return INT_MAX;
else
return L;
}
Push_down(u, L, R);
if (C[lc[u]] <= k)
return Dfs(lc[u], L, mid, k);
else
return Dfs(rc[u], mid + 1, R, k);
}
int Query(int u, int L, int R, int l, int r, int k) {
if (L == l && R == r) return Dfs(u, L, R, k);
Push_down(u, L, R);
int mid = (L + R) >> 1;
if (r <= mid)
return Query(lc[u], L, mid, l, r, k);
else if (l > mid)
return Query(rc[u], mid + 1, R, l, r, k);
else {
return min(Query(lc[u], L, mid, l, mid, k),
Query(rc[u], mid + 1, R, mid + 1, r, k));
}
}
map<int, int> mp;
int main() {
scanf("%d%d%d", &N, &K, &D);
for (int i = 1; i <= N; i++) scanf("%d", &A[i]), A[i] += inf;
if (D == 0) {
int j, px, py, len = 0;
for (int i = 1; i <= N; i = j) {
j = i;
while (A[j] == A[i] && j <= N) j++;
if (j - i > len) len = j - i, px = i, py = j - 1;
}
printf("%d %d\n", px, py);
} else {
Pre();
rt = tot = 0;
for (int i = 1; i <= N; i++) Link(rt, 1, N, i);
int last = 1;
int len = 0, px, py;
for (int i = 1; i <= N; i++) {
if ((A[i] - A[i - 1]) % D != 0) last = i;
if (mp[A[i]]) last = max(last, mp[A[i]] + 1);
mp[A[i]] = i;
Change1(rt, 1, N, max(last, lmax[i]), i, A[i] / D);
Change2(rt, 1, N, max(last, lmin[i]), i, A[i] / D);
int x = Query(rt, 1, N, last, i, K + i);
if (i - x + 1 > len) len = i - x + 1, px = x, py = i;
}
printf("%d %d\n", px, py);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long go(long long num, long long parts) {
long long len1 = num / parts;
long long len2 = len1 + 1;
long long rem = num % parts;
parts -= rem;
return (parts * len1 * len1) + (rem * len2 * len2);
}
struct S {
long long len, parts;
long long imporvement() const { return go(len, parts) - go(len, parts + 1); }
bool operator<(const S& s) const { return imporvement() > s.imporvement(); }
};
int32_t main() {
long long n, k;
cin >> n >> k;
multiset<S> q;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
q.insert({x, 1});
}
long long part = n;
while (part < k) {
S s = *q.begin();
q.erase(q.begin());
q.insert({s.len, s.parts + 1});
part++;
}
long long ans = 0;
for (auto each : q) {
ans += go(each.len, each.parts);
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n, m, p[maxn], s[maxn], b[maxn], inc[maxn], pref[maxn], ans[maxn], tot;
pair<int, int> t[maxn * 3];
int Id[maxn], rk[maxn];
inline int gi() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while ('0' <= c && c <= '9') sum = sum * 10 + c - 48, c = getchar();
return sum;
}
int rt[maxn * 6];
namespace sgt {
int lch[maxn * 200], rch[maxn * 200], sum[maxn * 200], tot;
int Id[maxn], rk[maxn];
inline bool cmp(int x, int y) { return p[x] - b[x] < p[y] - b[y]; }
void pre() {
for (int i = 1; i <= n; ++i) Id[i] = i;
sort(Id + 1, Id + n + 1, cmp);
for (int i = 1; i <= n; ++i) rk[Id[i]] = i, Id[i] = p[Id[i]] - b[Id[i]];
}
void insert(int &s, int l, int r, int x, int v) {
if (!s) s = ++tot;
sum[s] += v;
if (l == r) return;
if (x <= ((l + r) >> 1))
insert(lch[s], l, ((l + r) >> 1), x, v);
else
insert(rch[s], ((l + r) >> 1) + 1, r, x, v);
}
int query(int &s, int l, int r, int x) {
if (!s || r <= x) return sum[s];
if (x <= ((l + r) >> 1))
return query(lch[s], l, ((l + r) >> 1), x);
else
return query(lch[s], l, ((l + r) >> 1), x) +
query(rch[s], ((l + r) >> 1) + 1, r, x);
}
int query(int s, int x) {
int pos = upper_bound(Id + 1, Id + n + 1, x) - Id - 1;
return query(rt[s], 1, n, pos);
}
}; // namespace sgt
void insert(int s, int l, int r, int x, int y, int tp) {
sgt::insert(rt[s], 1, n, sgt::rk[y], tp);
if (l == r) return;
if (x <= ((l + r) >> 1))
insert((s << 1), l, ((l + r) >> 1), x, y, tp);
else
insert((s << 1 | 1), ((l + r) >> 1) + 1, r, x, y, tp);
}
int query(int s, int l, int r, int x, int y) {
if (r <= x) return sgt::query(s, y);
if (x <= ((l + r) >> 1))
return query((s << 1), l, ((l + r) >> 1), x, y);
else
return query((s << 1), l, ((l + r) >> 1), x, y) +
query((s << 1 | 1), ((l + r) >> 1) + 1, r, x, y);
}
void insert(int x, int tp) { insert(1, 1, n, rk[x], x, tp); }
int query(int x) {
int pos = upper_bound(Id + 1, Id + n + 1, inc[x] + pref[x]) - Id - 1;
return pos ? query(1, 1, n, pos, inc[x] - pref[x]) : 0;
}
inline bool cmp(int x, int y) { return p[x] + b[x] < p[y] + b[y]; }
int main() {
n = gi();
m = gi();
for (int i = 1; i <= n; ++i) p[i] = gi();
for (int i = 1; i <= n; ++i) s[i] = gi();
for (int i = 1; i <= n; ++i) b[i] = gi();
for (int i = 1; i <= m; ++i) inc[i] = gi();
for (int i = 1; i <= m; ++i) pref[i] = gi();
for (int i = 1; i <= n; ++i) Id[i] = i;
sort(Id + 1, Id + n + 1, cmp);
for (int i = 1; i <= n; ++i) rk[Id[i]] = i, Id[i] = p[Id[i]] + b[Id[i]];
sgt::pre();
for (int i = 1; i <= n; ++i) t[++tot] = make_pair(p[i], i);
for (int i = 1; i <= m; ++i) t[++tot] = make_pair(inc[i], i + n);
for (int i = 1; i <= n; ++i) t[++tot] = make_pair(s[i], i + n + m);
sort(t + 1, t + tot + 1);
for (int i = 1; i <= tot; ++i) {
if (t[i].second <= n)
insert(t[i].second, 1);
else if (t[i].second <= n + m)
ans[t[i].second - n] = query(t[i].second - n);
else
insert(t[i].second - n - m, -1);
}
for (int i = 1; i <= m; ++i) printf("%d ", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:133217728")
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
long long s;
long long ss = 0;
int x[200200];
cin >> n >> s;
for (int i = 0; i < n; i++) {
cin >> x[i];
ss += x[i];
}
for (int i = 0; i < n; i++) {
long long ans = max(0LL, x[i] + s - ss - 1) + max(0LL, x[i] + n - s - 1);
cout << ans << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
int N;
char s[MAXN][6];
int parse(int x) {
char* t = s[x];
return (t[3] - '0') + (t[2] - '0') * 10 + (t[1] - '0') * 100 +
(t[0] - '0') * 1000;
}
int main(int argc, char* argv[]) {
scanf("%d", &N);
for (int i = 0, _i = 4; i < _i; ++i) s[0][i] = '0';
for (int i = (1), _i = (N); i <= _i; ++i) {
scanf("%s", s[i]);
}
for (int i = (1), _i = (N); i <= _i; ++i) {
int mn = INT_MAX;
for (int j = 0, _j = 4; j < _j; ++j) {
for (int k = 0, _k = 9; k <= _k; ++k) {
if (j == 0 && k == 0) continue;
char old = s[i][j];
s[i][j] = k + '0';
int x = parse(i);
int y = parse(i - 1);
if (x >= y && x >= 1000 && x <= 2011) {
mn = min(mn, x);
}
s[i][j] = old;
}
}
if (mn == INT_MAX) {
return puts("No solution") & 0;
}
s[i][3] = (mn % 10) + '0';
s[i][2] = ((mn / 10) % 10) + '0';
s[i][1] = ((mn / 100) % 10) + '0';
s[i][0] = ((mn / 1000) % 10) + '0';
}
for (int i = (1), _i = (N); i <= _i; ++i) {
puts(s[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s1[200005], s2[200005];
int Min(int a, int b) {
if (a < b) return a;
return b;
}
int Max(int a, int b) {
if (a > b) return a;
return b;
}
int solve(char s1[], char s2[], int l) {
int i, t = 0, x;
for (i = 0; i < l; i++)
if (s1[i] != s2[i]) {
t = 1;
break;
}
if (t == 0)
return 1;
else {
if (l % 2 != 0) return 0;
}
x = l / 2;
if (solve(s1, s2, x) && solve(s1 + x, s2 + x, x)) return 1;
if (solve(s1, s2 + x, x) && solve(s1 + x, s2, x)) return 1;
return 0;
}
int main() {
scanf("%s %s", s1, s2);
int l = strlen(s1);
if (solve(s1, s2, l))
puts("YES");
else
puts("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5005;
const int MAXQ = 100005;
struct BIT2D {
int n, m, c[MAXN][MAXN];
void init(int _n, int _m) {
n = _n, m = _m;
for (int i = 1; i <= n; i++) memset(c[i] + 1, 0, m * sizeof(int));
}
void update(int x, int y, int v) {
for (int i = x; i <= n; i += i & -i)
for (int j = y; j <= m; j += j & -j) c[i][j] += v;
}
int query(int x, int y) {
int res = 0;
for (int i = x; i > 0; i -= i & -i)
for (int j = y; j > 0; j -= j & -j) res += c[i][j];
return res;
}
} bit;
int ty[MAXQ], dir[MAXQ], x[MAXQ], y[MAXQ], len[MAXQ], res[MAXQ];
struct Event {
int x, y, t, id;
bool operator<(const Event &rhs) const { return t < rhs.t; }
} el[MAXQ], er[MAXQ];
void solve(int l, int r) {
if (l == r) return;
int m = (l + r) / 2;
for (int _ = 1; _ <= 4; _++) {
int cl = 0, cr = 0;
for (int i = l; i <= m; i++) {
if (dir[i] != _) continue;
if (_ == 1) el[cl++] = Event{x[i], y[i], -x[i] - y[i] - len[i], i};
if (_ == 2)
el[cl++] = Event{x[i], bit.n + 1 - y[i], -x[i] + y[i] - len[i], i};
if (_ == 3)
el[cl++] = Event{bit.n + 1 - x[i], y[i], x[i] - y[i] - len[i], i};
if (_ == 4)
el[cl++] =
Event{bit.n + 1 - x[i], bit.n + 1 - y[i], x[i] + y[i] - len[i], i};
}
for (int i = m + 1; i <= r; i++) {
if (ty[i] != 2) continue;
if (_ == 1) er[cr++] = Event{x[i], y[i], -x[i] - y[i], i};
if (_ == 2) er[cr++] = Event{x[i], bit.n + 1 - y[i], -x[i] + y[i], i};
if (_ == 3) er[cr++] = Event{bit.n + 1 - x[i], y[i], x[i] - y[i], i};
if (_ == 4)
er[cr++] = Event{bit.n + 1 - x[i], bit.n + 1 - y[i], x[i] + y[i], i};
}
sort(el, el + cl);
sort(er, er + cr);
int p = 0;
for (int i = 0; i < cr; i++) {
while (p < cl && el[p].t <= er[i].t) {
bit.update(el[p].x, el[p].y, 1);
p++;
}
res[er[i].id] += bit.query(er[i].x, er[i].y);
}
for (int i = 0; i < p; i++) bit.update(el[i].x, el[i].y, -1);
}
solve(l, m);
solve(m + 1, r);
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
bit.init(n, n);
for (int i = 1; i <= q; i++) {
scanf("%d", &ty[i]);
if (ty[i] == 1)
scanf("%d%d%d%d", &dir[i], &x[i], &y[i], &len[i]);
else
scanf("%d%d", &x[i], &y[i]);
}
solve(1, q);
for (int i = 1; i <= q; i++)
if (ty[i] == 2) printf("%d\n", res[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int mx, nm;
cin >> mx >> nm;
int cnt = 0;
int prev;
int d;
cin >> prev;
for (int i = 1; i < nm; i++) {
cin >> d;
if (prev != mx) cnt += mx - prev;
prev = d;
}
cout << cnt;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int zy[N][N * N / 2];
bool dp[N][N * N / 2];
deque<int> ans;
void dfs(int n, int k) {
if (n == 1) {
ans.push_back(1);
return;
} else {
if (zy[n][k] > 0) {
dfs(n - zy[n][k] + 1, k - zy[n][k]);
int sz = ans.size();
ans.push_front(zy[n][k] / 2 + sz);
if (zy[n][k] & 1) {
for (int i = (int)1; i <= (int)zy[n][k] / 2 - 2; ++i) {
ans.push_back(sz + zy[n][k] / 2 + i);
ans.push_back(sz + i);
}
ans.push_back(sz + zy[n][k] - 1);
ans.push_back(sz + zy[n][k] / 2 - 1);
ans.push_back(sz + zy[n][k] - 2);
} else {
for (int i = (int)1; i <= (int)zy[n][k] / 2 - 1; ++i) {
ans.push_back(sz + zy[n][k] / 2 + i);
ans.push_back(sz + i);
}
}
} else {
dfs(n + zy[n][k] + 1, k + zy[n][k] * (1 - zy[n][k]) / 2 + 1);
int sz = ans.size();
if (ans.front() > ans.back()) {
for (int i = (int)1; i <= (int)-zy[n][k] - 1; ++i)
ans.push_back(sz + i);
} else {
for (int i = (int)1; i <= (int)-zy[n][k] - 1; ++i)
ans.push_front(sz + i);
}
}
}
}
int main() {
dp[1][1] = 1;
for (int i = (int)2; i <= (int)100; ++i) {
for (int j = (int)i + 1; j <= (int)i * (i + 1) / 2; ++j) {
for (int k = (int)2; k <= (int)i; ++k) {
if (k * (k + 1) / 2 <= j &&
dp[i - (k - 1)][j - (k * (k + 1) / 2 - 1)]) {
dp[i][j] = 1;
zy[i][j] = -k;
}
if (k >= 4 && dp[i - k + 1][j - k]) {
dp[i][j] = 1;
zy[i][j] = k;
}
}
}
}
int q, n, k;
cin >> q;
while (q--) {
cin >> n >> k;
if (!dp[n][k]) {
puts("NO");
} else {
dfs(n, k);
puts("YES");
while (ans.size()) {
cout << ans.front() << ' ';
ans.pop_front();
}
cout << endl;
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, ax, ay, bx, by, cx, cy;
cin >> n >> bx >> by >> ax >> ay >> cx >> cy;
int x = bx, y = by;
if ((ay < by && cy < by) && (ax < bx && cx < bx)) {
while (x > 0 && y > 0) {
if ((x == ax && y == ay) || (x == cx && y == cy)) {
cout << "NO" << endl;
return 0;
}
x--;
y--;
}
cout << "YES" << endl;
} else if ((ay < by && cy < by) && (ax > bx && cx > bx)) {
while (x <= n && y > 0) {
if ((x == ax && y == ay) || (x == cx && y == cy)) {
cout << "NO" << endl;
return 0;
}
x++;
y--;
}
cout << "YES" << endl;
} else if ((ay > by && cy > by) && (ax < bx && cx < bx)) {
while (x > 0 && y <= n) {
if ((x == ax && y == ay) || (x == cx && y == cy)) {
cout << "NO" << endl;
return 0;
}
x--;
y++;
}
cout << "YES" << endl;
} else if ((ay > by && cy > by) && (ax > bx && cx > bx)) {
while (x <= n && y <= n) {
if ((x == ax && y == ay) || (x == cx && y == cy)) {
cout << "NO" << endl;
return 0;
}
x++;
y++;
}
cout << "YES" << endl;
} else
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v, nxt;
} e[500005];
int n, h[100005], t, sz[100005];
double f[105][105], g[105][105], fr[105], infr[105], tmp[105];
void add(int u, int v) {
e[++t].v = v;
e[t].nxt = h[u];
h[u] = t;
}
double C(int x, int y) { return fr[x] * infr[y] * infr[x - y]; }
void dfs(int u, int fa) {
sz[u] = 0;
f[u][0] = 1;
for (int i = h[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
dfs(v, u);
memcpy(tmp, f[u], sizeof(tmp));
memset(f[u], 0, sizeof(f[u]));
for (int j = 0; j <= sz[u]; j++)
for (int k = 0; k <= sz[v]; k++) {
f[u][j + k] += tmp[j] * g[v][k] * C(j + k, j) *
C(sz[u] + sz[v] - j - k, sz[u] - j);
}
sz[u] += sz[v];
}
sz[u]++;
double sum = 0;
for (int i = 0; i <= sz[u]; i++) {
g[u][i] = sum / 2 + f[u][i] * (sz[u] - i);
sum += f[u][i];
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
fr[0] = infr[0] = 1;
for (int i = 1; i <= 2 * n; i++) {
fr[i] = fr[i - 1] * i;
infr[i] = 1 / fr[i];
}
for (int i = 1; i <= n; i++) {
dfs(i, 0);
double ans = f[i][n - 1] * infr[n - 1];
printf("%.10f\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n;
cin >> n;
int arr[n + 5][n + 5], a, b;
map<int, int> mp, mp2;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
arr[i][j] = 0;
}
}
for (int i = 1; i < n; i++) {
cin >> a >> b;
arr[a][b] = 1;
mp[a]++;
mp2[b]++;
}
vector<pair<int, pair<int, int>>> v;
int tmp = n;
while (tmp > 1) {
if (mp2[tmp]) {
for (int i = 1; i < tmp; i++) {
if (!mp2[i]) {
v.push_back({2, {i, tmp}});
mp2[i] = mp2[tmp];
for (int ii = 1; ii <= tmp; ii++) {
swap(arr[ii][tmp], arr[ii][i]);
}
break;
}
}
}
if (!mp[tmp]) {
for (int i = 1; i < tmp; i++) {
if (mp[i]) {
v.push_back({1, {i, tmp}});
mp[i] = mp[tmp];
for (int ii = 1; ii <= tmp; ii++) {
mp2[ii] -= arr[i][ii];
swap(arr[tmp][ii], arr[i][ii]);
}
break;
}
}
} else {
for (int ii = 1; ii <= tmp; ii++) {
mp2[ii] -= arr[tmp][ii];
arr[tmp][ii] = 0;
}
}
tmp--;
}
cout << v.size() << '\n';
for (auto i : v) {
cout << i.first << " " << i.second.first << " " << i.second.second << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int SQRTN = 320;
const int LOGN = 20;
const double PI = acos(-1);
int n, val;
map<int, int> dp;
int dp2[N];
int range[N];
bool en[N];
int grundy(long long n) {
if (n < 1e6) return dp2[n];
if (dp.find(n) != dp.end()) return dp[n];
int& mex = dp[n];
int st = 0;
double e = sqrt(n);
double s = sqrt(e);
int i = ceil(s), _ = floor(e);
while (i < n && i <= _) {
i = range[i];
st = st | (1 << grundy(i));
i++;
}
while (st & (1 << mex)) mex++;
return mex;
}
int calc(int n) {
int& mex = dp2[n];
int st = 0;
double e = sqrt(n);
double s = sqrt(e);
for (int i = ceil(s), _ = floor(e); i < n && i <= _; i++) {
st = st | (1 << dp2[i]);
}
while (st & (1 << mex)) mex++;
return mex;
}
int main() {
for (int i = 0; i < 1000000; i++) {
calc(i);
}
range[999999] = 999999;
en[999999] = 1;
for (int i = 999998; i > -1; i--) {
if (dp2[i] != dp2[i + 1])
range[i] = i, en[i] = 1;
else
range[i] = range[i + 1];
}
cin >> n;
long long a;
for (int i = 0; i < n; i++) {
scanf("%lld", &a);
val = val ^ grundy(a);
}
cout << (val ? "Furlo" : "Rublo") << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005, p = 998244353;
int read() {
int f = 1, g = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) g = g * 10 + ch - '0';
return f * g;
}
int qpow(int x, int k) {
int t = 1;
for (; k; k >>= 1) {
if (k & 1) t = (long long)t * x % p;
x = (long long)x * x % p;
}
return t;
}
int ans, n, cnt, b[N], a[N][N], f[N], g[N][N];
void check(int &x, int y) { x = (x + y < p) ? (x + y) : (x + y - p); }
int sub(int x, int y) { return (x - y < 0) ? (x - y + p) : (x - y); }
struct BIT {
int f[N];
inline int lowbit(int x) { return x & (-x); }
void reset() {
for (int i = 1; i <= n; i++) f[i] = lowbit(i);
}
void add(int x) {
for (; x <= n; x += lowbit(x)) f[x]++;
}
void del(int x) {
for (; x <= n; x += lowbit(x)) f[x]--;
}
int que(int x) {
int t = 0;
for (; x; x -= lowbit(x)) t += f[x];
return t;
}
int query(int l, int r) { return que(r) - que(l - 1); }
} h[2];
int main() {
n = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) a[i][j] = read();
f[0] = 1;
f[1] = 0;
for (int i = 2; i <= n; i++)
f[i] = (long long)(i - 1) * (f[i - 1] + f[i - 2]) % p;
g[0][0] = 1;
for (int i = 1; i <= n; i++) {
g[i][0] = (long long)g[i - 1][0] * i % p;
for (int j = 1; j <= i; j++) g[i][j] = sub(g[i][j - 1], g[i - 1][j - 1]);
}
int c = qpow(f[n], n - 1);
for (int i = 1; i <= n; i++) {
check(ans, (long long)g[n - i][0] * (a[1][i] - 1 - h[0].que(a[1][i])) % p *
c % p);
h[0].add(a[1][i]);
}
for (int i = 2; i <= n; i++) {
h[0].reset();
h[1].reset();
memset(b, 0, sizeof(b));
cnt = n;
int c = qpow(f[n], n - i);
for (int j = 1; j <= n; j++) {
if (!b[a[i - 1][j]]++) {
cnt--;
h[1].del(a[i - 1][j]);
}
int tc = h[1].que(a[i][j] - 1), t = h[0].que(a[i][j] - 1) - tc;
if ((a[i - 1][j] < a[i][j]) && (b[a[i - 1][j]] == 1)) t--;
check(ans, (long long)t * g[n - j][cnt] % p * c % p);
check(ans, (long long)tc * g[n - j][cnt - 1] % p * c % p);
if (!b[a[i][j]]++) {
cnt--;
h[1].del(a[i][j]);
}
h[0].del(a[i][j]);
}
}
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename TP>
inline bool rd(TP& r) {
r = 0;
char tmp = getchar();
while (tmp < '0' || tmp > '9') {
if (tmp == EOF) return 0;
tmp = getchar();
}
while ('0' <= tmp && tmp <= '9') {
r = (r << 3) + (r << 1) + tmp - '0';
tmp = getchar();
}
return 1;
}
long long ab(long long num) {
if (num >= 0) return num;
return -num;
}
int main() {
long long x1, y1;
long long x2, y2;
scanf("%I64d %I64d\n", &x1, &y1);
scanf("%I64d %I64d\n", &x2, &y2);
long long dx = ab(x1 - x2) + 1;
long long dy = ab(y1 - y2) + 1;
if (x1 == x2) dx++;
if (y1 == y2) dy++;
if (x1 == x2 && y1 == y2) dx++;
printf("%I64d\n", (dx + dy) * 2);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, y = 0;
cin >> n;
for (int i = 1; i <= sqrt(2 * n); i++) {
if (i * (i + 1) == 2 * n) {
cout << "YES";
y = 1;
break;
}
}
if (y == 0) cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 1000000007;
const char nl = '\n';
const int MX = 100001;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < (N); i++) cin >> A[i];
int pos[N];
for (int i = 0; i < (N); i++) {
pos[A[i] - 1] = i;
}
int lst = 0;
int X = N;
while (lst != N) {
for (int i = pos[lst] + 1; i < (X); i++) {
if (A[i] != A[i - 1] + 1) {
cout << "No" << nl;
goto done;
}
}
int oX = X;
X = pos[lst];
lst = A[oX - 1];
}
cout << "Yes" << nl;
done:;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n, nxt[N];
bool vis[N];
inline void read(int &X) {
X = 0;
char ch = 0;
int op = 1;
for (; ch > '9' || ch < '0'; ch = getchar())
if (ch == '-') op = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar())
X = (X << 3) + (X << 1) + ch - 48;
X *= op;
}
void solve(int p) {
if (vis[p]) {
printf("%d ", p);
return;
}
vis[p] = 1;
solve(nxt[p]);
}
int main() {
read(n);
for (int i = 1; i <= n; i++) read(nxt[i]);
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof(vis));
solve(i);
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 20;
const long long mod = 998244353;
long long fact[N];
map<long long, long long> vis;
long long ksm(long long a, long long b) {
if (b == 0) return 1;
if (b & 1)
return a * ksm(a, b - 1) % mod;
else {
long long k = ksm(a, b / 2);
return k * k % mod;
}
}
long long C(long long m, long long n) {
if (m == 0) return 1;
return fact[n] * ksm(fact[m] * fact[n - m] % mod, mod - 2) % mod;
}
signed main() {
fact[0] = 1;
for (long long i = 1; i < N; i++) {
fact[i] = fact[i - 1] * i % mod;
}
long long T;
cin >> T;
while (T--) {
long long n;
cin >> n;
vis.clear();
long long mx = 0;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
vis[x]++;
mx = max(x, mx);
}
if (vis[mx] > 1)
cout << fact[n] << endl;
else {
if (vis[mx - 1] == 0) {
cout << 0 << endl;
} else {
long long all = n - vis[mx] - vis[mx - 1];
long long res = fact[n];
for (long long i = vis[mx - 1] + 1; i <= n; i++) {
res = ((res - C(n - i, all) * fact[i - 1] % mod * fact[n - i] % mod) +
mod) %
mod;
}
cout << res << endl;
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int long long power(int long long n) {
string s = "1";
for (int i = 0; i < n; i++) {
s += "0";
}
return stoll(s);
}
int main() {
int t;
cin >> t;
while (t--) {
int long long n, k;
cin >> n >> k;
k++;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
if (k <= 9) {
cout << k << endl;
continue;
}
int idx = -1;
int long long result = 0;
for (int i = 1; i < n; i++) {
if (k + 1 > power(arr[i]) / power(arr[i - 1])) {
k -= (power(arr[i]) / power(arr[i - 1]) - 1);
result += ((power(arr[i]) / power(arr[i - 1]) - 1) * power(arr[i - 1]));
} else {
idx = i;
break;
}
}
if (idx == -1) {
result += (k * power(arr[n - 1]));
} else {
result += (k * power(arr[idx - 1]));
}
cout << result << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
cin >> TESTS;
while (TESTS--) {
long long int n, k;
cin >> n >> k;
long long int sm = k * (k + 1) / 2;
sm *= 2;
sm -= k;
if (sm <= n && (n - sm) % 2 == 0)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = int(1e6) + 3;
long long r[148];
long long h[148];
int main() {
int c, w, th;
cin >> c >> w >> th;
w++;
h[0] = 1;
for (int i = 1; i <= w; i++) h[i] = (h[i - 1] * th) % mod;
long long res = 0;
r[w - 1] = 1;
r[w - 2] = 1;
long long s = th + 1;
for (int i = 0; i < c; i++) {
long long t = s;
s -= r[i % w] * h[w - 1];
s %= mod;
if (s < 0) s += mod;
s *= th;
r[i % w] = t;
s += r[i % w];
s %= mod;
}
res = r[(c - 1) % w] % mod;
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int sqr(int x) { return (x * x); }
int main(void) {
int a[100005], ds[100005] = {0}, n, h, d, mx = 0, offset;
cin >> n;
h = (n / 2) + (n % 2);
offset = (n + 1) % 2;
for (int i = (1); i <= (h); i++) {
cin >> a[i];
d = a[i] - i;
if (d >= 0) {
ds[d]++;
mx = max(mx, ds[d]);
}
}
for (int i = (h + 1); i <= (n); i++) {
cin >> a[i];
d = a[i] + i - (2 * h) - offset;
if (d >= 0) {
ds[d]++;
mx = max(mx, ds[d]);
}
}
cout << n - mx << '\n';
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n - 1) * 2 + 1 << " " << 2 << endl;
cout << 1 << " " << 2 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct pp {
int f, s;
};
int main() {
vector<int> with[200005];
int n;
cin >> n;
pp a[200005];
int i, j;
for (i = 1; i <= n; i++) {
cin >> a[i].f >> a[i].s;
if (a[i].f > a[i].s) swap(a[i].f, a[i].s);
with[a[i].f].push_back(a[i].s);
with[a[i].s].push_back(a[i].f);
}
vector<int> res;
res.push_back(a[1].f);
res.push_back(a[1].s);
int last = a[1].f;
int curr = a[1].s;
for (i = 3; i <= n; i++) {
if (with[curr][0] != last) {
res.push_back(with[curr][0]);
last = curr;
curr = with[curr][0];
} else {
res.push_back(with[curr][1]);
last = curr;
curr = with[curr][1];
}
}
if ((min(res[1], res[2]) == a[res[0]].f) &&
(max(res[1], res[2]) == a[res[0]].s)) {
for (i = 0; i < n; i++) cout << res[i] << " ";
} else {
for (i = n - 1; i >= 0; i--) cout << res[i] << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int head, tail;
long long n, p, t, l, r, fres, tres, tdist, res[maxn], dist[maxn];
void update() {
long long cnt = (r - max(l, dist[head] + t)) / p;
long long tr = res[head] + cnt;
long long td = max(l, dist[head] + t) + cnt * p;
if (tr > tres || (tr == tres && td < tdist)) {
tres = tr;
tdist = td;
}
}
int main() {
while (scanf("%lld%lld%lld%lld", &l, &n, &p, &t) == 4) {
fres = head = tres = tail = 0;
res[0] = 0;
dist[0] = -t;
while (n--) {
scanf("%lld%lld", &l, &r);
tdist = r;
while (head <= tail) {
if (dist[head] + t > r) break;
update();
++head;
}
head = max(head - 1, 0);
if (fres < tres) {
fres = tres;
++tail;
res[tail] = tres;
dist[tail] = tdist;
}
}
cout << fres << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int minimum(long long int a, long long int b, long long int c,
long long int d) {
long long int min1 = min(a, b);
long long int min2 = min(c, d);
long long int mini = min(min1, min2);
return mini;
}
int main() {
ios_base::sync_with_stdio(0);
;
cin.tie(0);
long long int n, start;
cin >> n >> start;
long long int a[n + 1];
for (long long int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
if (n == 1)
cout << "0";
else if (start <= a[0])
cout << (a[n - 2] - start);
else if (start >= a[n - 1])
cout << (start - a[1]);
else {
long long int path1 = abs(a[n - 2] - start) + abs(a[n - 2] - a[0]);
long long int path2 = abs(a[n - 1] - start) + abs(a[n - 1] - a[1]);
long long int path3 = abs(start - a[1]) + abs(a[n - 1] - a[1]);
long long int path4 = abs(start - a[0]) + abs(a[n - 2] - a[0]);
cout << min(min(path1, path2), min(path3, path4));
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 610;
const int maxN = N + N, maxE = (N + 2 * N + N) * 2;
const long long oo = 1e18;
long long src, snk, cap[maxE];
int head[maxN], headcpy[maxN], nxt[maxE], to[maxE], edgeCnt;
void init() {
memset(head, -1, sizeof head);
edgeCnt = 0;
}
void addedge(int u, int v, long long c) {
nxt[edgeCnt] = head[u];
head[u] = edgeCnt;
cap[edgeCnt] = c;
to[edgeCnt++] = v;
}
void addbiedge(int u, int v, long long c) {
addedge(u, v, c);
addedge(v, u, 0);
}
int Rank[maxN];
long long ddfs(int cur = src, long long flow = oo) {
if (cur == snk) return flow;
for (int &i = headcpy[cur]; i != -1; i = nxt[i]) {
int t = to[i];
if (!cap[i] || Rank[t] != Rank[cur] + 1) continue;
long long f = ddfs(t, min(flow, cap[i]));
cap[i] -= f;
cap[i ^ 1] += f;
if (f) return f;
}
return 0;
}
int Q[maxN];
bool dbfs() {
memset(Rank, -1, sizeof Rank);
int Qi = 0;
Q[Qi++] = src;
Rank[src] = 0;
for (int i = 0; i < Qi; ++i) {
int cur = Q[i];
int r = Rank[cur];
for (int j = head[cur]; j != -1; j = nxt[j]) {
int t = to[j];
if (!cap[j] || Rank[t] != -1) continue;
Rank[t] = r + 1;
Q[Qi++] = t;
if (t == snk) return 1;
}
}
return 0;
}
long long dinic() {
long long ret = 0, f;
while (dbfs()) {
memcpy(headcpy, head, sizeof head);
while (f = ddfs()) {
ret += f;
}
}
return ret;
}
int t, n, m, k, u[N], v[N], req[N];
vector<int> helpEdges[N];
void pr() {
for (int i = 0; i < m; ++i) printf("0%c", " \n"[i + 1 == m]);
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n), scanf("%d", &m), scanf("%d", &k);
init();
for (int i = 0; i < n; ++i) req[i] = 0;
for (int i = 0; i < m; ++i) {
scanf("%d", &u[i]);
scanf("%d", &v[i]);
u[i]--, v[i]--;
req[u[i]]++;
req[v[i]]++;
}
bool can = 1;
for (int i = 0; i < n; ++i) {
if (req[i] > 2 * k)
can = 0;
else if (req[i] > k && req[i] <= 2 * k)
req[i] = 2 * (req[i] - k);
else
req[i] = 0;
}
if (!can) {
pr();
continue;
}
src = n + m;
snk = src + 1;
for (int i = 0; i < m; ++i) {
addbiedge(src, i, 1);
addbiedge(i, m + u[i], 1);
addbiedge(i, m + v[i], 1);
}
int sumreq = 0;
for (int i = 0; i < n; ++i) {
addbiedge(m + i, snk, req[i]);
sumreq += req[i];
}
int flow = dinic();
if (flow != sumreq) {
pr();
continue;
}
for (int cur = 0; cur < m; cur++) {
for (int j = head[cur]; j != -1; j = nxt[j]) {
if (to[j] != src && cap[j] == 0) helpEdges[to[j] - m].push_back(cur);
}
}
int id = 1;
vector<int> col(m, 0);
for (int i = 0; i < n; ++i) {
for (int j = 0; j + 1 < helpEdges[i].size(); j += 2) {
col[helpEdges[i][j]] = id;
col[helpEdges[i][j + 1]] = id++;
}
}
for (int i = 0; i < m; ++i)
if (!col[i]) col[i] = id++;
for (int i = 0; i < m; ++i) printf("%d%c", col[i], " \n"[i + 1 == m]);
for (int i = 0; i < n; ++i) helpEdges[i].clear();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline void umax(long long &a, long long b) { a = max(a, b); }
inline void umin(long long &a, long long b) { a = min(a, b); }
inline pair<long long, long long> rv(pair<long long, long long> a) {
return make_pair(a.second, a.first);
}
const long long N = 60010;
const long long INF = 1e15 + 10;
const pair<long long, long long> NINF = make_pair(INF, INF);
const long double EPS = 1e-6;
const long long II = 1e9;
const long long MOD = 1e8;
long long n, r;
long long dp[101][N];
bool comp(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first + a.second > b.first + b.second);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> r;
vector<pair<long long, long long> > pos, neg;
for (long long i = 0; i < (n); i++) {
pair<long long, long long> a;
cin >> a.first >> a.second;
if (a.second >= 0)
pos.push_back(a);
else
neg.push_back(a);
}
sort(pos.begin(), pos.end());
sort(neg.begin(), neg.end(), comp);
long long ansPos = 0;
for (pair<long long, long long> &i : pos)
if (r >= i.first) r += i.second, ansPos++;
dp[0][r] = ansPos;
for (long long i = 0; i < (neg.size()); i++)
for (long long en = r; en >= 0; en--) {
if (en >= neg[i].first && en + neg[i].second >= 0)
umax(dp[i + 1][en + neg[i].second], dp[i][en] + 1);
umax(dp[i + 1][en], dp[i][en]);
}
long long ansNeg = 0;
for (long long i = 0; i < (r + 1); i++)
for (long long j = 0; j < (neg.size() + 1); j++) umax(ansNeg, dp[j][i]);
cout << ansNeg << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e6 + 5;
const long long MOD = 1e9 + 7;
const long long MAXX = 4e18;
long long r, z, n, m, l, s, x, y, maxx, a[maxn], b[maxn];
vector<long long> v;
deque<long long> q;
map<long long, long long> mp;
map<long long, long long> mp1;
long long f(long long x) {
if (x == 1 || x == 0) return mp[x] = 1;
return mp[x] = f(x / 2) * 2 + 1;
}
long long f1(long long x) {
if (x == 1) return mp1[x] = 1;
return mp1[x] = 2 * f(x / 2) + x % 2;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> l >> r;
if (n == 1 || n == 0) return cout << n, 0;
f(n);
q.push_front(n / 2), q.push_front(n % 2), q.push_front(n / 2);
while (!q.empty() && l <= r && r > 0) {
x = q.front(), q.pop_front();
if (x == 1 && l == 1) {
s++, r--;
continue;
}
if (x == 1 && l > 1) {
r--, l = max(l - 1, (long long)1);
continue;
}
if (x == 0) {
r--, l = max(l - 1, (long long)1);
continue;
}
if (l > mp[x])
l = max((long long)1, l - mp[x]), r -= mp[x];
else if (l <= mp[x] && x != 1 && x != 0) {
q.push_front(x / 2), q.push_front(x % 2), q.push_front(x / 2);
}
}
cout << s;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const double pi = acos(-1.0);
const int INF = 1e9 + 2;
const int N = 1e6;
long double n, r;
void input() { cin >> n >> r; }
void output() {
cout << fixed << setprecision(20)
<< n * sin(pi / (2 * n)) / sin(3 * pi / (2 * n)) * r * r * sin(pi / n)
<< endl;
}
void solve() {
input();
output();
}
int main() {
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length(), i;
int p[n], q[n];
if (islower(s[0])) {
p[0] = 0;
q[0] = 1;
} else {
p[0] = 1;
q[0] = 0;
}
for (i = 1; i < n; i++) {
if (islower(s[i])) {
p[i] = min(p[i - 1], q[i - 1]);
q[i] = q[i - 1] + 1;
}
if (isupper(s[i])) {
p[i] = min(p[i - 1], q[i - 1]) + 1;
q[i] = q[i - 1];
}
}
cout << min(q[n - 1], p[n - 1]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int n, m, ans[N], h[N];
bitset<N> a[N];
vector<int> e[N];
bool check1() {
for (int i = (int)(1); i <= (int)(n); i++)
if (e[i].size() & 1) return 0;
return 1;
}
void gauss() {
int it = 1;
for (int i = (int)(1); i <= (int)(n); i++) {
int j = it;
for (; j <= n; j++)
if (a[j][i]) break;
if (j > n) continue;
if (j > it) swap(a[j], a[it]);
h[it] = i;
for (int j = (int)(it + 1); j <= (int)(n); j++)
if (a[j][i]) a[j] ^= a[it];
it++;
}
int las = n + 1;
for (int i = (int)(it - 1); i >= (int)(1); i--) {
for (int j = (int)(h[i] + 1); j <= (int)(las - 1); j++) ans[j] = 0;
ans[h[i]] = a[i][0];
for (int j = (int)(1); j <= (int)(i - 1); j++)
if (a[j][h[i]]) a[j] ^= a[i];
las = h[i];
}
for (int i = (int)(1); i <= (int)(las - 1); i++) ans[i] = 0;
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = (int)(1); i <= (int)(n); i++) e[i].clear();
for (int i = (int)(1); i <= (int)(m); i++) {
int x, y;
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
if (check1()) {
puts("1");
for (int i = (int)(1); i <= (int)(n); i++) printf("1 ");
puts("");
return;
}
for (int i = (int)(1); i <= (int)(n); i++) {
a[i] = 0;
for (auto j : e[i]) a[i].set(j);
if (e[i].size() & 1) a[i].set(i), a[i].set(0);
}
memset(ans, 0, sizeof(ans));
gauss();
puts("2");
for (int i = (int)(1); i <= (int)(n); i++) printf("%d ", ans[i] + 1);
puts("");
}
int main() {
int T;
scanf("%d", &T);
while (T--) solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793238462643383279;
const int N = 500005, M = 998244353;
int n, m, i, j, lim, d[100005], p[100005], k, f[100005];
int u, v, ans;
map<int, int> g[100005];
int Find(int x) {
if (f[x] == 0) return x;
return f[x] = Find(f[x]);
}
void uniot(int u, int v) {
int a = Find(u), b = Find(v);
if (a != b) f[a] = b;
}
int main() {
scanf("%d %d", &n, &m);
for (i = 1; i <= m; ++i) {
scanf("%d %d", &u, &v);
++d[u];
++d[v];
g[u][v] = g[v][u] = 1;
}
if (n <= 1000) {
for (i = 1; i <= n; ++i)
for (j = i + 1; j <= n; ++j)
if (!g[i][j]) uniot(i, j);
} else {
if (n <= 10000)
lim = 200;
else
lim = 30;
for (i = 1; i <= n; ++i)
if (n - d[i] <= lim) p[++k] = i;
for (i = 1; i <= k; ++i)
for (j = 1; j <= n; ++j)
if (!g[p[i]][j]) uniot(p[i], j);
u = 0;
for (i = 1; i <= n; ++i)
if (n - d[i] > lim)
if (u)
uniot(u, i);
else
u = i;
}
for (i = 1; i <= n; ++i)
if (Find(i) == i) ++ans;
cout << ans - 1;
}
| 5 |
#include <bits/stdc++.h>
int main() {
char s[10000];
gets(s);
if (s[0] > 90) {
s[0] = s[0] - 32;
}
printf("%s", s);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 998244353;
const long double error = 2e-6;
const long double PI = acosl(-1);
mt19937 rng((unsigned)chrono::system_clock::now().time_since_epoch().count());
inline long long int MOD(long long int x, long long int m = mod) {
long long int y = x % m;
return (y >= 0) ? y : y + m;
}
const int inf = 1e9;
const long long int infl = 1061109567;
const int nmax = 2e5 + 10;
int L[nmax], R[nmax];
int indice[nmax], ans[nmax];
vector<int> start[nmax];
const int lgn = 32 - __builtin_clz(nmax);
int sparse[nmax][lgn];
void buildsparse(int n) {
for (int i = 1; i <= n; i++) sparse[i][0] = indice[i];
for (int k = 1, p = 1; k < lgn; k++, p <<= 1)
for (int i = 1; i + p + p <= n + 1; i++)
sparse[i][k] = ((L[sparse[i][k - 1]] < L[sparse[i + p][k - 1]])
? (sparse[i][k - 1])
: (sparse[i + p][k - 1]));
}
int query(int l, int r) {
int len = r - l + 1;
int k = 32 - __builtin_clz(len) - 1;
return ((L[sparse[l][k]] < L[sparse[r - (1 << k) + 1][k]])
? (sparse[l][k])
: (sparse[r - (1 << k) + 1][k]));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> L[i] >> R[i];
start[L[i]].push_back(i);
}
priority_queue<pair<int, int>> pq;
int cur = 1;
while (cur <= n) {
for (int x : start[cur]) pq.push({-R[x], x});
int x = pq.top().second;
pq.pop();
indice[cur] = x;
cur++;
}
for (int i = 1; i <= n; i++) ans[indice[i]] = i;
buildsparse(n);
int s1 = 0, s2 = 0;
for (int i = 1; i <= n; i++) {
int x = indice[i];
int r = R[x];
if (i == r) continue;
int y = query(i + 1, r);
if (L[y] <= i) {
s1 = x, s2 = y;
break;
}
}
if (s1)
cout << "NO\n";
else
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
if (s1 == 0) return 0;
swap(ans[s1], ans[s2]);
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> nodes[200010];
int res[200010][2], arr[200010];
int st[200010], en[200010], disc[200010], depth[200010];
int tempo = 0;
void dfs(int x, int p, int d) {
st[x] = ++tempo;
depth[x] = d;
disc[tempo] = x;
for (auto i : nodes[x]) {
if (i != p) {
dfs(i, x, d + 1);
}
}
en[x] = tempo;
}
int read(int par, int idx) {
int sum = 0;
while (idx > 0) {
sum += res[idx][par];
idx -= (idx & -idx);
}
return sum;
}
void update(int par, int idx, int val, int N) {
while (idx <= N) {
res[idx][par] += val;
idx += (idx & -idx);
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
int u, v;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
nodes[u].push_back(v);
nodes[v].push_back(u);
}
dfs(1, -1, 0);
int t;
int node, val;
while (m--) {
cin >> t;
if (t == 1) {
cin >> node >> val;
update(depth[node] % 2, st[node], val, n);
update(depth[node] % 2, en[node] + 1, -val, n);
update((depth[node] + 1) % 2, st[node], -val, n);
update((depth[node] + 1) % 2, en[node] + 1, val, n);
} else {
cin >> node;
cout << arr[node] + read(depth[node] % 2, st[node]) << "\n";
}
}
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("expensive-optimizations")
using namespace std;
constexpr short int infs = 3e4 + 7;
constexpr int inf = 1e9 + 7;
constexpr long long infl = 1e18 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int k, n = 2000, s;
cin >> k;
s = k + n;
cout << n << '\n' << -1 << ' ';
for (int i = 2; i <= n; i++) {
cout << min(1000000, s) << ' ';
s -= min(1000000, s);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k, minn = 10000, a[1000], temp = 0;
cin >> n >> m >> k;
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (a[i] <= k && a[i] != 0) {
temp = abs(i + 1 - m) * 10;
if (temp < minn) minn = temp;
}
}
cout << minn;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int r, c;
scanf("%d %d", &r, &c);
int i, j;
char s[r][c], flag = 0;
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++) {
scanf(" %c", &s[i][j]);
if (s[i][j] == 'C' || s[i][j] == 'M' || s[i][j] == 'Y') flag = 1;
}
}
if (flag == 1)
printf("#Color");
else
printf("#Black&White");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int c[n], o[n];
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < n; i++) cin >> o[i];
int min1 = INT_MAX, min2 = INT_MAX;
for (int i = 0; i < n; i++) min1 = min(min1, c[i]);
for (int i = 0; i < n; i++) min2 = min(min2, o[i]);
int diff1 = 0;
int diff2 = 0;
long long int ans = 0;
for (int i = 0; i < n; i++) {
diff1 = abs(min1 - c[i]);
diff2 = abs(min2 - o[i]);
ans += max(diff1, diff2) % 1000000007;
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n = n * 2;
double f;
double a[n];
double ans = 0;
for (int i = 0; i < n; i++) {
cin >> f;
a[i] = f - (double)(int)f;
ans = ans + a[i];
}
ans = ans * -1;
int x = 0;
for (int i = 0; i < n; i++)
if (a[i] == 0) x++;
if ((n - 2 * x) > 0) ans = ans + (double)((n - (2 * x)) / 2);
x = min(x, n - x);
for (int i = 0; i < x; i++) {
if (abs(1 + ans) < abs(ans)) ans++;
}
ans = abs(ans);
cout.precision(3);
cout << fixed << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000 * 1000 * 1000 + 7;
const int INF = 2 * MOD;
int n, m;
char t[20500][12];
int cntSender[20500];
int cntGroup[12];
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
cin >> n >> m;
vector<int> inp(n), a, b;
for (int i = 0; i < n; ++i) {
cin >> inp[i];
}
for (int i = 0; i < m; ++i) {
int t;
cin >> t;
b.push_back(inp[--t]);
inp[t] = -1;
}
long long sum = 0;
for (int i = 0; i < n; ++i) {
if (inp[i] != -1) {
sum += inp[i];
}
}
sort(b.begin(), b.end());
long long mx = 0;
for (int i = 0; i < b.size() + 1; ++i) {
long long cur = 0;
for (int j = i; j < b.size(); ++j) {
cur += b[j];
}
int j = 0;
while (j < i && sum + cur >= b[j]) {
cur += max((long long)b[j], sum + cur);
++j;
}
if (j < i) {
for (int l = j; l < i; ++l) {
cur += b[l];
}
}
mx = max(sum + cur, mx);
}
cout << mx << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, e, m[1009];
double x, y;
pair<pair<int, int>, double> p[1009];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> a >> b;
for (c = 1; c <= a; c++) {
cin >> m[c];
m[c] += 2000;
}
cout << b << " ";
p[1].first.first = m[1] - b;
p[1].first.second = m[1] + b;
p[1].second = b;
for (c = 2; c <= a; c++) {
x = (double)(0);
for (d = 1; d < c; d++) {
if ((m[c] - b <= p[d].first.first && m[c] + b >= p[d].first.second) ||
(m[c] - b >= p[d].first.first && m[c] + b <= p[d].first.second) ||
(m[c] - b >= p[d].first.first && m[c] - b <= p[d].first.second) ||
(m[c] + b >= p[d].first.first && m[c] + b <= p[d].first.second)) {
y = p[d].second +
sqrt((b * 2) * (b * 2) -
(m[c] - p[d].first.first - b) * (m[c] - p[d].first.first - b));
x = max(x, y);
}
}
if (x == 0) x = b;
cout << setprecision(13) << x << " ";
p[c].first.first = m[c] - b;
p[c].first.second = m[c] + b;
p[c].second = x;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int a[N + 10], b[N + 10], tg[N + 10], pos[N + 10];
int main() {
int T;
scanf("%d", &T);
while (T--) {
memset(tg, -1, sizeof(tg));
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
tg[pos[b[i]]] = i;
}
int ans = 1;
for (int i = 1; i <= m; i++) {
int cnt = 0;
if (pos[b[i]] > 1 && tg[pos[b[i]] - 1] < tg[pos[b[i]]]) cnt++;
if (pos[b[i]] < n && tg[pos[b[i]] + 1] < tg[pos[b[i]]]) cnt++;
ans *= cnt;
ans %= 998244353ll;
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
auto query = [&](vector<int> s) {
if (s.size() <= 1) return 0;
cout << "? " << s.size() << endl;
for (int i : s) cout << i + 1 << " ";
cout << endl;
int res;
cin >> res;
return res;
};
vector<int> que = {0};
vector<int> was(n);
was[0] = 1;
while ((int)que.size() < n) {
vector<int> st;
for (int i = 0; i < n; i++)
if (!was[i]) st.push_back(i);
int l = query(que);
int lo = 0, hi = st.size();
while (hi - lo > 1) {
int mid = (hi + lo) >> 1;
vector<int> c = que;
vector<int> sp;
for (int i = 0; i < mid; i++) {
c.push_back(st[i]);
sp.push_back(st[i]);
}
if (query(c) > l + query(sp))
hi = mid;
else
lo = mid;
}
que.push_back(st[lo]);
was[st[lo]] = 1;
}
vector<int> pref(n + 1);
for (int i = 1; i < n + 1; i++) {
vector<int> q;
for (int j = 0; j < i; j++) q.push_back(que[j]);
pref[i] = query(q);
}
vector<int> par(n, -1);
for (int i = 1; i < n; i++) {
int lo = 0, hi = i;
while (hi - lo > 1) {
int mid = (hi + lo) >> 1;
vector<int> q;
for (int j = 0; j < mid; j++) q.push_back(que[j]);
q.push_back(que[i]);
if (query(q) > pref[mid])
hi = mid;
else
lo = mid;
}
par[que[i]] = que[lo];
}
vector<int> res(n);
vector<vector<int>> to(2);
for (int i = 1; i < n; i++) res[que[i]] = res[par[que[i]]] ^ 1;
for (int i = 0; i < n; i++) to[res[i]].push_back(i);
for (int rot = 0; rot < 2; rot++) {
if (query(to[rot])) {
int r = -1;
vector<int> q;
for (int i = 0; i < (int)to[rot].size(); i++) {
q.push_back(to[rot][i]);
if (query(q)) {
r = i;
break;
}
}
int l = -1;
q.clear();
q.push_back(to[rot][r]);
for (int i = r - 1; i > -1; i--) {
q.push_back(to[rot][i]);
if (query(q)) {
l = i;
break;
}
}
assert(~l && ~r);
l = to[rot][l];
r = to[rot][r];
vector<int> pl, pr;
while (l != -1) {
pl.push_back(l);
l = par[l];
}
while (r != -1) {
pr.push_back(r);
r = par[r];
}
reverse(pl.begin(), pl.end());
reverse(pr.begin(), pr.end());
int nxt = 0;
while (nxt < (int)min(pl.size(), pr.size()) && pl[nxt] == pr[nxt]) nxt++;
assert(nxt);
nxt--;
vector<int> ft;
for (int i = pl.size() - 1; i > nxt; i--) ft.push_back(pl[i]);
for (int i = nxt; i < (int)pr.size(); i++) ft.push_back(pr[i]);
cout << "N " << ft.size() << endl;
for (int i : ft) cout << i + 1 << " ";
cout << endl;
return 0;
}
}
cout << "Y " << to[0].size() << endl;
for (int i : to[0]) cout << i + 1 << " ";
cout << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000 + 10;
string s[maxn];
int vis[maxn];
int len[maxn];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
memset(len, -1, sizeof(len));
memset(vis, -1, sizeof(vis));
int end_loc = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
int y = s[i].length();
int k;
scanf("%d", &k);
for (int j = 0; j < k; j++) {
int loc;
scanf("%d", &loc);
if (y > len[loc]) {
vis[loc] = i;
len[loc] = s[i].length();
}
end_loc = max(end_loc, loc);
}
}
int en = 0;
for (int i = 1; i <= end_loc; i++) {
if (vis[i] == -1) {
if (i > en) {
printf("a");
en++;
}
} else if (vis[i] >= 0) {
int id = vis[i];
if (i > en) {
cout << s[id];
en += s[id].length();
} else if (i <= en) {
int x = 0;
for (int j = en - i + 1; j < s[id].length(); j++) {
x++;
printf("%c", s[id][j]);
}
en += x;
}
}
}
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 1040;
int n;
char a[MAXN][MAXN];
int x[MAXN][MAXN], y[MAXN][MAXN];
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
string mv = "LRUD";
string nv = "RLDU";
bool valid(int i, int j) { return i > 0 && i <= n && j > 0 && j <= n; }
void dfs(int i, int j) {
if (x[i][j] == i && y[i][j] == j) a[i][j] = 'X';
if (x[i][j] == -1) {
for (int k = 0; k < 4; k++) {
int xx = i + dx[k];
int yy = j + dy[k];
if (valid(xx, yy) && x[xx][yy] == x[i][j] && y[xx][yy] == y[i][j]) {
a[i][j] = nv[k];
}
}
}
for (int k = 0; k < 4; k++) {
int xx = i + dx[k];
int yy = j + dy[k];
if (valid(xx, yy) && !a[xx][yy] && x[xx][yy] == x[i][j] &&
y[xx][yy] == y[i][j]) {
a[xx][yy] = mv[k];
dfs(xx, yy);
}
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
memset(a, 0, sizeof a);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cin >> x[i][j] >> y[i][j];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (x[i][j] == i && y[i][j] == j) dfs(i, j);
if (x[i][j] == -1 && !a[i][j]) {
dfs(i, j);
}
}
}
bool cond = true;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (!a[i][j]) cond = false;
}
}
if (!cond) {
cout << "INVALID" << '\n';
return 0;
}
cout << "VALID" << '\n';
cerr << n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cout << a[i][j];
}
cout << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
const int maxn = 200200;
const int mod = 998244353;
int n, m;
long long add_tag, mul_tag;
std::vector<std::pair<int, long long> > vc;
inline long long getv(std::pair<int, long long> x) {
return x.first * mul_tag + x.second + add_tag;
}
inline long double getk(std::pair<int, long long> x,
std::pair<int, long long> y) {
return (long double)(getv(y) - getv(x)) / (y.first - x.first);
}
int main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
vc.emplace_back(0, 0);
int first = 0, last = n - 1;
for (int i = 0; i < m; ++i) {
int opt, k;
cin >> opt;
if (opt == 1) {
mul_tag = add_tag = 0;
cin >> k;
vc = {std::pair<int, long long>(first -= k, 0)};
}
if (opt == 2) {
cin >> k;
last += 1;
std::pair<int, long long> x(last, -add_tag - (long long)last * mul_tag);
for (; vc.size() > 1 &&
getk(vc.back(), x) <= getk(vc[vc.size() - 2], vc.back());)
vc.pop_back();
vc.emplace_back(x);
last += k - 1;
}
if (opt == 3) {
long long b, s;
cin >> b >> s;
b -= s * first;
add_tag += b;
mul_tag += s;
}
for (; vc.size() > 1 && getv(vc[vc.size() - 2]) <= getv(vc.back());)
vc.pop_back();
cout << vc.rbegin()->first - first + 1 << ' ' << getv(vc.back()) << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k, ls, lt, lp, tt;
char st[1000], ss[1000], sp[1000], s[1000];
bool cheak(char *st) {
int tot = 0;
for (int i = 0; i < lt; i++) {
int f = 1;
for (int j = 0; j < ls; j++)
if (ss[j] != st[i + j]) {
f = 0;
break;
}
if (f == 1) tot++;
}
if (tot != tt) return 0;
return 1;
}
int main() {
cin >> n >> k;
scanf("%s", ss);
scanf("%s", sp);
st[n] = '\0';
for (int i = 0; i < n; i++) st[i] = '!';
lt = n;
ls = strlen(ss);
lp = strlen(sp);
for (int i = 0; i < lp; i++) {
if (sp[i] == '1') {
tt++;
for (int j = 0; j < ls; j++)
if (st[j + i] != '!') {
if (st[j + i] != ss[j]) {
puts("No solution");
return 0;
}
} else
st[j + i] = ss[j];
}
}
for (int i = 'a'; i <= 'a' + k; i++) {
for (int j = 0; j < lt; j++)
if (st[j] == '!')
s[j] = i;
else
s[j] = st[j];
if (cheak(s)) {
printf("%s", s);
return 0;
};
}
puts("No solution");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long t[32];
int main() {
for (int i = 1; i <= 31; i++) t[i] = t[i - 1] * 4 + 1;
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
if (x == 2 && y == 3)
cout << "NO" << endl;
else {
long long vt = 0;
for (int j = 1; j <= 31; j++)
if (y > t[j]) vt = j;
if (vt >= x)
cout << "NO" << endl;
else if (y == 3)
cout << "YES " << x - 1 << endl;
else
cout << "YES " << x - (long long)roundf(log10(3 * y + 1) / log10(4))
<< endl;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void dprintln(const T &t) {
cout << t << endl;
}
template <typename T, typename... Args>
void dprintln(const T &t, const Args &...rest) {
cout << t << ' ';
dprintln(rest...);
}
template <typename T>
void println(const T &t) {
cout << t << '\n';
}
template <typename T, typename... Args>
void println(const T &t, const Args &...rest) {
cout << t << ' ';
println(rest...);
}
template <typename T>
void print(const T &t) {
cout << t << ' ';
}
template <typename T, typename... Args>
void print(const T &t, const Args &...rest) {
cout << t;
print(rest...);
}
template <class T>
void scan(T &t) {
cin >> t;
}
template <class T, class... Args>
void scan(T &a, Args &...rest) {
cin >> a;
scan(rest...);
}
using ll = long long;
using vl = vector<ll>;
using vi = vector<int>;
using pii = pair<int, int>;
using vb = vector<bool>;
using vpii = vector<pii>;
template <typename T>
struct bit {
vector<T> a;
explicit bit(int n, int v = 0) {
a.resize(n + 1);
if (v != 0) {
for (int i = 1; i <= n; ++i) a[i] = v;
}
}
T sum(T x) {
T res = 0;
while (x) {
res += a[x];
x -= x & -x;
}
return res;
}
T sum(int l, int r) {
if (l > r) return 0;
return sum(r) - sum(l - 1);
}
void add(int x, T v) {
while (x < a.size()) {
a[x] += v;
x += x & -x;
}
}
void clear() { fill(a.begin(), a.end(), 0); }
};
vi get_prime(int n) {
vi minp(n + 1), p;
for (int i = 2; i <= n; i++) {
if (!minp[i]) {
minp[i] = i;
p.push_back(i);
}
for (auto &x : p) {
if (x <= minp[i] && x * i <= n)
minp[x * i] = x;
else
break;
}
}
return p;
}
const int mod = 1000000007;
inline void add_mod(ll &x, const ll &y) {
x += y;
if (x >= mod) x -= mod;
}
void sub_mod(ll &x, const ll &y) {
x -= y;
if (x < 0) x += mod;
}
template <typename T>
using vv = vector<vector<T>>;
template <typename T1, typename T2 = T1>
using vp = vector<pair<T1, T2>>;
template <typename T, int n>
using va = vector<array<T, n>>;
using vec = vector<ll>;
using mat = vector<vec>;
mat get_I(int n) {
mat res(n, vec(n));
for (int i = 0; i < n; i++) res[i][i] = 1;
return res;
}
mat operator*(const mat &a, const mat &b) {
mat c(a.size(), vec(b[0].size()));
for (size_t i = 0; i < a.size(); i++) {
for (size_t j = 0; j < a[0].size(); j++) {
if (a[i][j]) {
for (size_t k = 0; k < b[0].size(); k++) {
add_mod(c[i][k], a[i][j] * b[j][k] % mod);
}
}
}
}
return c;
}
vec operator*(const mat &a, const vec &b) {
vec c(a.size());
for (size_t i = 0; i < a.size(); i++) {
for (size_t j = 0; j < a[0].size(); j++) {
add_mod(c[i], a[i][j] * b[j] % mod);
}
}
return c;
}
mat pow(mat a, ll n) {
mat res(a.size(), vec(a[0].size()));
for (size_t i = 0; i < a.size(); i++) {
res[i][i] = 1;
}
while (n) {
if (n & 1) {
res = res * a;
}
a = a * a;
n >>= 1;
}
return res;
}
struct UF {
vi par;
explicit UF(int n) {
par.assign(n + 1, 0);
for (int i = (1); i < (n + 1); ++i) par[i] = i;
}
int find(int x) { return x == par[x] ? x : par[x] = find(par[x]); }
void unite(int x, int y) { par[find(x)] = find(y); }
};
vi get_popcnt(int n) {
vi res(n + 1);
for (int i = (0); i < (n); ++i) {
if (i * 2 <= n) res[i * 2] = res[i];
if ((i & 1) == 0) res[i + 1] = res[i] + 1;
}
return res;
}
const int N = (int)2e5 + 5, M = 1005;
int head[N], tail;
struct edge {
int to, next;
} E[N];
inline void add_edge(int u, int v) {
E[++tail] = {v, head[u]};
head[u] = tail;
}
int fa[N][18];
int dep[N];
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int dif = dep[u] - dep[v];
for (int i = (0); i < (18); ++i) {
if (dif & 1 << i) {
u = fa[u][i];
}
}
if (u == v) return u;
for (int i = (17); i >= (0); i--) {
if (fa[u][i] != fa[v][i]) {
u = fa[u][i];
v = fa[v][i];
}
}
return fa[u][0];
}
vi check(int a, int b, int c, int d) {
if (a == 0) return {c, d};
int x[4] = {a, b, c, d};
for (int i = (0); i < (3); ++i)
for (int j = (i + 1); j < (4); ++j) {
int u = lca(x[i], x[j]);
bool flag = true;
for (int k = (0); k < (4); ++k) {
if (k != i && k != j) {
int t = x[k];
if (dep[t] >= dep[u] && (lca(t, x[i]) == t || lca(t, x[j]) == t)) {
continue;
} else {
flag = false;
break;
}
}
}
if (flag) return {x[i], x[j]};
}
return {-1, -1};
}
struct node {
bool ok;
int u, v;
} tree[N * 4];
int leaf[N];
int p[N];
int v[N];
void push_up(int id) {
auto &f = tree[id], lson = tree[id * 2], rson = tree[id * 2 + 1];
if (lson.ok && rson.ok) {
auto res = check(lson.u, lson.v, rson.u, rson.v);
if (res[0] != -1) {
f.ok = true;
f.u = res[0];
f.v = res[1];
} else
f.ok = false;
} else {
f.ok = false;
}
}
void build(int id, int l, int r) {
if (l == r) {
leaf[l] = id;
tree[id].u = tree[id].v = v[l];
tree[id].ok = true;
return;
}
int mid = (l + r) / 2;
build(id * 2, l, mid);
build(id * 2 + 1, mid + 1, r);
push_up(id);
}
void work(int i) {
int id = leaf[p[i]];
tree[id].u = tree[id].v = i;
while (id != 1) {
id /= 2;
push_up(id);
}
}
void upd(int i, int j) {
swap(p[i], p[j]);
work(i);
work(j);
}
int query(int id, int l, int r, int u, int v) {
if (tree[id].ok) {
auto t = check(u, v, tree[id].u, tree[id].v);
if (t[0] != -1) return r - l + 1;
if (l == r) return 0;
}
int mid = (l + r) / 2;
auto &lson = tree[id * 2];
if (lson.ok) {
auto t = check(u, v, lson.u, lson.v);
if (t[0] != -1) {
return mid - l + 1 + query(id * 2 + 1, mid + 1, r, t[0], t[1]);
}
}
return query(id * 2, l, mid, u, v);
}
int main() {
int n;
scanf("%d", &n);
for (int i = (1); i < (n + 1); ++i) {
scanf("%d", &p[i]);
v[p[i]] = i;
}
for (int i = (2); i < (n + 1); ++i) {
scanf("%d", &fa[i][0]);
dep[i] = dep[fa[i][0]] + 1;
}
for (int i = (1); i < (18); ++i)
for (int j = (2); j < (n + 1); ++j) fa[j][i] = fa[fa[j][i - 1]][i - 1];
build(1, 0, n - 1);
int q;
scanf("%d", &q);
for (int _ = 0, __ = (int)q; _ < __; _++) {
int t, i, j;
scanf("%d", &t);
if (t == 1) {
scanf("%d%d", &i, &j);
upd(i, j);
} else {
printf("%d\n", query(1, 0, n - 1, 0, 0));
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
long long Calc() {
long long ret = v[0] ^ v[1];
vector<long long> stk;
for (long long i = 0; i < v.size(); i++) {
while (!stk.empty() && stk.back() < v[i]) stk.pop_back();
stk.push_back(v[i]);
if (stk.size() > 1)
ret = max(ret, stk[stk.size() - 1] ^ stk[stk.size() - 2]);
}
return ret;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long n, ans, cur;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> cur;
v.push_back(cur);
}
ans = Calc();
reverse(v.begin(), v.end());
ans = max(ans, Calc());
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void extgcd(long long a, long long b, long long &x, long long &y,
long long &d) {
if (b) {
extgcd(b, a % b, y, x, d);
y -= x * (a / b);
} else {
x = 1, y = 0, d = a;
}
}
int main() {
long long a, b, c, x, y;
scanf("%lld %lld %lld", &a, &b, &c);
long long d = c;
if (c % gcd(a, b))
printf("-1");
else {
extgcd(a, b, x, y, d);
printf("%lld %lld \n", x * (-c / d), y * (-c / d));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int f(int x) { return x * (x + 1) / 2; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int k;
cin >> k;
if (k == 0) {
cout << "a";
return 0;
}
int cnt[26], k0 = 0;
memset(cnt, 0, sizeof(cnt));
for (int j = 0; j < 26; j++) {
while (k0 + f(cnt[j] + 1) <= k) cnt[j]++;
k0 += f(cnt[j]);
if (k0 == k) break;
}
if (k0 != k) {
cout << -1;
return 0;
}
for (int j = 0; j < 26; j++) {
if (cnt[j] == 0) continue;
for (int i = 0; i <= cnt[j]; i++) cout << (char)(j + 'a');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long fact[1005];
long long expo(long long x, long long y) {
if (y == 0) return 1;
long long ans = expo(x, y / 2);
ans = (ans * ans) % 1000000007;
if (y % 2) ans = (ans * x) % 1000000007;
return ans;
}
long long inv(long long x) { return expo(x, 1000000007 - 2); }
long long nCr(long long n, long long r) {
if (n < r) return 0;
return ((fact[n] * inv(fact[n - r])) % 1000000007 * inv(fact[r])) %
1000000007;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, k, i, j;
fact[0] = 1;
for (i = 1; i <= 1001; i++) fact[i] = (fact[i - 1] * i) % 1000000007;
cin >> n >> m >> k;
n--, m--;
cout << (nCr(n, 2 * k) * nCr(m, 2 * k)) % 1000000007;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, ans = 0;
cin >> n;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
ans = arr[0] + n + n - 1;
for (long long i = 1; i < n; i++) {
if (arr[i] >= arr[i - 1]) {
ans += arr[i] - arr[i - 1];
} else {
ans += arr[i - 1] - arr[i];
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int C[200][200];
int n, mod;
int b[1 << 21], init[1 << 21];
int eff[1 << 21][22];
long long t;
struct mat {
int n, m;
vector<vector<int> > a;
mat() {}
mat(int nn, int mm, bool h = false) {
n = nn, m = mm;
a = vector<vector<int> >(n, vector<int>(m, 0));
if (h)
for (int i = 0; i < n; i++) a[i][i] = 1;
}
} res;
mat mul(const mat &A, const mat &B) {
mat ret(A.n, B.m);
for (int i = 0; i < ret.n; i++)
for (int j = 0; j < ret.m; j++)
for (int k = 0; k < A.m; k++)
ret.a[i][j] = (ret.a[i][j] + A.a[i][k] * (long long)B.a[k][j]) % mod;
return ret;
}
mat POW(const mat &base, long long p) {
mat cur = base;
mat ret(base.n, base.m, true);
while (p) {
if (p & 1) ret = mul(ret, cur);
p >>= 1;
cur = mul(cur, cur);
}
return ret;
}
void solve(int lo, int hi) {
if (lo == hi) {
for (int i = 0; i <= n; i++)
eff[lo][i] = ((long long)res.a[i][0] * init[lo]) % mod;
return;
}
int mid = (lo + hi) / 2;
solve(lo, mid);
solve(mid + 1, hi);
int len = (hi - lo + 1) / 2;
for (int j = 0; j <= n; j++)
for (int i = lo; i <= hi; i++)
eff[i][j] = (eff[i][j] + eff[i ^ len][j + 1]) % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> t >> mod;
for (int i = 0; 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]) % mod;
}
for (int i = 0; i < (1 << n); i++) cin >> init[i];
for (int i = 0; i <= n; i++) cin >> b[i];
mat base(n + 1, 1);
base.a[0][0] = 1;
mat comb(n + 1, n + 1);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
for (int t = 0; t <= n; t++)
if ((j + i) % 2 == t % 2) {
int y = (t + j - i) / 2;
int x = j - y;
if (x >= 0 && y >= 0 && x + y == j && x <= i && y <= (n - i) &&
(i - x) + y == t) {
comb.a[i][j] = (comb.a[i][j] + b[t] * (long long)C[i][x] % mod *
(long long)C[n - i][y]) %
mod;
}
}
res = mul(POW(comb, t), base);
solve(0, (1 << n) - 1);
for (int i = 0; i < (1 << n); i++) cout << eff[i][0] << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long sz = 23;
void solve() {
long long n;
cin >> n;
vector<long long> a(n), b(sz);
for (long long i = 0; i < n; i++) {
cin >> a[i];
for (long long j = 0; j < sz; j++) {
if (a[i] & (1 << j)) b[j]++;
}
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long sum = 0;
for (long long j = 0; j < sz; j++) {
if (b[j]) {
sum += (1 << j);
b[j]--;
}
}
ans += sum * sum;
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed;
cout.precision(30);
long long t = 1;
while (t--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[1000], t = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 0) {
t++;
}
}
if (n == 1 && t == 0) {
cout << "YES";
} else {
if (t == 1 && n > 1) {
cout << "YES";
} else {
cout << "NO";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[199];
int main() {
long long x, y, x1, y1;
int untd = -1;
cin >> x >> y;
cin >> x1 >> y1;
for (int k = 0; k <= 100; k++)
for (int j = 0; j <= 100; j++)
if (y + x * k == y1 + x1 * j) {
cout << y + x * k;
return 0;
}
cout << untd;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int w[n];
vector<pair<int, int> > vect;
vector<pair<int, int> > vect2;
int in = 0, ex = -1;
char st[2 * n];
for (int i = 0; i < n; i++) {
cin >> w[i];
vect.push_back(make_pair(w[i], i));
}
sort(vect.begin(), vect.end());
int h;
scanf("%s", st);
int u[n];
for (int i = 0; i < n; i++) {
u[i] = 0;
}
for (long long i = 0; i < 2 * n; i++) {
if (st[i] == '0') {
printf("%d ", (vect[in].second) + 1);
vect2.push_back(make_pair(vect[in].first, vect[in].second));
ex++;
h = ex;
in++;
}
if (st[i] == '1') {
printf("%d ", (vect2[ex].second) + 1);
vect2.pop_back();
ex--;
}
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int il[5];
int wyn = 0;
void printState() {}
int n;
int main() {
ios::sync_with_stdio(0);
cin >> n;
while (n--) {
int tmp;
cin >> tmp;
il[tmp]++;
}
int tmp;
if (il[1] > il[2]) {
wyn += il[2];
il[3] += il[2];
il[1] -= il[2];
il[2] = 0;
printState();
wyn += il[1] / 3 * 2;
il[3] += il[1] / 3;
il[1] = il[1] % 3;
printState();
if (il[1] == 1 && il[3] > 0) {
tmp = min(il[1], il[3]);
wyn += tmp;
il[1] -= tmp;
il[3] -= tmp;
il[4] += tmp;
} else if (il[1] == 1) {
printState();
tmp = min(1, il[4] / 2);
il[1] -= tmp;
il[4] -= 2 * tmp;
wyn += 2 * tmp;
} else if (il[1] == 2 && il[4] > 0) {
wyn += il[1];
il[4] -= il[1];
il[3] += il[1] * 2;
il[1] = 0;
} else if (il[1] == 2) {
tmp = min(il[1], il[3]);
wyn += tmp;
il[1] -= tmp;
il[3] -= tmp;
}
printState();
} else {
wyn += il[1];
il[3] += il[1];
il[2] -= il[1];
il[1] = 0;
printState();
wyn += il[2] / 3 * 2;
il[3] += il[2] / 3 * 2;
il[2] = il[2] % 3;
printState();
if (il[2] == 1 && il[4] > 0) {
il[2] = 0;
il[4] -= 1;
il[3] += 2;
wyn += 1;
} else if (il[2] == 1 && il[3] >= 2) {
il[3] -= 2;
il[2] -= 1;
il[4] += 2;
wyn += 2;
} else if (il[2] == 2) {
il[4] += 1;
il[2] -= 2;
wyn += 2;
}
printState();
}
cout << (il[2] + il[1] > 0 ? -1 : wyn) << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int maxn = 105;
int s[maxn][maxn], ans[maxn][maxn];
int dp[55][5005], f[maxn][5005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> s[i][j];
memset(ans, -1, sizeof ans);
for (int i = 0; i <= n; i++) ans[i][0] = 0;
for (int line = 1; line <= n; line++) {
memset(dp, 0, sizeof dp);
dp[0][0] = 1;
for (int i = 1; i <= m; i++) {
for (int j = m / 2; j >= 1; j--) {
for (int k = i * 70; k >= s[line][i]; k--) {
if (dp[j - 1][k - s[line][i]]) dp[j][k] = 1;
}
}
}
for (int i = 0; i <= m / 2; i++)
for (int j = 0; j <= 4900; j++)
if (dp[i][j]) ans[line][j % k] = max(ans[line][j % k], j);
}
memset(f, -1, sizeof f);
for (int i = 0; i <= n; i++) f[i][0] = 0;
for (int i = 0; i < k; i++) f[1][i] = ans[1][i];
for (int i = 2; i <= n; i++)
for (int j = 0; j < k; j++)
for (int l = i * k; l >= j; l--)
if (f[i - 1][l - j] != -1 && ans[i][j] != -1) {
f[i][l] = max(f[i][l], f[i - 1][l - j] + ans[i][j]);
}
int res = 0;
for (int i = 0; i <= n; i++) res = max(res, f[n][i * k]);
cout << res << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T getint() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * p;
}
template <typename T1, typename T2>
bool umin(T1 &x, const T2 &y) {
if (x > y) return x = y, true;
return false;
}
template <typename T1, typename T2>
bool umax(T1 &x, const T2 &y) {
if (x < y) return x = y, true;
return false;
}
const int maxn = 5e3 + 10;
const int inf = (int)1e9 + 5;
const int mod = (int)1e9 + 7;
const long long llinf = (long long)1e18 + 5;
const long double pi = acos(-1.0);
int n;
int a[maxn];
int d[maxn];
int order[maxn];
int main() {
srand(time(NULL));
cin >> n;
for (int i = (0); i < (n); i++) cin >> a[i] >> d[i], order[i] = i;
sort(order, order + n, [&](int i, int j) {
if (d[i] >= 0 && d[j] <= 0) return true;
if (d[i] <= 0 && d[j] >= 0) return false;
if (d[i] >= 0) return a[i] < a[j] || (a[i] == a[j] && i > j);
return a[i] > a[j] || (a[i] == a[j] && i < j);
});
int res = 0;
vector<pair<int, int> > z(n);
for (int i = (0); i < (n); i++) z[i] = make_pair(a[i], -i);
sort((z).begin(), (z).end());
reverse((z).begin(), (z).end());
for (int i = (0); i < (n); i++) {
int j = order[i];
int x = -1;
for (int c = (0); c < (n); c++)
if (z[c].second == -j) x = c;
z[x].first += d[j];
sort((z).begin(), (z).end());
reverse((z).begin(), (z).end());
int y = -1;
for (int c = (0); c < (n); c++)
if (z[c].second == -j) y = c;
res += abs(x - y);
}
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
if ((a + b) % 2 == 0) {
if ((a + d) == 0)
cout << "Tidak Tidak Ya Tidak"
<< "\n";
else if ((b + c) == 0)
cout << "Tidak Tidak Tidak Ya"
<< "\n";
else
cout << "Tidak Tidak Ya Ya"
<< "\n";
} else {
if ((a + d) == 0)
cout << "Tidak Ya Tidak Tidak"
<< "\n";
else if ((b + c) == 0)
cout << "Ya Tidak Tidak Tidak"
<< "\n";
else
cout << "Ya Ya Tidak Tidak"
<< "\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct MaxQ {
deque<T> D, Q;
T top() { return D.front(); }
void push(T x, int k) {
while (!D.empty() && x > D.back()) D.pop_back();
D.push_back(x);
Q.push_back(x);
}
void pop() {
if (D.front() == Q.front()) D.pop_front();
Q.pop_front();
}
T front() { return Q.front(); }
T empty() { return Q.empty(); }
T size() { return Q.size(); }
};
long long dp[5010][5010];
int n, k, x;
long long a[5111];
int main(void) {
ios_base::sync_with_stdio(false);
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
cin >> n >> k >> x;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
long long sol = -1;
for (int i = 1; i <= x; ++i) {
MaxQ<pair<long long, long long>> q;
q.push({dp[0][i - 1], 0}, k);
for (int j = 1; j <= n; ++j) {
long long mini = q.top().first;
q.push({dp[j][i - 1], j}, k);
if (q.Q.size() > k) q.pop();
if (mini == -1) continue;
dp[j][i] = max(dp[j][i], mini + a[j - 1]);
if (i == x && n - j < k) sol = max(sol, dp[j][i]);
}
}
cout << sol << endl;
return 0;
}
| 6 |
#include <stdio.h>
int t,n,d;
int min[2];
int max;
int main()
{
scanf("%d", &t);
int i,j;
for (i = 0; i < t; i++)
{
min[0] = min[1] = 10000;
max = -1;
scanf("%d %d", &n, &d);
int a;
for (j = 0; j < n; j++)
{
scanf("%d", &a);
if(a<min[0])
{
min[1] = min[0];
min[0] = a;
}
else if (a < min[1])
{
min[1] = a;
}
if (a > max) max = a;
}
if (max <= d) printf("YES\n");
else if (min[0] + min[1] <= d) printf("YES\n");
else printf("NO\n");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long a, n, m, sum = 0;
cin >> n >> m;
priority_queue<int> q;
stack<int> k;
while (n--) {
cin >> a;
if (sum + a <= m) {
cout << k.size() << " ";
q.push(a);
sum += a;
} else {
while (sum + a > m) {
int tmp = q.top();
q.pop();
k.push(tmp);
sum -= tmp;
}
cout << k.size() << " ";
while (!k.empty() && sum < m && k.top() <= a) {
int tmp = k.top();
k.pop();
q.push(tmp);
sum += tmp;
}
sum += a;
q.push(a);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
void run() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<pair<int, int> > v;
pair<int, int> p;
for (int i = 0; i < n; i++) {
v.push_back(make_pair(a[i], i));
}
sort(v.begin(), v.end());
for (int i = 1; i < n; i++) {
if (v[i].first != 0) {
if (v[i].first <= v[i - 1].first) v[i].first = v[i - 1].first + 1;
}
}
sort(v.begin(), v.end(), sortbysec);
for (int i = 0; i < n; i++) {
cout << v[i].first << " ";
}
}
int main(int argc, char **argv) {
run();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 4e5 + 10;
const ll inf = 1e18 + 10;
const ll MOD = 998244353;
string s, t;
int n, m;
int main() {
cin >> s >> t;
n = s.size(), m = t.size();
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
if (n - j + i - 1 < m) continue;
int p = 0, q = 0;
while (p < n) {
if (i <= p && p <= j) p = j + 1;
if (p < n && q < m && s[p] == t[q]) q++;
p++;
}
if (q == m) ans = max(ans, j - i + 1);
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
char w[10][30];
int main() {
int t;
for (int i = 'A'; i <= 'Z'; i++) {
w[1][i - 'A'] = i;
}
for (int i = 'a'; i <= 'z'; i++) {
w[2][i - 'a'] = i;
}
for (int i = '0'; i <= '9'; i++) {
w[3][i - '0'] = i;
}
scanf("%d", &t);
while (t--) {
int r, c, k;
char s[120][120];
char q[120][120];
scanf("%d%d%d", &r, &c, &k);
int num = 0;
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) {
scanf(" %c", &s[i][j]);
if (s[i][j] == 'R') {
num++;
}
}
}
int x = num - num / k * k;
int y = num / k;
int now = 0;
int sum = 1;
int u = 1;
int nowu = 0;
for (int i = 1; i <= r; i++) {
if (i & 1)
for (int j = 1; j <= c; j++) {
if (s[i][j] == 'R') now++;
q[i][j] = w[u][nowu];
if (sum <= x) {
if (now >= y + 1) {
sum++;
now = 0;
nowu++;
}
} else if (sum < k) {
if (now >= y) {
sum++;
now = 0;
nowu++;
}
}
if (nowu >= 26) u++, nowu -= 26;
}
else {
for (int j = c; j >= 1; j--) {
if (s[i][j] == 'R') now++;
q[i][j] = w[u][nowu];
if (sum <= x) {
if (now >= y + 1) {
sum++;
now = 0;
nowu++;
}
} else if (sum < k) {
if (now >= y) {
sum++;
now = 0;
nowu++;
}
}
if (nowu >= 26) u++, nowu -= 26;
}
}
}
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) printf("%c", q[i][j]);
printf("\n");
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
;
}
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
namespace std {
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
} // namespace std
long long int readL() {
long long int res;
scanf("%I64d", &res);
return res;
}
void printL(long long int res) { printf("%I64d", res); }
namespace std {
bool operator<(const complex<long long int>& a,
const complex<long long int>& b) {
return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
} // namespace std
long long int cross(const complex<long long int>& a,
const complex<long long int>& b) {
return imag(conj(a) * b);
}
long long int dot(const complex<long long int>& a,
const complex<long long int>& b) {
return real(conj(a) * b);
}
const double PI = acos(-1.0);
int n;
complex<long long int> ps[3005];
pair<int, double> ang[6005];
int dist[5000000];
int solve() {
int res = 0;
for (int i = 0; i < (n); ++i) {
int m = 0;
for (int j = 0; j < (n); ++j) {
ang[m++] = make_pair(norm(ps[j] - ps[i]),
atan2((double)ps[j].imag() - ps[i].imag(),
(double)ps[j].real() - ps[i].real()));
}
sort(ang, ang + m, greater<pair<int, double> >());
set<double> ever;
for (int j = 0; j < (m); ++j) {
double a = ang[j].second;
auto it = ever.lower_bound(a + PI / 3);
if (it != ever.end() && *it <= a + PI / 3 * 5) {
chmax(res, ang[j].first);
break;
}
ever.insert(a);
ever.insert(a + 2 * PI);
}
}
return res;
}
int main() {
cin >> n;
for (int i = 0; i < (n); ++i) {
int x, y;
cin >> x >> y;
ps[i].real(x);
ps[i].imag(y);
}
int res = solve();
printf("%.10f\n", sqrt((double)res) / 2);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const long long INF64 = (long long)1e18;
#pragma comment(linker, "/STACK:16777216")
#pragma warning(disable : 4786)
int Set(int N, int pos) { return N = N | (1 << pos); }
int Reset(int N, int pos) { return N = N & ~(1 << pos); }
bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
const int mx = 1 << 29;
int ans, sum, t, n, k, m, g;
priority_queue<int> q;
int main() {
cin >> n;
cin >> m;
for (int i = 1; i <= n - 1; i++) {
cin >> k;
q.push(k);
}
while (!q.empty()) {
g = q.top();
q.pop();
if (m > g) break;
m++;
g--;
ans++;
q.push(g);
}
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void chkmax(T &x, const T &y) {
if (x < y) x = y;
}
template <class T>
inline void chkmin(T &x, const T &y) {
if (x > y) x = y;
}
const int MAXN = (1 << 20);
int q;
void read() { cin >> q; }
void solve() {
while (q--) {
int n;
cin >> n;
if (n < 9 && n % 2 == 1) {
cout << -1 << '\n';
continue;
}
if (n < 4) {
cout << -1 << '\n';
continue;
}
int answer = n / 4;
if (n % 4 == 1) {
answer -= 2;
if (answer < 0) {
cout << -1 << '\n';
continue;
}
answer += 1;
cout << answer << '\n';
continue;
}
if (n % 4 == 0) {
cout << answer << '\n';
continue;
}
if (n % 4 == 2) {
cout << answer << '\n';
continue;
}
if (n % 4 == 3) {
answer -= 3;
if (answer < 0) {
cout << -1 << '\n';
continue;
}
answer += 2;
cout << answer << '\n';
continue;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, nums[5050], acum[5050], dp[5050][5050], minv[5050][5050];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &nums[i]);
acum[i] = nums[i];
if (i) acum[i] += acum[i - 1];
}
for (int i = 0; i < 5050; i++)
for (int j = 0; j < 5050; j++) {
dp[i][j] = 10000000;
if (i) minv[i][j] = 10000000;
}
dp[0][1] = 0;
minv[0][0] = 10000000;
for (int i = 1; i < n; i++) {
dp[i][i + 1] = minv[i][i + 1] = i;
for (int j = 1; j <= i; j++) {
int ini = 0, fim = i - j + 1;
while (ini <= fim) {
int mid = (ini + fim) / 2;
if (acum[i - j] - acum[i - j - mid] <= acum[i] - acum[i - j])
ini = mid + 1;
else
fim = mid - 1;
}
minv[i][j] = dp[i][j] = min(dp[i][j], minv[i - j][fim] + j - 1);
}
for (int j = 1; j < 5050; j++) minv[i][j] = min(minv[i][j], minv[i][j - 1]);
}
int ans = 10000000;
for (int i = 1; i <= n; i++) ans = min(ans, dp[n - 1][i]);
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n++;
while (1) {
vector<bool> a(10, 0);
a[n / 1000] = 1;
a[n / 100 % 10] = 1;
a[n / 10 % 10] = 1;
a[n % 10] = 1;
int sum = 0;
for (int i = 0; i <= 9; i++) sum += a[i];
if (sum == 4) break;
n++;
}
cout << n;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int> > G;
vector<bool> mark;
double dfs(int u, int p = -1) {
mark[u] = false;
double res = 0;
int cnt = 0;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (mark[v] || v == p) continue;
cnt++;
res += dfs(v, u);
}
return (cnt ? res / cnt + 1 : 0);
}
int main() {
cin >> n;
m = n - 1;
G.resize(n + 1);
mark.assign(n + 1, false);
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
cout << setprecision(7) << fixed << dfs(1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, m, i;
scanf("%d%d", &n, &m);
if (m == 3) {
if (n == 3)
printf("0 0\n0 1\n1 0\n");
else if (n == 4)
printf("0 0\n0 10\n10 0\n1 1\n");
else
printf("-1\n");
} else {
for (i = m; i >= 1; i--) printf("%d %d\n", m - i + 1, i * i);
for (i = n - m; i >= 1; i--) printf("%d %d\n", -(n - m - i + 1), -i * i);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double p[18][18], dp[18][(1 << 18)];
int main() {
int n;
double ans = 0;
scanf("%d", &n);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) scanf("%lf", &p[i][j]);
dp[0][(1 << n) - 1] = 1;
for (int x = (1 << n) - 1; x > 0; --x) {
for (int i = 0; i < n; i++) {
if ((x & (1 << i)) == 0) continue;
for (int j = 0; j < n; j++) {
if ((x & (1 << j)) > 0) continue;
int y = (x | (1 << j));
dp[i][x] = max(dp[i][x], p[i][j] * dp[i][y] + p[j][i] * dp[j][y]);
}
}
}
for (int i = 0; i < n; i++) {
ans = max(ans, dp[i][(1 << i)]);
}
printf("%.15lf\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
const int NR = 2e5 + 10;
const int MR = 3e6 + 10;
const int INF = 0x3f3f3f3f;
void Min(int& x, int y) { x = min(x, y); }
void Max(int& x, int y) { x = max(x, y); }
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int n, m, ans, S, T;
int flag[NR];
int to[MR], nxt[MR], val[MR], head[MR], tot = 1;
void add(int x, int y, int z) {
to[tot] = y, val[tot] = z, nxt[tot] = head[x], head[x] = tot++;
}
int id[MR], all;
int fid[MR];
void build(int rt, int l, int r) {
id[rt] = ++all;
fid[all] = rt;
if (l == r) {
add(id[rt], l + n, 1);
add(l + n, id[rt], 0);
return;
}
int mid = (l + r) >> 1;
build(rt * 2, l, mid), build(rt * 2 + 1, mid + 1, r);
add(id[rt], id[rt * 2], INF), add(id[rt * 2], id[rt], 0);
add(id[rt], id[rt * 2 + 1], INF), add(id[rt * 2 + 1], id[rt], 0);
}
void query(int rt, int l, int r, int L, int R, int x) {
if (l == L && r == R) {
add(x, id[rt], 1);
add(id[rt], x, 0);
return;
}
int mid = (l + r) >> 1;
if (R <= mid)
query(rt * 2, l, mid, L, R, x);
else if (L > mid)
query(rt * 2 + 1, mid + 1, r, L, R, x);
else
query(rt * 2, l, mid, L, mid, x),
query(rt * 2 + 1, mid + 1, r, mid + 1, R, x);
}
void find(int now, int& s, int pre) {
if (s) return;
if (now >= 1 && now <= n) {
s = now;
return;
}
for (int i = head[now]; i; i = nxt[i])
if (to[i] != pre && val[i]) {
find(to[i], s, now);
--val[i];
return;
}
}
int op[NR], X[NR], Y[NR], Z[NR];
int dep[NR], now[MR];
int tt[MR];
int cnt[MR], ftt[MR];
bool bfs() {
memset(dep, 0, sizeof(dep));
dep[S] = 1;
now[S] = head[S];
queue<int> q;
q.push(S);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
if (!val[i] || dep[y]) continue;
dep[y] = dep[x] + 1;
now[y] = head[y];
q.push(y);
if (y == T) return 1;
}
}
return 0;
}
int dinic(int x, int flow) {
if (!flow) return flow;
if (x == T) return flow;
int mxflow = 0;
for (int& i = now[x]; i; i = nxt[i]) {
int y = to[i];
if (val[i] && dep[y] == dep[x] + 1) {
int num = dinic(y, min(val[i], flow - mxflow));
val[i] -= num, val[i * 2 - (i ^ 1)] += num;
mxflow += num;
if (flow == mxflow) break;
if (!num) dep[y] = -1;
}
}
return mxflow;
}
int main() {
n = read(), m = read();
all = n + m;
build(1, 1, m);
T = all + 1;
for (int i = 1; i <= n; i++) {
op[i] = read();
if (op[i] == 0) {
add(S, i, 1), add(i, S, 0);
int k = read();
for (int j = 1; j <= k; j++) {
int x = read();
add(i, x + n, 1), add(x + n, i, 0);
}
}
if (op[i] == 1) {
add(S, i, 1), add(i, S, 0);
int l = read(), r = read();
query(1, 1, m, l, r, i);
}
if (op[i] == 2) {
add(S, i, 2), add(i, S, 0);
int x = read(), y = read(), z = read();
add(i, x + n, 1), add(x + n, i, 0);
add(i, y + n, 1), add(y + n, i, 0);
add(i, z + n, 1), add(z + n, i, 0);
X[i] = x, Y[i] = y, Z[i] = z;
}
}
for (int i = 1; i <= m; i++) add(i + n, T, 1), add(T, i + n, 0);
while (bfs()) ans += dinic(S, INF);
printf("%d\n", ans);
for (int i = head[T]; i; i = nxt[i]) {
if (val[i]) {
find(to[i], tt[to[i] - n], T);
}
}
for (int i = 1; i <= m; i++) cnt[tt[i]]++, ftt[tt[i]] = i;
for (int i = 1; i <= n; i++)
if (op[i] == 2) {
if (cnt[i] == 0 || cnt[i] == 2) continue;
if (ftt[i] == X[i])
ftt[tt[Y[i]]] = 0, tt[Y[i]] = i;
else
ftt[tt[X[i]]] = 0, tt[X[i]] = i;
}
for (int i = 1; i <= m; i++)
if (tt[i]) printf("%d %d\n", tt[i], i);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, s[105][105], g = 0;
int lis[105], r[105], c[105];
int gcd(int a, int b) {
if (b)
return gcd(b, a % b);
else
return a;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &s[i][j]);
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= m; j++) lis[j] = s[i][j] - s[1][j];
for (int j = 2; j <= m; j++) g = gcd(g, lis[j] - lis[j - 1]);
}
for (int j = 2; j <= m; j++) {
for (int i = 1; i <= n; i++) lis[i] = s[i][j] - s[i][1];
for (int i = 2; i <= n; i++) g = gcd(g, lis[i] - lis[i - 1]);
}
g = abs(g);
if (g == 0) {
printf("YES\n1000000007\n");
int mx = 1, my = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (s[i][j] < s[mx][my]) mx = i, my = j;
}
for (int i = 1; i <= n; i++)
printf("%d%c", s[i][my] - s[mx][my], i == n ? '\n' : ' ');
for (int i = 1; i <= m; i++) printf("%d%c", s[mx][i], i == m ? '\n' : ' ');
} else {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i][j] >= g) {
printf("NO\n");
return 0;
}
}
}
printf("YES\n%d\n", g);
for (int i = 1; i <= n; i++)
printf("%lld%c", (0LL + s[i][1] - s[1][1] + g + g) % g,
i == n ? '\n' : ' ');
for (int i = 1; i <= m; i++) printf("%d%c", s[1][i], i == n ? '\n' : ' ');
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;
long long f[maxn];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
long long ans = 1;
n *= 2;
for (int i = 3; i <= n; ++i) ans = ans * i % mod;
printf("%lld\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &num) {
T x = 0, f = 1;
char ch = getchar();
for (; ch > '9' || ch < '0'; ch = getchar())
if (ch == '-') f = -1;
for (; ch <= '9' && ch >= '0'; ch = getchar())
x = (x << 3) + (x << 1) + (ch ^ '0');
num = x * f;
}
int ttt, n, Rev, a[5005], b[5005], ca[2], cb[2], ans[5005], cnt;
char s[5005], t[5005];
void Reverse(int i) {
ans[++cnt] = i;
reverse(a + 1, a + i + 1);
}
void init() {
Rev = 0;
int I = 0, J = 0, K = 0;
for (int i = 2; i <= n; i += 2) I += (a[i - 1] == 1 && a[i] == 0);
for (int i = 2; i <= n; i += 2) J += (b[i - 1] == 1 && b[i] == 0);
K = J;
for (int i = 0; i <= n; i += 2) {
if (i > 0) I -= (a[i - 1] == 1 && a[i] == 0) - (a[i - 1] == 0 && a[i] == 1);
J = K;
for (int j = 0; j <= n; j += 2) {
if (j > 0)
J -= (b[j - 1] == 1 && b[j] == 0) - (b[j - 1] == 0 && b[j] == 1);
if (I == J) {
if (i) Reverse(i);
if (j) Rev = j, reverse(b + 1, b + j + 1);
i = j = n;
}
}
}
}
int main() {
read(ttt);
for (int tt = 1; tt <= ttt; tt++) {
scanf("%s %s", s + 1, t + 1);
n = strlen(s + 1);
cnt = 0;
for (int i = 0; i < 2; i++) ca[i] = cb[i] = 0;
for (int i = 1; i <= n; i++) {
a[i] = s[i] - '0', b[i] = t[i] - '0';
if (i % 2 == 0 && a[i - 1] == 0 && a[i] == 0) ca[0]++;
if (i % 2 == 0 && a[i - 1] == 1 && a[i] == 1) ca[1]++;
if (i % 2 == 0 && b[i - 1] == 0 && b[i] == 0) cb[0]++;
if (i % 2 == 0 && b[i - 1] == 1 && b[i] == 1) cb[1]++;
}
if (ca[0] != cb[0] || ca[1] != cb[1]) {
puts("-1");
continue;
}
init();
for (int i = 2; i <= n; i += 2) {
int j = 0;
for (j = i; j <= n; j += 2)
if (a[j - 1] == b[i - 1] && a[j] == b[i]) break;
if (j > 2) Reverse(j - 2);
if (i < n) Reverse(j);
}
if (Rev) Reverse(Rev);
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) printf("%d ", ans[i]);
puts("");
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m, c, x, k[1005];
int main() {
cin >> n >> m >> c;
while (m--) {
cin >> x;
if (x <= c / 2) {
for (int i = 1; i <= n; i++)
if (k[i] > x || !k[i]) {
k[i] = x;
cout << i << endl;
break;
}
} else
for (int i = n; i; i--)
if (k[i] < x || !k[i]) {
k[i] = x;
cout << i << endl;
break;
}
}
}
| 6 |
#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>
#include <fstream>
#include <numeric>
#include <string>
using namespace std;
using ll = long long;
int mod = 1e9+7;
vector<pair<int, int>> boygirl;
void solve(){
ll n;
cin>>n;
while(n>1){
if(n%2==1){
cout<<"YES"<<endl;
return;
}
n/=2;
}
cout<<"NO"<<endl;
return;
}
int main(){
int tests;
cin>>tests;
while(tests--){
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
cout << (n - 2) * (n - 2) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const unsigned long long base = 2333;
const int maxn = 1e3 + 50;
const int maxm = 1e3 + 50;
const int maxv = 1e6 + 5;
const int mod = 1e9 + 7;
const int ba = 3e5;
long long N;
long long a[maxn][maxn];
int main() {
scanf("%lld", &N);
for (int i = 1; i < N; i++) {
long long p = i;
for (int j = 1; j < N; j++) {
a[i][j] = p;
p++;
if (p == N) p = 1;
}
}
for (int i = 1; i < N; i++) {
a[i][N] = a[N][i] = a[i][i];
a[i][i] = 0;
}
a[N][N] = 0;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) printf("%lld ", a[i][j]);
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
if (n == 1)
cout << 0 << endl;
else if (n == 2)
cout << m << endl;
else
cout << 2 * m << endl;
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int INF = 0x3f3f3f3f;
set<pair<int, int> > heap;
int n, k, t, c[30], d[30][30];
long long rest[1 << 22];
deque<int> q[30];
int count(int x) {
int ret = 0;
while (x) {
x = x & (x - 1);
ret++;
}
return ret;
}
int have = 0;
int main() {
scanf("%d%d%d", &n, &k, &t);
string s;
cin >> s;
s = '#' + s;
for (int i = 0; i < k; ++i) scanf("%d", &c[i]);
for (int i = 0; i < k; ++i)
for (int j = 0; j < k; ++j) scanf("%d", &d[i][j]);
for (int i = 1; i <= n; ++i) {
have |= 1 << (s[i] - 'A');
q[s[i] - 'A'].push_back(i);
}
for (int i = 0; i < k; ++i) {
if (!q[i].empty()) {
heap.insert(make_pair(q[i].front(), i));
q[i].pop_front();
}
}
for (int i = 1; i <= n; ++i) {
if (!q[s[i] - 'A'].empty()) {
heap.insert(make_pair(q[s[i] - 'A'].front(), s[i] - 'A'));
q[s[i] - 'A'].pop_front();
}
heap.erase(make_pair(i, s[i] - 'A'));
int mask = 0;
for (auto it = heap.begin(); it != heap.end(); it++) {
rest[mask] += d[s[i] - 'A'][(*it).second];
rest[mask | (1 << (s[i] - 'A'))] -= d[s[i] - 'A'][(*it).second];
rest[mask | (1 << ((*it).second))] -= d[s[i] - 'A'][(*it).second];
rest[mask | (1 << ((*it).second)) | (1 << (s[i] - 'A'))] +=
d[s[i] - 'A'][(*it).second];
mask |= (1 << ((*it).second));
if ((*it).second == s[i] - 'A') break;
}
}
for (int i = 0; i < k; ++i)
for (int mask = 0; mask < 1 << k; ++mask) {
if ((mask >> i) & 1) rest[mask] += rest[mask ^ (1 << i)];
}
int rest_ = 0;
for (int i = 0; i < 1 << k; ++i) {
if ((i | have) != have) continue;
if (i == have) continue;
long long tmp = rest[i];
for (int j = 0; j < k; ++j)
if ((i >> j) & 1) tmp += c[j];
rest_ += tmp <= (long long)t;
}
cout << rest_ << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long cnt = 0;
long long l = 0;
long long h = 500000;
while (l <= h) {
long long mid = (l + h) / 2;
if (((mid * (mid - 1)) / 2) < n) {
cnt = mid;
l = mid + 1;
} else
h = mid - 1;
}
cout << "133";
if (n == 1) {
cout << "7\n";
continue;
}
long long rem = n - (cnt * (cnt - 1)) / 2;
for (long long i = 0; i < rem; i++) cout << "7";
for (long long i = 0; i < (cnt - 2); i++) cout << "3";
if (cnt > 0) cout << "7";
cout << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 505;
long long p;
long long po(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a;
if (b % 2 == 0) {
long long u = po(a, b / 2);
return (u * u) % p;
} else {
long long u = po(a, b - 1);
return (a * u) % p;
}
}
long long fact[maxn];
long long invf[maxn];
long long c3[maxn][maxn];
long long c(long long n, long long k) { return c3[n][k]; }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
cin >> p;
long long u1 = 1;
for (long long i = 0; i < maxn; ++i) {
fact[i] = u1;
u1 *= (i + 1);
u1 %= p;
}
for (long long i = 0; i < maxn; ++i) {
for (long long j = 0; j < maxn; ++j) {
if (j == 0)
c3[i][j] = 1;
else if (i == 0)
c3[i][j] = 0;
else if (i > j)
c3[i][j] = c3[i - 1][j - 1] + c3[i - 1][j];
else if (i == j)
c3[i][j] = 1;
c3[i][j] %= p;
}
}
long long dp1[n + 1];
dp1[0] = 1;
long long dp2[n + 1];
dp2[0] = 0;
for (long long i = 1; i <= n; ++i) {
dp1[i] = 0;
dp2[i] = 0;
for (long long j = 0; j < i; ++j) {
dp1[i] +=
(((((dp1[j] * dp1[i - 1 - j]) % p) * (i + 1)) % p) % p) * c(i - 1, j);
dp2[i] += ((((((dp1[j] * dp2[i - j - 1]) % p) * (i + 1) +
((dp2[j] * dp1[i - j - 1]) % p) * (i + 1) +
((dp1[j] * dp1[i - 1 - j]) % p) *
((((i - 1 - j) * (i - j) + j * (j + 1)) / 2) % p)) %
p) %
p) %
p) *
c(i - 1, j);
dp2[i] %= p;
dp1[i] %= p;
}
}
long long dp3[n + 1][n + 1];
long long dp4[n + 1][n + 1];
for (long long i = 0; i <= n; ++i) {
for (long long j = 0; j <= n; ++j) {
dp3[i][j] = 0;
dp4[i][j] = 0;
}
}
for (long long i = 0; i <= n; ++i) {
for (long long j = 0; j <= i; ++j) {
for (long long k = 0; k <= j; ++k) {
if (k != j)
dp3[i][j] += ((dp3[i - k - 1][j - k] * dp1[k]) % p) * c(j, k);
else
dp3[i][j] += dp1[k];
dp3[i][j] %= p;
if (k != j)
dp4[i][j] += ((dp4[i - k - 1][j - k] * dp1[k] +
dp2[k] * dp3[i - k - 1][j - k]) %
p) *
c(j, k);
else
dp4[i][j] += dp2[k];
dp4[i][j] %= p;
}
}
}
cout << dp4[n][m];
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 30), N = 100010;
int n, m;
inline int in() {
char ch = getchar();
int f = 1, tmp = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
tmp = (tmp << 1) + (tmp << 3) + (ch - '0');
ch = getchar();
}
return tmp * f;
}
vector<int> a[3];
inline int gi(int x) { return (x % 3 + 3) % 3; }
int main() {
n = in();
a[1].push_back(1);
a[2].push_back(0);
a[2].push_back(1);
for (int i = 3; i <= n + 1; i++) {
a[gi(i)].clear();
a[gi(i)].push_back(0);
for (int j = 0; j < a[gi(i - 1)].size(); j++)
a[gi(i)].push_back(a[gi(i - 1)][j]);
for (int j = 0; j < a[gi(i - 2)].size(); j++)
a[gi(i)][j] = (a[gi(i)][j] + a[gi(i - 2)][j]) % 2;
}
cout << a[gi(n + 1)].size() - 1 << endl;
for (int i = 0; i < a[gi(n + 1)].size(); i++) cout << a[gi(n + 1)][i] << " ";
cout << endl;
cout << a[gi(n)].size() - 1 << endl;
for (int i = 0; i < a[gi(n)].size(); i++) cout << a[gi(n)][i] << " ";
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = (1uLL << 63) - 1;
const long long mod = 1000000007;
const int N = 150 + 5;
const double Pi = acos(-1.0);
const int maxn = 1e6 + 5;
int Q[maxn << 1];
char ch[11];
int num;
inline void out(int x) {
num = 0;
while (x) ch[++num] = x % 10, x /= 10;
while (num) putchar(ch[num--] + 48);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) Q[i] = i;
for (int i = 2; i <= n; i++) {
int x = 0;
for (int j = i - 1; j < n + i - 1; j += i) {
swap(x, Q[j]);
}
Q[n + i - 1] = x;
}
for (int i = n; i < n << 1; i++) {
out(Q[i]);
putchar(' ');
}
}
| 7 |
#include <bits/stdc++.h>
int main() {
int n;
char kata[1005];
char find[1005];
scanf("%d", &n);
getchar();
for (int i = 0; i < n; i++) {
scanf("%c", &kata[i]);
}
getchar();
for (int i = 0; i < n; i++) {
scanf("%c", &find[i]);
}
int total = 0;
int a, b, sum;
for (int i = 0; i < n; i++) {
a = kata[i] - find[i];
if (a < 0) a = a * -1;
if (a > 5) {
sum = 10 - a;
} else
sum = a;
total += sum;
}
printf("%d\n", total);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, K, A[150005];
bool mark[150005];
map<int, string> M;
string name;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> K;
int cont = 0;
char a, b;
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++) {
a = i + 'A';
b = j + 'a';
name = "";
name += a;
name += b;
M[++cont] = name;
}
for (int i = 1; i < K; i++) A[i] = i;
char tmp[5];
for (int i = K; i <= N; i++) {
cin >> tmp;
if (tmp[0] == 'Y')
A[i] = i;
else
A[i] = A[i - K + 1];
}
for (int i = 1; i <= N; i++) {
cout << M[A[i]];
if (i != N) cout << ' ';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, T, at[1000000], m, pj[1000000], precalc[1000000];
double c;
int main() {
cin >> n >> T >> c;
for (long long i = 0; i < n; ++i) {
cin >> at[i];
if (i == 0) {
precalc[i] = at[i];
} else {
precalc[i] = precalc[i - 1] + at[i];
}
}
cin >> m;
for (long long i = 0; i < m; ++i) {
cin >> pj[i];
}
double mean = 0.0;
double real = 0.0;
long long k = 0;
for (long long i = 0; i < n; ++i) {
mean = (mean + double(at[i]) / double(T)) / c;
if (i + 1 == pj[k]) {
real = precalc[pj[k] - 1];
if (pj[k] - T - 1 >= 0) {
real -= precalc[pj[k] - T - 1];
}
double rr = real / double(T);
double err = abs(mean - rr) / rr;
printf("%.6f %.6f %.6f\n", rr, mean, err);
k++;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1001;
int main() {
int M, K;
int d[MAXN], s[MAXN];
while (2 == scanf("%d%d", &M, &K)) {
for (int i = 0; i < M; i++) {
scanf("%d", &d[i]);
}
for (int i = 0; i < M; i++) {
scanf("%d", &s[i]);
}
int fuel = s[0];
int time = d[0];
int index = 0;
while (fuel < d[0]) {
fuel += s[0];
time += K;
}
for (int i = 1; i < M; i++) {
fuel -= d[i - 1];
fuel += s[i];
time += d[i];
if (s[i] > s[index]) index = i;
while (fuel < d[i]) {
fuel += s[index];
time += K;
}
}
printf("%d\n", time);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
template <typename T>
void read(T &x) {
int ch = getchar();
x = 0;
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
}
template <typename T>
bool chmin(T &a, const T &b) {
if (a > b) return a = b, 1;
return 0;
}
template <typename T>
bool chmax(T &a, const T &b) {
if (a < b) return a = b, 1;
return 0;
}
int q, k, n;
long long F[6], f[N];
void ins(int v, long long w) {
for (int i = N - 1; i >= v; --i) chmax(f[i], f[i - v] + w);
}
int main() {
read(k);
k = 3 * (k - 1);
for (int i = 0; i < 6; ++i) read(F[i]);
for (int i = 0; i < N; ++i) {
int tmp = i;
for (int j = 0; tmp; ++j, tmp /= 10) {
int d = tmp % 10;
if (!(d % 3)) f[i] += d / 3 * F[j];
}
}
for (int i = 0, pw = 3; i < 6; ++i, pw *= 10) {
int c = min(k, N / pw);
for (int j = 1; c > j; j <<= 1) {
c -= j;
ins(pw * j, F[i] * j);
}
ins(pw * c, F[i] * c);
}
read(q);
while (q--) {
read(n);
printf("%lld\n", f[n]);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e18 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
long long n = s.size();
long long lower[n + 2], upper[n + 2];
lower[0] = upper[n + 1] = 0;
for (int i = 1; i <= n; ++i) {
lower[i] = lower[i - 1];
if (islower(s[i - 1])) lower[i]++;
}
for (int i = n; i > 0; i--) {
upper[i] = upper[i + 1];
if (isupper(s[i - 1])) upper[i]++;
}
long long m = mod;
for (int i = 1; i <= n; ++i) m = min(m, lower[i] + upper[i] - 1);
cout << m;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.