solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2 * 100000 + 10;
int cows[Maxn] = {0};
int tozi[Maxn] = {0};
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> cows[i];
tozi[0] = cows[0];
for (int i = 1; i < n; i++) tozi[i] = tozi[i - 1] + cows[i];
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (!cows[i]) ans += tozi[i];
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
const int MAXM = 300000;
struct node {
int key, id, rev;
int siz1, siz2, s;
node *fa, *ch[2], *mx;
} tree[MAXN + MAXM + 5], *ad[MAXN + MAXM + 5];
struct edge {
int u, v, w, id;
edge(int _u = 0, int _v = 0, int _w = 0, int _i = 0)
: u(_u), v(_v), w(_w), id(_i) {}
} e[MAXM + 5];
bool operator<(edge a, edge b) {
if (a.w == b.w) return a.id < b.id;
return a.w < b.w;
}
set<edge> Set;
set<edge>::iterator it;
node *NIL, *ncnt;
void Init() {
NIL = ncnt = &tree[0];
NIL->fa = NIL->ch[0] = NIL->ch[1] = NIL->mx = NIL;
NIL->key = -1;
}
bool IsRoot(node *x) {
return (x->fa == NIL) || (x->fa->ch[0] != x && x->fa->ch[1] != x);
}
void SetChild(node *x, node *y, int d) {
x->ch[d] = y;
if (y != NIL) y->fa = x;
}
node *NewNode(int k, int id, int s) {
ncnt++;
ncnt->key = k, ncnt->id = id, ncnt->s = ncnt->siz1 = s;
ncnt->fa = ncnt->ch[0] = ncnt->ch[1] = NIL;
ncnt->mx = ncnt;
return ncnt;
}
void PushDown(node *x) {
if (x->rev) {
swap(x->ch[0], x->ch[1]);
if (x->ch[0] != NIL) x->ch[0]->rev ^= 1;
if (x->ch[1] != NIL) x->ch[1]->rev ^= 1;
x->rev = 0;
}
}
node *max(node *x, node *y) {
if (x->key < y->key) return y;
return x;
}
void PushUp(node *x) {
x->mx = max(x, max(x->ch[0]->mx, x->ch[1]->mx));
x->siz1 = x->s + x->ch[0]->siz1 + x->ch[1]->siz1 + x->siz2;
}
void Rotate(node *x) {
node *y = x->fa;
PushDown(y), PushDown(x);
int d = (y->ch[1] == x);
if (IsRoot(y))
x->fa = y->fa;
else
SetChild(y->fa, x, y->fa->ch[1] == y);
SetChild(y, x->ch[!d], d);
SetChild(x, y, !d);
PushUp(y);
}
void Splay(node *x) {
node *y = x;
stack<node *> stk;
while (!IsRoot(y)) stk.push(y), y = y->fa;
stk.push(y);
while (!stk.empty()) PushDown(stk.top()), stk.pop();
while (!IsRoot(x)) {
y = x->fa;
if (IsRoot(y))
Rotate(x);
else {
if ((y->fa->ch[1] == y) == (y->ch[1] == x))
Rotate(y);
else
Rotate(x);
Rotate(x);
}
}
PushUp(x);
}
void Access(node *x) {
node *y = NIL;
while (x != NIL) {
Splay(x);
x->siz2 += x->ch[1]->siz1;
SetChild(x, y, 1);
x->siz2 -= x->ch[1]->siz1;
PushUp(x);
y = x, x = x->fa;
}
}
void MakeRoot(node *x) {
Access(x), Splay(x);
x->rev ^= 1;
}
void Link(node *x, node *y) {
MakeRoot(x);
MakeRoot(y);
x->fa = y;
y->siz2 += x->siz1;
}
void Cut(node *x, node *y) {
MakeRoot(x);
Access(y), Splay(y);
y->ch[0] = x->fa = NIL;
PushUp(y);
}
node *FindRoot(node *x) {
Access(x), Splay(x);
while (x->ch[0] != NIL) x = x->ch[0];
return x;
}
node *QueryMAX(node *x, node *y) {
MakeRoot(x);
Access(y);
Splay(y);
return y->mx;
}
int n, m, stot;
void Debug() {
for (it = Set.begin(); it != Set.end(); it++)
printf("(%d, %d, %d)\n", it->u, it->v, it->w);
}
int main() {
Init();
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) ad[i] = NewNode(-1, -1, 1);
stot = n;
for (int i = 1; i <= m; i++) {
e[i].id = i;
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
if (e[i].u == e[i].v) continue;
ad[n + i] = NewNode(e[i].w, i, 0);
Set.insert(e[i]);
if (FindRoot(ad[e[i].u]) == FindRoot(ad[e[i].v])) {
node *p = QueryMAX(ad[e[i].u], ad[e[i].v]);
if (p->key > e[i].w) {
Set.erase(e[p->id]);
Cut(p, ad[e[p->id].u]), Cut(p, ad[e[p->id].v]);
Link(ad[e[i].u], ad[n + i]), Link(ad[e[i].v], ad[n + i]);
} else
Set.erase(e[i]);
} else {
MakeRoot(ad[e[i].u]), MakeRoot(ad[e[i].v]);
if (ad[e[i].u]->siz1 % 2 == 1 && ad[e[i].v]->siz1 % 2 == 1) stot -= 2;
Link(ad[e[i].u], ad[n + i]), Link(ad[e[i].v], ad[n + i]);
}
if (stot == 0) {
it = Set.end();
it--;
while (true) {
node *p = ad[n + it->id], *q = ad[e[it->id].u], *r = ad[e[it->id].v];
MakeRoot(p);
Access(q);
Access(r);
if (q->siz1 & 1) break;
Access(q);
if (r->siz1 & 1) break;
Set.erase(it);
Cut(p, q);
Cut(p, r);
it = Set.end();
it--;
}
it = Set.end();
it--;
printf("%d\n", it->w);
} else
printf("-1\n");
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
register int data = 0, w = 1;
register char ch = 0;
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (isdigit(ch)) data = 10 * data + ch - '0', ch = getchar();
return w * data;
}
void chkmax(int &x, int y) {
if (x < y) x = y;
}
const int MAX_N = 3e5 + 5;
struct Cloud {
int l, r, c;
} cld[MAX_N];
bool operator<(const Cloud &l, const Cloud &r) { return l.c < r.c; }
struct Query {
int id, t;
} q[MAX_N];
bool operator<(const Query &l, const Query &r) { return l.t < r.t; }
struct Node {
int t, op, id;
} a[MAX_N << 1];
int tot = 0;
bool operator<(const Node &l, const Node &r) { return l.t < r.t; }
int N, M, C, single[MAX_N], opt[MAX_N], ans[MAX_N];
map<int, int> cross[MAX_N];
set<int> s;
set<int>::iterator ite;
int Free, Top;
int mx[MAX_N << 2];
void modify(int o, int l, int r, int pos, int v) {
if (l == r) return (void)(mx[o] = v);
int mid = (l + r) >> 1;
if (pos <= mid)
modify((o << 1), l, mid, pos, v);
else
modify((o << 1 | 1), mid + 1, r, pos, v);
mx[o] = max(mx[(o << 1)], mx[(o << 1 | 1)]);
}
int find(int o, int l, int r) {
if (l == r) return l;
int mid = (l + r) >> 1;
if (mx[(o << 1)] > mx[(o << 1 | 1)])
return find((o << 1), l, mid);
else
return find((o << 1 | 1), mid + 1, r);
}
int query(int o, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return find(o, l, r);
int mid = (l + r) >> 1, res = 0;
if (ql <= mid) res = query((o << 1), l, mid, ql, qr);
if (qr > mid) {
int tmp = query((o << 1 | 1), mid + 1, r, ql, qr);
if (single[tmp] > single[res]) res = tmp;
}
return res;
}
int sum(int x, int y) {
if (x > y) swap(x, y);
return single[x] + single[y] + cross[x][y];
}
void solve() {
int now = 0, pos = 1;
for (int i = 1; i <= tot; i++) {
int dlt = a[i].t - now;
now = a[i].t;
if (!s.size())
Free += dlt;
else if (s.size() == 1) {
ite = s.upper_bound(0);
int x = *ite;
single[x] += dlt;
modify(1, 1, N, x, single[x]);
opt[x] += dlt;
int rem = C - cld[x].c;
if (rem >= 0) {
int val = single[x];
if (rem >= cld[1].c) {
int l = 1, r = N, res = 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (cld[mid].c <= rem)
res = mid, l = mid + 1;
else
r = mid - 1;
}
int ql = 1, qr = res;
if (x == qr) --qr;
if (x < qr) {
ql = x + 1;
if (ql <= qr) chkmax(val, sum(x, query(1, 1, N, ql, qr)));
ql = 1, qr = x - 1;
}
if (ql <= qr) chkmax(val, sum(x, query(1, 1, N, ql, qr)));
}
chkmax(opt[x], val);
chkmax(Top, opt[x]);
}
} else if (s.size() == 2) {
ite = s.upper_bound(0);
int x = *ite;
++ite;
int y = *ite;
if (cross[x].count(y) > 0)
cross[x][y] += dlt;
else
cross[x][y] = dlt;
if (cld[x].c + cld[y].c <= C) {
chkmax(opt[x], sum(x, y));
chkmax(opt[y], sum(x, y));
chkmax(Top, opt[x]);
}
}
while (pos <= M && Top + Free >= q[pos].t)
ans[q[pos].id] = now - (Top + Free - q[pos].t), ++pos;
if (pos > M) break;
if (a[i].op == 1)
s.insert(a[i].id);
else
s.erase(a[i].id);
}
}
int main() {
N = gi(), C = gi();
for (int i = 1; i <= N; i++)
cld[i].l = gi(), cld[i].r = gi(), cld[i].c = gi();
sort(&cld[1], &cld[N + 1]);
for (int i = 1; i <= N; i++) {
a[++tot] = (Node){cld[i].l, 1, i};
a[++tot] = (Node){cld[i].r, -1, i};
}
sort(&a[1], &a[tot + 1]);
a[++tot] = (Node){(int)(2e9 + 7), 1, N + 1};
M = gi();
for (int i = 1; i <= M; i++) q[i].id = i, q[i].t = gi();
sort(&q[1], &q[M + 1]);
solve();
for (int i = 1; i <= M; i++) printf("%d\n", ans[i]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int a[1000007];
char s[1000007];
int v[1000007];
int main() {
gets(s);
int la = strlen(s);
v[0] = 1;
int count = 1;
int jia = 1;
int jian = 0;
int i;
for (i = 1; i < la; i++) {
if (s[i] == '+') {
v[count++] = 1;
jia++;
} else if (s[i] == '-') {
v[count++] = -1;
jian++;
}
if (s[i] == '=') break;
}
int n = 0;
for (; i < la; i++) {
if (s[i] >= '0' && s[i] <= '9') n = n * 10 + s[i] - '0';
}
int sum = jia - jian;
for (int i = 0; i < count; i++) a[i] = 1;
for (int i = 0; i < count; i++) {
while (sum < n && a[i] < n && v[i] == 1) {
a[i]++;
sum++;
}
while (sum > n && a[i] < n && v[i] == -1) {
a[i]++;
sum--;
}
}
if (sum != n)
printf("Impossible\n");
else {
printf("Possible\n");
printf("%d", a[0]);
for (int i = 1; i < count; i++) {
if (v[i] > 0)
printf(" + %d", a[i]);
else
printf(" - %d", a[i]);
}
printf(" = %d\n", n);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, sum, dp[1 << 16], arc[16][16], d[16];
void Floyd() {
int k, i, j;
for (k = 0; k < n; k++)
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) arc[i][j] = min(arc[i][j], arc[i][k] + arc[k][j]);
}
int getans() {
int i, j, x, t, totol;
if (d[0] == 0) {
for (i = 1; i < n; i++)
if (d[i]) return -1;
return 0;
}
Floyd();
for (i = 1; i < n; i++)
if (d[i] && arc[0][i] > 1000000007) return -1;
for (i = 0; i < n; i++)
if (d[i] % 2) break;
if (i == n) return sum;
memset(dp, 0x7f, sizeof(dp));
dp[0] = 0;
totol = (1 << n) - 1;
for (t = 0; t <= totol; t++) {
for (i = 0; i < n; i++)
if (d[i] % 2 && (t & (1 << i))) break;
if (i == n) dp[t] = 0;
for (i = 0; i < n; i++)
if (d[i] % 2 && !(t & (1 << i)))
for (j = i + 1; j < n; j++)
if (d[j] % 2 && !(t & (1 << j)) && arc[i][j] < 1000000007)
dp[t | (1 << i) | (1 << j)] =
min(dp[t | (1 << i) | (1 << j)], dp[t] + arc[i][j]);
}
if (dp[totol] > 1000000007) return -1;
return sum + dp[totol];
}
int main() {
int m;
while (~scanf("%d%d", &n, &m)) {
sum = 0;
memset(arc, 0x3f, sizeof(arc));
memset(d, 0, sizeof(d));
for (int i = 1; i <= m; i++) {
int x, y, l;
scanf("%d%d%d", &x, &y, &l);
sum += l;
x--, y--;
arc[y][x] = arc[x][y] = min(arc[x][y], l);
d[x]++, d[y]++;
}
printf("%d\n", getans());
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int p1, p2, p3, p4, a, b;
int main() {
cin >> p1 >> p2 >> p3 >> p4 >> a >> b;
int ans = 0;
int p = min(p1, p2);
p = min(p, p3);
p = min(p, p4);
if (b < p) {
cout << b - a + 1 << "\n";
return 0;
}
if (p - a > 0) {
ans = p - a;
}
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> p;
const int mod = 1000000009;
int fs(int x) { return (p[x] == x ? x : p[x] = fs(p[p[x]])); }
int main() {
int n, m;
scanf("%d %d", &n, &m);
p.resize(n + 1);
for (int i = 0; i <= n; ++i) p[i] = i;
int a, b, ans = 1;
for (int i = 0; i < m; ++i) {
scanf("%d %d", &a, &b);
a = fs(a), b = fs(b);
if (a == b) {
ans <<= 1;
if (ans >= mod) ans -= mod;
} else {
if (rand() & 1)
p[a] = b;
else
p[b] = a;
}
printf("%d\n", ans - 1);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const string FILENAME = "input";
const int MAXN = 2e5 + 1;
const long long INF = 1e18 + 1;
int n, m;
bitset<501> used[71][2][501];
long long dp[71][2][501];
long long sum(long long a, long long b) {
if ((a + b) >= INF) return INF;
return a + b;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = m; i--;) {
int a, b, c;
cin >> a >> b >> c;
--a, --b;
used[0][c][a][b] = true;
}
for (int len = 0; len <= 61; ++len) {
for (int c = 0; c < 2; ++c) {
for (int i = 0; i < n; ++i) {
bool OK = false;
for (int j = 0; j < n; ++j) {
if (used[len][c][i][j]) {
OK = true;
used[len + 1][c][i] |= used[len][!c][j];
}
}
if (OK) {
dp[len][c][i] = sum(1LL << len, 0);
} else {
if (len != 0) {
long long M = 0;
for (int j = 0; j < n; ++j) {
if (used[len - 1][c][i][j]) M = max(M, dp[len - 1][!c][j]);
}
dp[len][c][i] = sum(dp[len - 1][c][i], M);
}
}
}
}
}
if (dp[61][0][0] == INF) {
cout << -1 << endl;
} else {
cout << dp[61][0][0] << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool get(vector<long long> &a, int n, long long h, long long k) {
long long sm = 0, end = a[sm] + k - 1;
long long ans = 0;
for (int i = 1; i < n; i++) {
if (end < a[i]) {
ans += (end - a[sm] + 1);
sm = i;
}
end = a[i] + k - 1;
}
ans += (end - a[sm] + 1);
return (ans >= h);
}
long long fun(vector<long long> &a, int n, long long h) {
long long mn = 1, mx = h;
while (mn <= mx) {
long long mid = (mn + mx) / 2ll;
if (get(a, n, h, mid))
mx = mid - 1;
else
mn = mid + 1;
}
return mn;
}
int32_t main() {
int t;
cin >> t;
while (t--) {
int n;
long long h;
cin >> n >> h;
vector<long long> a(n + 1);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
a[n] = LONG_MAX;
if (n >= h)
cout << 1 << endl;
else
cout << fun(a, n, h) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
const int MAXS = 10005;
int N, X;
int C[MAXN];
double dp[MAXN][MAXS];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> X;
for (int i = 0; i < N; i++) cin >> C[i];
dp[0][0] = 1;
for (int k = 0; k < N; k++)
for (int i = k; i >= 0; i--)
for (int s = MAXS - C[k] - 1; s >= 0; s--)
if (dp[i][s] > 0) dp[i + 1][s + C[k]] += dp[i][s] * (i + 1) / (N - i);
double ans = 0;
for (int i = 1; i <= N; i++)
for (int s = 1; s < MAXS; s++)
if (dp[i][s] > 0)
ans += dp[i][s] * min(1.0 * s / i, (1.0 * N / i + 1) * X / 2);
cout << fixed << setprecision(10) << ans << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 100010;
const int INF = 2147483600;
int N, M, K;
int f[110];
char str[310];
int mx = 0;
int tg = 0;
int main() {
N = read(), M = read(), K = read() + 1;
int nx = 0, ny = 0;
bool flag = 0;
for (int i = 1; i <= N; i++) {
int X = 0, Y = 0;
scanf("%s", str + 1);
int cntg = 0, cntr = 0;
for (int j = 1; j <= M; j++) {
if (str[j] == 'G') X = j, ++cntg;
if (str[j] == 'R') Y = j, ++cntr;
}
if (cntg != M) nx |= X;
if (cntr != M) ny |= Y;
if (!X || !Y) continue;
flag = 1;
int D = max(X, Y) - min(X, Y) - 1, n = 0;
tg ^= D;
while (D) {
f[n] += (D % 2);
f[n] %= K;
++n;
D >>= 1;
}
mx = max(mx, n);
cout << endl;
}
if (!flag) {
if (nx && ny) {
puts("Draw");
return 0;
} else if (nx) {
puts("First");
return 0;
} else
puts("Second");
return 0;
}
for (int i = 0; i < mx; i++) {
if (f[i]) {
puts("First");
return 0;
}
}
puts("Second");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long double EPS = 1e-10;
const long long INF = 1e18;
const long double PI = acos(-1.0L);
vector<int> paths[1005];
int N;
int ret;
void query(int a, int b) {
cout << "? " << a << " " << b << endl;
cin >> ret;
}
vector<int> v;
void dfs(int now, int from) {
v.push_back(now);
for (auto to : paths[now]) {
if (to == from) continue;
dfs(to, now);
}
}
bool CUT(int root, int now, int from, int t) {
if (now == t) return true;
for (auto to : paths[now]) {
if (to == from) continue;
if (CUT(root, to, now, t)) {
if (root == now) {
auto itr = lower_bound(paths[now].begin(), paths[now].end(), to);
paths[now].erase(itr);
}
return true;
}
}
return false;
}
bool END = false;
void solve(int root) {
v.clear();
dfs(root, -1);
if (v.size() == 1) {
cout << "! " << root << endl;
END = true;
return;
}
if (v.size() == 2) {
query(v[0], v[1]);
cout << "! " << ret << endl;
END = true;
return;
}
bool ok = false;
for (int i = 0; i < v.size(); i++) {
if (ok) break;
for (int j = 0; j < i; j++) {
if (ok) break;
auto itr = lower_bound(paths[v[i]].begin(), paths[v[i]].end(), v[j]);
if (itr == paths[v[i]].end() or *itr != v[j]) {
query(v[i], v[j]);
if (ret == v[i]) {
CUT(v[i], v[i], -1, v[j]);
}
if (ret == v[j]) {
CUT(v[j], v[j], -1, v[i]);
}
if (ret != v[i] and ret != v[j]) {
CUT(ret, ret, -1, v[i]);
CUT(ret, ret, -1, v[j]);
}
ok = true;
}
}
}
}
int main() {
cin >> N;
for (int i = 0; i < N - 1; i++) {
int a, b;
cin >> a >> b;
paths[a].push_back(b);
paths[b].push_back(a);
}
for (int i = 1; i <= N; i++) {
sort(paths[i].begin(), paths[i].end());
}
ret = 1;
while (true) {
solve(ret);
if (END) break;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct $ {
$() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
} $;
const int Maxn = 20005;
int dp[Maxn][5];
int main() {
int n, k;
string s;
cin >> s;
n = s.length();
if (n < 7) {
cout << 0 << endl;
return 0;
}
s += "###";
if (n - 2 >= 5) dp[n - 2][2] = 1;
if (n - 3 >= 5) dp[n - 3][3] = 1;
for (int i = n - 4; i >= 5; i--) {
if (s.substr(i, 2) != s.substr(i + 2, 2)) {
dp[i][2] = (dp[i + 2][2] | dp[i + 2][3]);
} else {
dp[i][2] = dp[i + 2][3];
}
if (s.substr(i, 3) != s.substr(i + 3, 3)) {
dp[i][3] = (dp[i + 3][2] | dp[i + 3][3]);
} else {
dp[i][3] = dp[i + 3][2];
}
}
set<string> S;
for (int i = 5; i < n; i++) {
if (dp[i][2]) S.insert(s.substr(i, 2));
if (dp[i][3]) S.insert(s.substr(i, 3));
}
k = S.size();
cout << k << endl;
for (auto str : S) {
cout << str << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long t, n;
cin >> t;
while (t--) {
cin >> n;
bool flag = 0;
for (long i = 0; 3 * i <= n; i++)
if ((n - (3 * i)) % 7 == 0) {
flag = 1;
break;
}
if (flag)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T>
using V = vector<T>;
template <class T, class U>
using P = pair<T, U>;
using vll = V<ll>;
using vvll = V<vll>;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
constexpr ll MOD = 1000000007;
constexpr ll HIGHINF = (ll)1e18;
constexpr int INF = 1e9;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
int hn = (n + 1) / 2;
vll a(hn);
for (int i = 0; i < hn; i++) cin >> a[i];
ll x;
cin >> x;
vll m(hn + 1, 0);
ll pres = 0;
for (int i = 0; i < hn; i++) {
pres += x - a[i];
m[i + 1] = min(m[i], pres);
}
ll tmp = 0;
for (int i = 0; i < hn; i++) tmp += a[i];
for (int i = hn; i <= n; i++) {
if (tmp + m[n - i] > 0) {
cout << i << '\n';
return 0;
}
tmp += x;
}
cout << -1 << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int i, x = 0, y = 0, l;
char s[1000005];
scanf("%s", s);
l = strlen(s);
for (i = 0; i < l; i++) {
if (s[i] == 'x')
x++;
else
y++;
}
if (x > y)
for (i = 1; i <= x - y; i++) printf("x");
else
for (i = 1; i <= y - x; i++) printf("y");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int GCD(int a, int b) {
if (a % b == 0) {
return b;
}
return GCD(b, a % b);
}
int main() {
int n, z = 0, x, y, j, sum, m;
cin >> n;
for (j = 2; j < n; j++) {
sum = 0;
m = n;
while (m) {
sum += (m % j);
m /= j;
}
z += sum;
}
x = GCD(z, n - 2);
z = z / x;
y = (n - 2) / x;
cout << z << "/" << y << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
while (true) {
int tmp = n;
bool f = true;
while (tmp) {
if (tmp % 3 == 2) {
f = false;
break;
}
tmp /= 3;
}
if (!f)
n++;
else
break;
}
cout << n << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> kol(n, 0);
int ind = 0, ind_max = 0, tmp = -1, max = -1, n1;
while (m) {
n1 = n;
max = -1;
ind = 0;
while (n1) {
cin >> tmp;
if (tmp > max) {
max = tmp;
ind_max = ind;
}
ind++;
n1--;
}
kol[ind_max]++;
m--;
}
ind = 0;
for (int i = 0; i < n; ++i) {
if (kol[i] > kol[ind]) {
ind = i;
}
}
ind++;
cout << ind;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
const int N = 100;
const int M = 1000;
int dp[N][N][M];
int main() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < M; k++) {
dp[i][j][k] = -2;
}
}
}
int n, m, f;
cin >> n >> m >> f;
int a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c;
cin >> c;
a[n - i - 1][j] = c - '0';
}
}
for (int j = 0; j < m; j++) {
dp[0][j][a[0][j]] = -1;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < M; k++) {
int val = k - a[i][j];
if (val < 0) {
continue;
}
if (j != 0) {
if (dp[i - 1][j - 1][val] != -2) {
dp[i][j][k] = 1;
}
}
if (j != m - 1) {
if (dp[i - 1][j + 1][val] != -2) {
dp[i][j][k] = 0;
}
}
}
}
}
int ans = -1, pos;
for (int j = 0; j < m; j++) {
for (int k = M - 1; k >= 0; k--) {
if (dp[n - 1][j][k] != -2 && k % (f + 1) == 0 && k > ans) {
ans = k;
pos = j;
break;
}
}
}
cout << ans << "\n";
if (ans == -1) {
return 0;
}
string s;
int first = n - 1, second = pos;
int cur = a[first][second];
while (first > 0) {
if (dp[first][second][ans] == 1) {
ans -= a[first][second];
second--;
s += "R";
} else if (dp[first][second][ans] == 0) {
ans -= a[first][second];
second++;
s += "L";
}
first--;
cur += a[first][second];
}
cout << second + 1 << "\n";
reverse((s).begin(), (s).end());
cout << s;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 7005;
const int M = 110000;
const int mod = 1e9 + 7;
int lft[M], rt[M], n, m;
void init() {
int go = 1;
memset(lft, -1, sizeof lft);
memset(rt, -1, sizeof rt);
for (int i = 1; i < M; i++) {
if (i == (i & -i)) {
lft[i] = go++;
rt[i] = go++;
} else
rt[i] = go++;
}
}
bool intersect(int l1, int r1, int l2, int r2) {
return max(l1, l2) <= min(r1, r2);
}
int pos[1000005];
vector<vector<pair<int, pair<int, int>>>> vp;
int L[N], R[N];
int main() {
init();
scanf("%d%d", &n, &m);
memset(pos, -1, sizeof pos);
while (m--) {
int tp, t, l, r, x, v;
scanf("%d", &tp);
if (tp == 1) {
scanf("%d%d%d%d", &t, &l, &r, &x);
if (pos[x] == -1)
pos[x] = vp.size(), vp.push_back(vector<pair<int, pair<int, int>>>());
x = pos[x];
vp[x].push_back(make_pair(t, make_pair(l, r)));
} else {
scanf("%d%d", &t, &v);
memset(L, -1, sizeof L);
memset(R, -1, sizeof R);
int take = v;
for (int i = t; i <= n; i++) {
L[i] = take;
if (~lft[take])
take = lft[take];
else
take = rt[take];
}
take = v;
for (int i = t; i <= n; i++) {
R[i] = take;
take = rt[take];
}
int ans = 0;
for (int i = 0; i < vp.size(); i++) {
for (auto x : vp[i])
if (intersect(L[x.first], R[x.first], x.second.first,
x.second.second)) {
ans++;
break;
}
}
printf("%d\n", ans);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, y[100004], x[100004], a;
int main() {
cin >> n >> m;
int k, v;
cin >> k >> v;
for (int i = 0; i < n; i++) cin >> x[i];
for (int j = 0; j < m; j++) cin >> y[j];
for (int i = m - 1; i >= m - v; i--) {
if (y[i] <= x[k - 1]) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 0.000000000000001;
string convertstring(long long n) {
stringstream ss;
ss << n;
return ss.str();
}
int U[400005], V[400005], disc[400005], low[400005], t, comp_no[400005],
comp_sz[400005];
bool is_bridge[400005];
vector<int> g[400005];
int adj(int u, int edge_id) { return U[edge_id] ^ V[edge_id] ^ u; }
void tarjan(int src, int par_edge) {
disc[src] = low[src] = ++t;
for (int i = 0; i < g[src].size(); ++i) {
int edge_id = g[src][i];
if (edge_id == par_edge) continue;
int v = adj(src, edge_id);
if (!disc[v]) {
tarjan(v, edge_id);
low[src] = min(low[src], low[v]);
if (low[v] > disc[src]) is_bridge[edge_id] = 1;
} else {
low[src] = min(low[src], disc[v]);
}
}
}
int c_id, outdeg[400005];
vector<int> btree[400005];
vector<pair<int, pair<int, int> > > poop;
bool marked[400005];
void bridge_tree(int src) {
comp_no[src] = c_id;
comp_sz[c_id]++;
for (int i = 0; i < g[src].size(); ++i) {
int edge_id = g[src][i];
if (is_bridge[edge_id]) continue;
int v = adj(src, edge_id);
if (!marked[edge_id])
poop.push_back(make_pair(edge_id, make_pair(src, v))),
marked[edge_id] = 1;
if (!comp_no[v]) bridge_tree(v);
}
}
int llev[400005];
void DFS(int src, int par, int l) {
llev[src] = l;
for (int i = 0; i < btree[src].size(); ++i) {
if (btree[src][i] != par) DFS(btree[src][i], src, l + 1);
}
}
int main() {
int n, m, i, j;
scanf("%d%d", &n, &m);
;
for (i = 1; i <= m; ++i) {
scanf("%d%d", &U[i], &V[i]);
;
g[U[i]].push_back(i);
g[V[i]].push_back(i);
}
for (i = 1; i <= n; ++i) {
if (!disc[i]) tarjan(i, 0);
}
int mx = 0, ind = -1;
for (i = 1; i <= n; ++i) {
if (!comp_no[i]) {
++c_id;
bridge_tree(i);
if (comp_sz[c_id] > mx) {
mx = comp_sz[c_id];
ind = c_id;
}
}
}
printf("%d\n", mx);
for (i = 1; i <= m; ++i) {
if (is_bridge[i]) {
btree[comp_no[U[i]]].push_back(comp_no[V[i]]);
btree[comp_no[V[i]]].push_back(comp_no[U[i]]);
}
}
if (ind != -1) {
DFS(ind, 0, 0);
}
for (i = 1; i <= m; ++i) {
if (is_bridge[i]) {
if (llev[comp_no[U[i]]] < llev[comp_no[V[i]]]) swap(U[i], V[i]);
poop.push_back(make_pair(i, make_pair(U[i], V[i])));
}
}
sort(poop.begin(), poop.end());
for (i = 0; i < poop.size(); ++i)
printf("%d %d\n", poop[i].second.first, poop[i].second.second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (~scanf("%d", &n)) {
printf("%d\n", 2 * n - n / 2);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
vector<long long> c(30);
for (long long i = 0; i < 30; ++i) {
c[i] = -i - 1;
}
for (long long i = 0; i < n; ++i) {
string s;
cin >> s;
set<long long> indexes;
for (long long j = 0; j < s.size(); ++j) {
indexes.insert(c[s[j] - 'a']);
}
for (long long j = 0; j < 30; ++j) {
if (indexes.count(c[j])) {
c[j] = i + 1;
}
}
}
for (long long i = 0; i < 30; ++i) {
if (c[i] < 0) {
c[i] = 0;
}
}
set<long long> X;
for (long long i = 0; i < 30; ++i) {
X.insert(c[i]);
}
cout << X.size() - 1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s;
vector<int> v;
bool flag;
int main() {
int i, j, k;
cin >> s;
flag = false;
for (i = 0; i < s.size(); i++) {
j = i;
while (j < s.size() && s[j] == s[i]) j++;
int t = min(j - i, 2);
if (flag) t = 1;
if (t >= 2)
flag = true;
else
flag = false;
for (k = 0; k < t; k++) printf("%c", s[i]);
i = j - 1;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 119 << 23 | 1;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int)1e9 + 23111992;
const long long LINF = (long long)1e18 + 23111992;
const long double PI = acos((long double)-1);
const long double EPS = 1e-6;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline unsigned long long isqrt(unsigned long long k) {
unsigned long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() { return abs((int)mt()); }
inline int mrand(int k) { return abs((int)mt()) % k; }
void chemthan() {
int n, k, m;
cin >> n >> k >> m;
vector<int> l(m), r(m), x(m);
for (int i = (0); i < (m); ++i) cin >> l[i] >> r[i] >> x[i], l[i]--, r[i]--;
vector<tuple<int, int, int>> vals;
for (int i = (0); i < (m); ++i) {
vals.push_back({l[i], -r[i], x[i]});
}
sort((vals).begin(), (vals).end());
for (int i = (0); i < (m); ++i) {
tie(l[i], r[i], x[i]) = vals[i];
r[i] = -r[i];
}
int res = 1;
for (int t = (0); t < (k); ++t) {
vector<int> a(n);
for (int i = (0); i < (m); ++i) {
if ((((x[i]) >> (t)) & 1)) {
a[l[i]]++;
if (r[i] + 1 < n) {
a[r[i] + 1]--;
}
}
}
for (int i = (1); i < (n); ++i) a[i] += a[i - 1];
for (int i = (0); i < (n); ++i) a[i] = 0 < a[i];
vector<pair<int, int>> vals;
for (int i = (0); i < (m); ++i) {
if (!(((x[i]) >> (t)) & 1)) {
vals.push_back({l[i], -r[i]});
}
}
int mn = INF;
vector<pair<int, int>> nvals;
for (int i = (int((vals).size())) - 1; i >= (0); --i) {
int l, r;
tie(l, r) = vals[i];
r = -r;
if (r < mn) {
nvals.push_back({l, r});
}
chkmin(mn, r);
}
vals = nvals;
vector<int> dc;
for (int i = (0); i < (n); ++i) {
if (!a[i]) {
dc.push_back(i);
}
}
vector<int> f(n, n);
for (auto e : vals) {
int l = e.first;
int r = e.second;
int u = lower_bound((dc).begin(), (dc).end(), l) - dc.begin();
int v = upper_bound((dc).begin(), (dc).end(), r) - dc.begin() - 1;
if (v < u) {
cout << 0 << "\n";
return;
}
chkmin(f[u], v);
}
vector<int> fen(n + 5);
auto upd = [&](int p, int v) {
p++;
for (; p < int((fen).size()); p += p & -p) {
addmod(fen[p], v);
}
};
auto query = [&](int p) {
p++;
int res = 0;
for (; 0 < p; p -= p & -p) {
addmod(res, fen[p]);
}
return res;
};
int c = 1, d = 0;
vector<int> g(int((dc).size()));
for (int i = (0); i < (int((dc).size())); ++i) {
if (f[i] < n) {
addmod(g[f[i]], c);
addmod(d, c);
c = 0;
}
c = mult(c, 2);
addmod(c, d);
submod(d, g[i]);
}
res = mult(res, c);
}
cout << res << "\n";
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
chemthan();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
mt19937 RNG(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
T ceil(T a, T b) {
return (a + b - 1) / b;
}
template <typename T>
T binpow(T a, T b, T m) {
a %= m;
T res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
void solve() {
long long n;
cin >> n;
long long a[n + 1];
for (long long i = 0; i < n; i++) cin >> a[i];
long long b = 0;
a[n] = 0;
stack<long long> l, r;
for (long long i = 0; i < n + 1; i++) {
while (a[i] > b) {
l.push(i + 1);
b++;
}
while (a[i] < b) {
r.push(i);
b--;
}
}
cout << l.size() << "\n";
while (!l.empty() and !r.empty()) {
cout << l.top() << ' ' << r.top() << "\n";
l.pop(), r.pop();
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
for (long long i = 1; i < t + 1; i++) {
solve();
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, ta, tb, hh, mm, x1, y1, res = 0;
char ch;
cin >> a >> ta >> b >> tb >> hh >> ch >> mm;
x1 = hh * 60 + mm;
y1 = x1 + ta;
for (int i = 5 * 60; i < 24 * 60; i += b) {
int y2 = i + tb;
int x = max(i, x1), y = min(y1, y2);
if (x < y) res++;
}
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x;
cin >> x;
int answer = (x.size() + 1) * 26 - x.size();
cout << answer;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T>
void read(T &x) {
x = 0;
int c = getchar();
int flag = 0;
while (c < '0' || c > '9') flag |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (flag) x = -x;
}
template <class T>
T _max(T a, T b) {
return b < a ? a : b;
}
template <class T>
T _min(T a, T b) {
return a < b ? a : b;
}
template <class T>
bool checkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
bool checkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
const int B = 1000;
int n, t;
int a[2005][2005];
void init() {
read(n);
read(t);
}
void run(int x, int y) {
++a[x][y];
if (a[x][y] == 4) {
a[x][y] = 0;
run(x, y + 1);
run(x, y - 1);
run(x - 1, y);
run(x + 1, y);
}
}
void solve() {
for (int i = 1; i <= n; ++i) run(B, B);
int x, y;
while (t--) {
read(x);
read(y);
if (abs(x) > 1000 || abs(y) > 1000) {
printf("0\n");
continue;
}
printf("%d\n", a[B + x][B + y]);
}
}
int main() {
init();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, r = 1;
string s;
int main() {
cin >> n >> s;
for (int i = 1; i < n; i++) {
r += s[i] != s[i - 1];
}
cout << min(r + 2, n);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int used[210];
int main() {
memset(used, -1, sizeof(used));
int n, m;
cin >> n >> m;
vector<int> ord;
int cnt = 0;
for (int i = 0; i < m; i++) {
int k;
cin >> k;
for (int j = 0; j < k; j++) {
int t;
cin >> t;
t--;
used[t] = cnt++;
}
}
vector<pair<int, int> > sol;
for (int i = 0; i < cnt; i++) {
int unocc = -1;
for (int j = i; j < n; j++) {
if (used[j] == -1) {
unocc = j;
break;
}
}
for (int j = i; j < n; j++) {
if (used[j] == i) {
if (i == j) break;
if (i != unocc) sol.push_back(pair<int, int>(i, unocc));
used[unocc] = used[i];
if (i != j) sol.push_back(pair<int, int>(j, i));
used[i] = used[j];
used[j] = -1;
break;
}
}
}
cout << sol.size() << endl;
for (int i = 0; i < (int)sol.size(); i++) {
cout << sol[i].first + 1 << ' ' << sol[i].second + 1 << endl;
}
}
| 5 |
#include <bits/stdc++.h>
int main(void) {
int n = 400;
printf("%d\n", n + 2);
printf("0 300300\n");
int x = 300300;
for (int i = 0, _n = (n); i < _n; i = i + 1) {
printf("%d %d\n", x, n - i);
x += 2 * (n - i) - 1;
}
printf("600000 300300\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
vector<int> vc[500005], extra[500005];
set<long long int> name[500005];
long long int c[500005];
set<long long int> s;
set<long long int>::iterator it;
int vis[500005];
map<long long int, int> cou;
int cnt = 0;
void dfs2(int v, long long int x, int id) {
cnt++;
name[v].insert(x);
for (int i = 0; i < vc[v].size(); i++) {
int w = vc[v][i];
if ((c[w] ^ c[v]) != x) continue;
if (name[w].find(x) != name[w].end()) continue;
dfs2(w, x, id);
}
}
int id = 0;
int sum[500005];
map<long long int, int> ara;
void dfs(int v) {
vis[v] = 1;
for (int i = 0; i < vc[v].size(); i++) {
int w = vc[v][i];
long long int f = c[w] ^ c[v];
if (ara[f] == 0) {
ara[f] = ++id;
}
int q = ara[f];
s.insert(f);
if (name[v].find(f) == name[v].end()) {
cnt = 0;
dfs2(v, f, q);
extra[q].push_back(cnt);
sum[q] += cnt;
}
if (vis[w]) continue;
dfs(w);
}
}
long long int po[500009];
int track[500005][2], casio = 1;
long long int dp[500005][2];
long long int dp_func(int pos, int bol, int id) {
if (extra[id].size() == pos) return bol;
if (track[pos][bol] == casio) return dp[pos][bol];
track[pos][bol] = casio;
long long int d = po[extra[id][pos]];
d -= 2;
long long int ret = 0;
if (d < 0) d = (d + 1000000007) % 1000000007;
ret += (d * dp_func(pos + 1, bol || 1, id)) % 1000000007;
ret += (2 * dp_func(pos + 1, bol, id)) % 1000000007;
return dp[pos][bol] = ret % 1000000007;
}
int main() {
po[0] = 1;
for (int i = 1; i <= 500005; i++) {
po[i] = (po[i - 1] * 2) % 1000000007;
}
int n, m, k, x, y;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%lld", &c[i]);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
vc[y].push_back(x);
vc[x].push_back(y);
}
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
dfs(i);
}
long long int ans = po[n];
long long int rs = ans;
rs = (rs * (po[k]) % 1000000007) % 1000000007;
ans = rs;
for (int i = 1; i <= id; i++) {
casio++;
long long int d = dp_func(0, 0, i);
d = d * po[n - sum[i]];
d %= 1000000007;
ans -= d;
if (ans < 0) ans = (ans + 1000000007) % 1000000007;
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
const int mod = 1000000009;
int dp[2][2][31][31][31], n, h;
inline void INC(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
inline int min(int a, int b) { return a < b ? a : b; }
int main() {
scanf("%d%d", &n, &h);
dp[0][1][0][0][0] = 1;
int s = 0, _tmp, x3;
int f0, f1, f2, f3;
for (int i = 0; i < n; i++) {
s ^= 1;
for (int x0 = 0; x0 < h + 1; x0++)
for (int x1 = 0; x1 < h + 1; x1++)
for (int x2 = 0; x2 < h + 1; x2++)
for (int k = 0; k < 2; k++) {
int tmp = dp[s ^ 1][k][x0][x1][x2];
dp[s ^ 1][k][x0][x1][x2] = 0;
if (!tmp) continue;
if (k)
f3 = 1;
else
f3 = h;
f0 = min(h, x0 + 1);
f1 = min(h, x1 + 1);
f2 = min(h, x2 + 1);
dp[s][x0 < h][f1][f2][f3] += tmp;
if (dp[s][x0 < h][f1][f2][f3] >= mod)
dp[s][x0 < h][f1][f2][f3] -= mod;
dp[s][x1 < h][f0][f2][f3] += tmp;
if (dp[s][x1 < h][f0][f2][f3] >= mod)
dp[s][x1 < h][f0][f2][f3] -= mod;
dp[s][x2 < h][f0][f1][f3] += tmp;
if (dp[s][x2 < h][f0][f1][f3] >= mod)
dp[s][x2 < h][f0][f1][f3] -= mod;
dp[s][k][f0][f1][f2] += tmp;
if (dp[s][k][f0][f1][f2] >= mod) dp[s][k][f0][f1][f2] -= mod;
}
}
int ans = 0;
for (int x0 = 0; x0 < h + 1; x0++)
for (int x1 = 0; x1 < h + 1; x1++)
for (int x2 = 0; x2 < h + 1; x2++)
for (int alive = 0; alive < 2; alive++)
if (x0 < h || x1 < h || x2 < h || alive) {
ans += dp[s][alive][x0][x1][x2];
if (ans >= mod) ans -= mod;
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const long long MOD = 1e9 + 7;
const long long MOD1 = 998244353;
const long long M = 1e18;
long long qpow(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int tt = 1;
cin >> tt;
for (int t = 1; t <= tt; t++) {
int n;
cin >> n;
int a[n];
map<int, int> m;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
m[a[i]]++;
}
sum = 2 * sum;
long long ans = 0;
for (int i = 0; i < n; i++) {
m[a[i]]--;
if (sum % n == 0) {
ans += m[sum / n - a[i]];
}
}
cout << ans;
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 10;
int vis[maxn];
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int t;
vector<int> ans;
cin >> t;
int a[1010], b[1010], vb[1010];
while (t--) {
memset(vb, 0, sizeof(vb));
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) {
vb[i] = a[i] + b[i];
}
sort(a, a + n);
sort(b, b + n);
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
for (int i = 0; i < n; i++) {
cout << b[i] << " ";
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
string s;
cin >> s;
int n = ((int)(s).size());
int l = 0, r = n - 1;
while (true) {
if (s[l] != s[r]) {
cout << "0\n";
exit(0);
}
char prevC = s[l];
int i = l;
while (s[i] == prevC && i + 1 <= r) {
i++;
}
if (i == r) {
if (r - l + 1 >= 2) {
cout << r - l + 2 << "\n";
} else {
cout << "0\n";
}
exit(0);
}
int fromLeft = i - l;
int nextL = i;
i = r;
while (s[i] == prevC && i - 1 >= l) {
i--;
}
if (i == l) {
if (r - l + 1 >= 2) {
cout << r - l + 2 << "\n";
} else {
cout << "0\n";
}
exit(0);
}
int fromRight = r - i;
l = nextL;
r = i;
if (fromLeft + fromRight < 3) {
cout << "0\n";
exit(0);
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
vector<long long> v, v1;
v.clear();
v1.clear();
for (int I = 0; I < n; I++) {
long long c;
cin >> c;
v.push_back(c);
v1.push_back(c);
}
sort(v1.begin(), v1.end());
long long flag = 1, first = 0, last = 0;
for (int I = 0; I < n; I++) {
if (v[I] != v1[I]) {
if (flag) {
first = I;
flag = 0;
} else
last = I;
}
}
if (flag == 1) {
cout << "yes" << endl << 1 << " " << 1 << endl;
} else {
reverse(v.begin() + first, v.begin() + last + 1);
if (is_sorted(v.begin(), v.end()))
cout << "yes" << endl << first + 1 << " " << last + 1 << endl;
else
cout << "no" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, w, nxt;
} e[200005];
int n, tot = 0, head[200005], a[200005], fa[200005][35], ans[200005];
long long d[200005];
inline void adde(int x, int y, int w) {
e[++tot] = (edge){y, w, head[x]}, head[x] = tot;
}
inline void dfs(int x) {
int t = x;
for (int i = 1; i <= 30; i++) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (int i = 30; i >= 0; i--)
if (fa[t][i] && d[x] - d[fa[t][i]] <= a[x]) t = fa[t][i];
ans[fa[t][0]]--, ans[fa[x][0]]++;
for (int i = head[x]; i; i = e[i].nxt)
fa[e[i].to][0] = x, d[e[i].to] = d[x] + e[i].w, dfs(e[i].to),
ans[x] += ans[e[i].to];
}
int main() {
scanf("%d", &n), memset(head, 0, sizeof(head));
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 2, y, w; i <= n; i++) scanf("%d%d", &y, &w), adde(y, i, w);
dfs(1);
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], i == n ? '\n' : ' ');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXINT = 1073741823;
const int MAXN = 200005;
const int MOD = 998244353;
uint64_t inverseModp(uint64_t a, uint64_t p) {
uint64_t ex = p - 2, result = 1;
while (ex > 0) {
if (ex % 2 == 1) {
result = (result * a) % p;
}
a = (a * a) % p;
ex /= 2;
}
return result;
}
uint32_t c(uint32_t n, uint32_t r, uint32_t p) {
if (r > n - r) r = n - r;
if (r == 0) return 1;
if (n / p - (n - r) / p > r / p) return 0;
uint64_t result = 1;
for (uint32_t i = n, x = 1; i > r; --i, ++x) {
if (i % p != 0) {
result *= i % p;
result %= p;
}
if (x % p != 0) {
result *= inverseModp(x % p, p);
result %= p;
}
}
return result;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int n, m, answer = 1;
cin >> n >> m;
for (int i = 0; i < n - 3; i++) {
answer *= 2;
answer %= MOD;
}
answer *= c(m, n - 1, MOD);
answer %= MOD;
answer *= (n - 2);
answer %= MOD;
cout << answer;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
const long long inf = 2147383647;
const double pi = 2 * acos(0.0);
const double eps = 1e-7;
const long long maxint = 2147483647;
const long long minint = -2147483648;
using namespace std;
long long MIN(long long a, long long b) {
if (a < b) return a;
return b;
}
long long MAX(long long a, long long b) {
if (a > b) return a;
return b;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long power(long long a, long long p) {
if (p == 0) return 1;
if (p & 1) {
return a * power(a, p - 1);
} else {
long long c = power(a, p / 2);
return c * c;
}
}
long long sq(long long x) { return x * x; }
long long ser[1000010];
int init(long long k, long long b) {
int i;
ser[0] = 1;
for (i = 1;; i++) {
ser[i] = k * ser[i - 1] + b;
if (ser[i] > 1e6) break;
}
return i;
}
int main() {
int k, b, n, t;
while (scanf("%d %d %d %d", &k, &b, &n, &t) != EOF) {
int size = init(k, b);
int i;
for (i = size; i >= 0; i--) {
if (ser[i] <= t) break;
}
int res = n - i;
if (res < 0) res = 0;
printf("%d\n", res);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
class union_find {
private:
vector<int> par;
vector<int> ran;
vector<long long int> size;
public:
union_find(int n);
int find(int x);
void unite(int x, int y);
bool same(int x, int y);
long long int show_size(int x);
};
union_find::union_find(int n) {
par.resize(n);
ran.resize(n);
size.resize(n);
for (int i = 0; i < (n); ++i) par[i] = i;
for (int i = 0; i < (n); ++i) ran[i] = 0;
for (int i = 0; i < (n); ++i) size[i] = 1;
};
int union_find::find(int x) {
if (par[x] == x)
return x;
else
return par[x] = find(par[x]);
};
void union_find::unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
long long int t = show_size(x) + show_size(y);
size[x] = size[y] = t;
if (ran[x] < ran[y]) {
par[x] = y;
} else {
par[y] = x;
if (ran[x] == ran[y]) ran[x]++;
}
};
long long int union_find::show_size(int x) {
if (par[x] == x) return size[x];
return show_size(par[x] = find(par[x]));
}
bool union_find::same(int x, int y) { return (find(x) == find(y)); };
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
vector<int> c(k);
for (int i = 0; i < (k); ++i) {
cin >> c[i];
--c[i];
}
union_find uf(n);
for (int i = 0; i < (m); ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
uf.unite(u, v);
}
int ans = 0, mxdsu = c[0];
for (int j = 0; j < (k); ++j) {
if (uf.show_size(c[j]) > uf.show_size(mxdsu)) {
mxdsu = c[j];
}
}
for (int i = 0; i < (n); ++i) {
bool gov = false;
for (int j = 0; j < (k); ++j) {
if (uf.find(i) == uf.find(c[j])) gov = true;
}
if (gov) continue;
uf.unite(i, mxdsu);
}
for (int j = 0; j < (k); ++j) {
int sz = uf.show_size(c[j]);
int mx = sz * (sz - 1) / 2;
ans += mx;
}
ans -= m;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int const N = 200200;
int const LOG = 19;
vector<int> g[N];
int cdep[N], cpar[N];
int under[N];
int tin[N], depth[N];
int sp[LOG][N], logs[N], timer = 0;
void dfs(int v, int par, int dep) {
depth[v] = dep;
sp[0][tin[v] = timer++] = dep;
for (int to : g[v]) {
if (to != par) {
dfs(to, v, dep + 1);
sp[0][timer++] = dep;
}
}
}
int dist(int a, int b) {
int x = min(tin[a], tin[b]), y = max(tin[a], tin[b]) + 1;
int i = logs[y - x];
return depth[a] + depth[b] - 2 * min(sp[i][x], sp[i][y - (1 << i)]);
}
void calc_sizes(int v, int par) {
under[v] = 1;
for (int to : g[v]) {
if (to != par && cdep[to] < 0) {
calc_sizes(to, v);
under[v] += under[to];
}
}
}
void build_cd(int v, int dep, int par) {
calc_sizes(v, -1);
for (int did = 1, size = under[v]; did;) {
did = 0;
for (int to : g[v]) {
if (cdep[to] < 0 && under[to] < under[v] && under[to] * 2 > size) {
v = to;
did = 1;
}
}
}
cdep[v] = dep;
cpar[v] = par;
for (int to : g[v])
if (cdep[to] < 0) build_cd(to, dep + 1, v);
}
vector<pair<int, int>> dp[N];
void add(int v) {
for (int pc = -1, c = v; c >= 0; pc = c, c = cpar[c]) {
int pos = dp[c].size();
dp[c].emplace_back(dist(v, c), pc);
while (pos && dp[c][pos] < dp[c][pos - 1]) {
swap(dp[c][pos], dp[c][pos - 1]);
--pos;
}
if ((int)dp[c].size() > 2) dp[c].pop_back();
}
}
int ans(int v) {
int ret = N;
for (int pc = -2, c = v; c >= 0; pc = c, c = cpar[c]) {
int curd = dist(v, c);
for (auto x : dp[c])
if (x.second != pc) ret = min(ret, curd + x.first);
}
return ret;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n - 1; ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(0, 0, 0);
for (int i = 1; (1 << i) <= timer; ++i) {
int len = 1 << i;
for (int j = 0; j + len <= timer; ++j) {
sp[i][j] = min(sp[i - 1][j], sp[i - 1][j + len / 2]);
}
}
logs[1] = 0;
for (int i = 2; i <= timer; ++i) logs[i] = 1 + logs[i / 2];
fill(cdep, cdep + n, -1);
build_cd(0, 0, -1);
add(0);
for (int i = 0; i < m; ++i) {
int t, v;
scanf("%d%d", &t, &v);
--v;
if (t == 1) {
add(v);
} else {
cout << ans(v) << '\n';
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int cR[3], cG[3], cB[3], s[6];
int main() {
int n;
cin >> n;
string str;
cin >> str;
for (int k = 0; k < 3; k++) {
for (int i = k; i < n; i += 3) {
switch (str[i]) {
case 'R':
cR[k]++;
break;
case 'G':
cG[k]++;
break;
case 'B':
cB[k]++;
break;
}
}
}
s[0] = n - cR[0] - cG[1] - cB[2];
s[1] = n - cR[0] - cG[2] - cB[1];
s[2] = n - cR[1] - cG[0] - cB[2];
s[3] = n - cR[1] - cG[2] - cB[0];
s[4] = n - cR[2] - cG[1] - cB[0];
s[5] = n - cR[2] - cG[0] - cB[1];
int mini = 0;
for (int i = 0; i < 6; i++) {
if (s[i] < s[mini]) mini = i;
}
cout << s[mini] << endl;
string s0;
switch (mini) {
case 0:
s0 = "RGB";
break;
case 1:
s0 = "RBG";
break;
case 2:
s0 = "GRB";
break;
case 3:
s0 = "BRG";
break;
case 4:
s0 = "BGR";
break;
case 5:
s0 = "GBR";
break;
}
for (int i = 0; i < n / 3; i++) {
cout << s0;
}
for (int i = 0; i < n % 3; i++) {
cout << s0[i];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int ans, i, n, a[2000000], s;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
s += a[i];
}
for (i = 1; i <= n; i++)
if ((s - a[i]) % 2 == 0) ans++;
printf("%d", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int main() {
int n;
cin >> n;
int m = 1000003;
int res = 1;
for (int i = 1; i < n; i++) res = (res * 3) % m;
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
int cnt[256], op[256];
int main() {
cin >> s >> t;
for (int i = 0; i < t.size(); i++) {
cnt[t[i]]++;
}
for (int i = 0; i < 256; i++) op[i] = i;
swap(op['6'], op['9']);
swap(op['2'], op['5']);
int ans = 0;
while (true) {
for (int i = 0; i < s.size(); i++) {
if (cnt[s[i]])
cnt[s[i]]--;
else if (cnt[op[s[i]]])
cnt[op[s[i]]]--;
else {
printf("%d\n", ans);
return 0;
}
}
ans++;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int T;
string s, t;
vector<int> get(string tem) {
vector<int> ans;
int p = 0, x;
while ((x = s.find(tem, p)) != -1) {
ans.push_back(x);
p = x + 1;
}
return ans;
}
void solve() {
cin >> s >> t;
int ls = s.length(), lt = t.length();
bool f = false;
for (int i = 1; i < lt; i++) {
int x = i;
string left = t.substr(0, x);
vector<int> p1, p2;
p1 = get(left);
string right = t.substr(x);
reverse(right.begin(), right.end());
p2 = get(right);
for (int j = 0; j < p1.size(); j++)
for (int k = 0; k < p2.size(); k++)
if (p1[j] + left.size() == p2[k] + right.size() + 1) {
f = true;
puts("YES");
return;
}
}
if (s.find(t) != -1) f = true;
reverse(t.begin(), t.end());
if (s.find(t) != -1) f = true;
if (f)
puts("YES");
else
puts("NO");
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int i;
set<long long int> s;
void nec() {
for (i = 1; i <= sqrt(2 * pow(10, 9)); i++) s.insert(i * i);
}
void solve() {
nec();
string a, t;
vector<int> v;
cin >> a;
long long int j, test;
int len = a.length();
for (i = 0; i < (1 << len); ++i) {
t = "";
for (j = 0; j < len; j++) {
if (i & (1 << j)) t += a[j];
}
if (t[0] != '0' && t.length() != 0)
if (s.find(stoi(t)) != s.end()) v.push_back(a.length() - t.length());
}
if (!v.empty()) {
int min = 10000;
for (i = 0; i < v.size(); i++) {
if (min > v[i]) min = v[i];
}
cout << min;
} else
cout << -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using vi = vector<int>;
using vull = vector<ull>;
const size_t MAX_N = 1000;
ull N, M, K;
vector<int> adj[MAX_N];
int sz[MAX_N];
int cpar[MAX_N];
bool vis[MAX_N];
int assignments[MAX_N][MAX_N];
void dfs(int n, int p = -1) {
sz[n] = 1;
for (int v : adj[n])
if (v != p && !vis[v]) {
dfs(v, n);
sz[n] += sz[v];
}
}
int centroid(int n) {
dfs(n);
int num = sz[n];
int p = -1;
do {
int nxt = -1;
for (int v : adj[n])
if (v != p && !vis[v]) {
if (2 * sz[v] > num) nxt = v;
}
p = n, n = nxt;
} while (~n);
return p;
}
void centroidDecomp(int n = 0, int p = -1) {
int c = centroid(n);
vis[c] = true;
cpar[c] = p;
for (int v : adj[c])
if (!vis[v]) {
centroidDecomp(v, c);
}
}
int genNewSz(int node) {
int size = 0;
if (!vis[node]) {
size = 1;
vis[node] = true;
for (int v : adj[node]) size += genNewSz(v);
}
return sz[node] = size;
}
int centr;
vector<int> subTreeA, subTreeB;
void mergeSubtrees() {
sort(adj[centr].begin(), adj[centr].end(),
[](int t1, int t2) { return sz[t1] < sz[t2]; });
int sizeSubTreeA = 0;
int minTreeSize = ceil(static_cast<double>(N - 1) / 3.0);
int i;
for (i = 0; i < adj[centr].size() && sizeSubTreeA < minTreeSize; i++) {
subTreeA.push_back(adj[centr][i]);
sizeSubTreeA += sz[adj[centr][i]];
}
for (; i < adj[centr].size(); i++) {
subTreeB.push_back(adj[centr][i]);
}
}
int genAssignmentsHelp(const int mult, const vector<int>& subTree) {
int targetSum = 1;
queue<tuple<int, int>> traverse;
for (int v : subTree) {
cout << (centr + 1) << " " << (v + 1) << " " << (targetSum * mult) << endl;
vis[v] = true;
traverse.emplace(v, targetSum);
targetSum++;
}
while (!traverse.empty()) {
auto node = traverse.front();
traverse.pop();
int p = get<0>(node);
for (int v : adj[p]) {
if (!vis[v]) {
vis[v] = true;
cout << (p + 1) << " " << (v + 1) << " "
<< (targetSum - get<1>(node)) * mult << endl;
traverse.emplace(v, targetSum);
targetSum++;
}
}
}
return targetSum;
}
void genAssignments() {
memset(vis, false, sizeof(vis));
genNewSz(centr);
mergeSubtrees();
memset(vis, false, sizeof(vis));
vis[centr] = true;
int mult = genAssignmentsHelp(1, subTreeA);
genAssignmentsHelp(mult, subTreeB);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> N;
for (int i = 0; i < N - 1; i++) {
int u, v;
cin >> u >> v;
adj[--u].push_back(--v);
adj[v].push_back(u);
}
centroidDecomp();
for (int i = 0; i < N; i++) {
if (cpar[i] == -1) {
centr = i;
break;
}
}
genAssignments();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int arr[100005] = {0};
int main() {
int n;
cin >> n;
cin >> arr[0];
for (int i = 1; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
for (int i = 0; i < n - 1; i++) {
if (arr[i] == arr[i + 1]) {
continue;
}
if (arr[i] * 2 > arr[i + 1]) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int b, d;
char a[110];
char c[110];
int dp[110];
int main(int argc, char *argv[]) {
int cnt;
scanf("%d %d %s %s", &b, &d, a, c);
n = strlen(a);
m = strlen(c);
fill_n(dp, m, -1);
for (int i = 0; i < m; i += 1) {
int k = i;
int j = 0;
while (j < n) {
if (c[k % m] == a[j]) {
k++;
}
j++;
}
dp[i] = k - i;
}
cnt = 0;
for (int i = 0; i < b; i += 1) {
cnt += dp[cnt % m];
}
printf("%d\n", cnt / d / m);
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int N = 18, oo = 0x3f3f3f3f;
using namespace std;
int n, m, du[N], sum, dis[N][N], ans = oo, res;
bool vis[N];
vector<int> odd;
bool floyd() {
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
for (int i = 2; i <= n; i++)
if (du[i] && dis[1][i] >= oo) return 0;
return 1;
}
void solve(int x) {
if (x >= odd.size()) {
ans = min(ans, res);
return;
}
if (vis[x]) {
solve(x + 1);
return;
}
vis[x] = 1;
for (int i = 0; i < odd.size(); i++)
if (i != x && vis[i] == 0) {
res += dis[odd[x]][odd[i]];
vis[i] = 1;
solve(x + 1);
res -= dis[odd[x]][odd[i]];
vis[i] = 0;
}
vis[x] = 0;
}
int main() {
memset(dis, oo, sizeof(dis));
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) dis[i][i] = 0;
while (m--) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
if (dis[x][y] > w) dis[x][y] = dis[y][x] = w;
du[x]++, du[y]++;
sum += w;
}
for (int i = 1; i <= n; i++)
if (du[i] & 1) odd.push_back(i);
if (!floyd()) return puts("-1"), 0;
solve(0);
printf("%d\n", ans + sum);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
long long int n, w;
cin >> n >> w;
long long int a, sm = 0;
vector<long long int> v;
int f = 0;
for (int i = 0; i < n; i++) {
cin >> a;
if (a < (w + 1) / 2 && !f) {
sm += a;
v.push_back(i + 1);
if (sm >= ((w + 1) / 2) && sm <= w) f = 1;
}
if (a >= ((w + 1) / 2) && a <= w) {
v.clear();
v.push_back(i + 1);
f = 1;
}
}
if (!f)
cout << -1 << "\n";
else {
cout << v.size() << "\n";
for (auto a : v) cout << a << " ";
cout << "\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, w;
} len[2000017];
int n, m, lazy[2000017 << 2], minn[2000017 << 2];
bool cmp(node A, node B) {
if (A.w == B.w) {
if (A.l == B.l)
return A.r < B.r;
else
return A.l < B.l;
} else
return A.w < B.w;
}
void modify(int k, int l, int r, int ql, int qr, int v) {
if (l >= ql && r <= qr) {
lazy[k] += v;
minn[k] += v;
return;
}
int mid = (l + r) >> 1;
if (lazy[k]) {
lazy[k << 1] += lazy[k];
lazy[k << 1 | 1] += lazy[k];
minn[k << 1] += lazy[k];
minn[k << 1 | 1] += lazy[k];
lazy[k] = 0;
}
if (ql <= mid) modify(k << 1, l, mid, ql, qr, v);
if (mid < qr) modify(k << 1 | 1, mid + 1, r, ql, qr, v);
minn[k] = min(minn[k << 1], minn[k << 1 | 1]);
}
int solve() {
int nxt, lim = 2000017;
for (int l = 1, r = 1; l <= n; l += 1) {
while (!minn[1] && r <= n) {
if (len[r].r != m)
nxt = len[r].r - 1;
else
nxt = m;
modify(1, 1, m, len[r].l, nxt, 1);
r++;
}
if (minn[1]) lim = min(lim, len[r - 1].w - len[l].w);
if (len[l].r != m)
nxt = len[l].r - 1;
else
nxt = m;
modify(1, 1, m, len[l].l, nxt, -1);
}
return lim;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i += 1)
scanf("%d%d%d", &len[i].l, &len[i].r, &len[i].w);
sort(len + 1, len + n + 1, cmp);
printf("%d\n", solve());
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double PI = acos(-1.0);
const long long int mod = 1e9 + 7;
const int MAXN = 1e5 + 5;
struct edge {
int u, v, wt;
long long int freq;
edge() : u(0), v(0), wt(0), freq(0) {}
edge(int u, int v, int wt) : u(u), v(v), wt(wt), freq(0) {}
};
int n;
vector<edge> edges;
vector<vector<int>> adj;
int dfs(int u, int par) {
int subtree = 0;
for (int e : adj[u]) {
int v = (edges[e].u == u ? edges[e].v : edges[e].u);
if (v != par) {
int child = dfs(v, u);
int other = n - child;
edges[e].freq = child * 1LL * other;
subtree += child;
}
}
return subtree + 1;
}
void cp() {
cin >> n;
adj.resize(n + 1);
for (int i = 0, u, v, l; i < n - 1; i++) {
cin >> u >> v >> l;
adj[u].push_back(((int)edges.size()));
adj[v].push_back(((int)edges.size()));
edges.push_back(edge(u, v, l));
}
dfs(1, 0);
double total = n * 1.0 * (n - 1) / 2.0;
double ans = 0;
for (int i = 0; i < n - 1; i++) {
ans += edges[i].wt * double(edges[i].freq) / total;
}
cout << setprecision(10) << fixed;
;
int q;
cin >> q;
while (q--) {
int idx, nwt;
cin >> idx >> nwt;
idx--;
ans -= edges[idx].wt * double(edges[idx].freq) / total;
edges[idx].wt = nwt;
ans += edges[idx].wt * double(edges[idx].freq) / total;
cout << 3.0 * ans << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
while (t--) {
cp();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#define ll long long
#define ls id << 1
#define rs id << 1 | 1
#define mem(array, value, size, type) memset(array, value, ((size) + 5) * sizeof(type))
#define memarray(array, value) memset(array, value, sizeof(array))
#define fillarray(array, value, begin, end) fill((array) + (begin), (array) + (end) + 1, value)
#define fillvector(v, value) fill((v).begin(), (v).end(), value)
#define pb(x) push_back(x)
#define st(x) (1LL << (x))
#define pii pair<int, int>
#define mp(a, b) make_pair((a), (b))
#define Flush fflush(stdout)
#define vecfirst (*vec.begin())
#define veclast (*vec.rbegin())
#define vecall(v) (v).begin(), (v).end()
#define vecupsort(v) (sort((v).begin(), (v).end()))
#define vecdownsort(v, type) (sort(vecall(v), greater<type>()))
#define veccmpsort(v, cmp) (sort(vecall(v), cmp))
using namespace std;
const int N = 500050;
const int inf = 0x3f3f3f3f;
const ll llinf = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
clock_t TIME__START, TIME__END;
void program_end()
{
#ifdef ONLINE
printf("\n\nTime used: %.6lf(s)\n", ((double)TIME__END - TIME__START) / 1000);
system("pause");
#endif
}
int n, k;
int a[N];
struct segtree
{
int l, r;
ll sum, lazy;
} t[N << 2];
inline void pushup(int id) { t[id].sum = t[ls].sum + t[rs].sum; }
inline void pushdown(int id)
{
if (t[id].lazy)
{
t[ls].sum += t[id].lazy * (t[ls].r - t[ls].l + 1);
t[rs].sum += t[id].lazy * (t[rs].r - t[rs].l + 1);
t[ls].lazy += t[id].lazy, t[rs].lazy += t[id].lazy;
t[id].lazy = 0;
}
}
void build(int l, int r, int id)
{
t[id].l = l, t[id].r = r;
t[id].lazy = 0;
if (l == r)
return;
int mid = (l + r) >> 1;
build(l, mid, ls);
build(mid + 1, r, rs);
}
void change(int L, int R, ll val, int id)
{
int l = t[id].l, r = t[id].r;
if (L <= l && R >= r)
{
t[id].sum += (r - l + 1ll) * val;
t[id].lazy += val;
return;
}
pushdown(id);
int mid = (l + r) >> 1;
if (R <= mid)
change(L, R, val, ls);
else if (L > mid)
change(L, R, val, rs);
else
{
change(L, mid, val, ls);
change(mid + 1, R, val, rs);
}
pushup(id);
}
ll querysum(int L, int R, int id)
{
int l = t[id].l, r = t[id].r;
if (L <= l && R >= r)
return t[id].sum;
pushdown(id);
int mid = (l + r) >> 1;
if (R <= mid)
return querysum(L, R, ls);
else if (L > mid)
return querysum(L, R, rs);
else
return querysum(L, mid, ls) + querysum(mid + 1, R, rs);
}
inline void solve()
{
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
sort(a + 1, a + n + 1, greater<int>());
build(1, 500000, 1);
change(1, 1, 1, 1);
int nowleft = 1, nowdep = 1, ans = inf;
for (int i = 1; i <= n; ++i)
{
int adep = (a[i] - 1) / 2;
change(nowdep, nowdep, -1, 1);
change(nowdep + 2, nowdep + adep + 1, 2, 1);
if (a[i] % 2 == 0)
change(nowdep + adep + 2, nowdep + adep + 2, 1, 1);
nowleft--;
while (nowleft == 0)
nowdep++, nowleft = querysum(nowdep, nowdep, 1);
if (querysum(1, 500000, 1) < k)
continue;
int l = nowdep, r = 500000, res = inf;
while (l <= r)
{
int mid = (l + r) >> 1;
if (querysum(1, mid, 1) >= k)
res = mid, r = mid - 1;
else
l = mid + 1;
}
ans = min(ans, res);
}
if (ans == inf)
ans = 0;
printf("%d\n", ans - 1);
}
int main()
{
TIME__START = clock();
int Test = 1;
// scanf("%d", &Test);
while (Test--)
{
solve();
// if (Test)
// putchar('\n');
}
TIME__END = clock();
program_end();
return 0;
}
| 9 |
#include <bits/stdc++.h>
static const int MAX = 100005;
using namespace std;
static const int BSIZE = 316;
int previous[MAX];
int nextOccur[MAX];
int a[MAX];
int mark[MAX];
set<int> occ[MAX];
long long tree[325][325];
int Block[MAX];
static inline int lbs(int x) { return x & -x; }
void update(int x, int y, int val) {
if (!x || !y) return;
x = Block[x];
y = Block[y];
for (int i = x; i <= 320; i += lbs(i)) {
for (int j = y; j <= 320; j += lbs(j)) {
tree[i][j] += val;
}
}
}
long long query(int x, int y) {
long long ans = 0;
for (int i = x; i > 0; i -= lbs(i)) {
for (int j = y; j > 0; j -= lbs(j)) {
ans += tree[i][j];
}
}
return ans;
}
::std::pair<int, int> look_out(int elem, int ind) {
set<int>::iterator it = occ[elem].upper_bound(ind);
::std::pair<int, int> ans;
if (it == occ[elem].end()) {
ans.first = 0;
} else {
ans.first = *it;
}
it--;
if (it == occ[elem].begin()) {
ans.second = 0;
} else {
it--;
ans.second = *it;
}
return ans;
}
int n, nquery;
void ReadInit() {
scanf("%d%d", &n, &nquery);
memset(a, 0, sizeof(a));
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
occ[a[i]].insert(i);
}
Block[0] = 0;
for (int i = 1; i <= n; i++) {
Block[i] = (i - 1) / BSIZE + 1;
}
memset(mark, 0, sizeof(mark));
for (int i = 1; i <= n; i++) {
previous[i] = mark[a[i]];
mark[a[i]] = i;
}
memset(mark, 0, sizeof(mark));
for (int i = n; i >= 1; --i) {
nextOccur[i] = mark[a[i]];
mark[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
if (nextOccur[i] > 0) update(i, nextOccur[i], nextOccur[i] - i);
}
}
void update_ans(int pos, int val) {
int p, x;
p = pos;
x = val;
if (a[p] == x) return;
int i = p;
occ[x].insert(i);
::std::pair<int, int> got = look_out(x, i);
nextOccur[i] = got.first;
previous[i] = got.second;
if (nextOccur[i] > 0) {
update(i, nextOccur[i], nextOccur[i] - i);
previous[nextOccur[i]] = i;
}
if (previous[i] > 0) {
update(previous[i], i, i - previous[i]);
nextOccur[previous[i]] = i;
}
update(previous[i], nextOccur[i], previous[i] - nextOccur[i]);
got = look_out(a[p], i);
if (got.first) {
update(i, got.first, i - got.first);
previous[got.first] = got.second;
}
if (got.second) {
update(got.second, i, got.second - i);
nextOccur[got.second] = got.first;
}
update(got.second, got.first, got.first - got.second);
occ[a[p]].erase(i);
a[p] = x;
}
long long query_ans(int l, int r) {
long long ans = 0;
if ((r - l) <= 2 * BSIZE + 2) {
for (int i = l; i <= r; i++) {
if (nextOccur[i] > 0 && nextOccur[i] <= r) ans += nextOccur[i] - i;
}
return ans;
}
int just_big = l / BSIZE;
just_big *= BSIZE;
just_big += 1;
if (just_big <= l) just_big += BSIZE;
int just_small = r / BSIZE;
just_small *= BSIZE;
if (just_small == r) just_small -= BSIZE;
swap(just_big, just_small);
ans = query(Block[just_big], Block[just_big]) -
query(Block[just_small] - 1, Block[just_big]) -
query(Block[just_big], Block[just_small] - 1) +
query(Block[just_small] - 1, Block[just_small] - 1);
swap(just_big, just_small);
for (int i = l; i < just_big; i++) {
if (nextOccur[i] > 0 && nextOccur[i] <= r) ans += nextOccur[i] - i;
}
for (int i = just_small + 1; i <= r; i++) {
if (previous[i] >= just_big) ans += i - previous[i];
}
return ans;
}
int main(int argc, char* argv[]) {
ReadInit();
while (nquery--) {
int t, x, y;
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
update_ans(x, y);
} else {
long long ans = query_ans(x, y);
printf("%lld\n", ans);
}
}
}
| 9 |
#include <bits/stdc++.h>
int main() {
int n, a, b;
scanf("%d%d%d", &a, &b, &n);
n %= 6;
if (n == 1)
printf("%d\n", a % 1000000007 + (a % 1000000007 < 0 ? 1000000007 : 0));
else if (n == 2)
printf("%d\n", b % 1000000007 + (b % 1000000007 < 0 ? 1000000007 : 0));
else if (n == 3)
printf("%d\n",
(b - a) % 1000000007 + ((b - a) % 1000000007 < 0 ? 1000000007 : 0));
else if (n == 4)
printf("%d\n",
(-a) % 1000000007 + ((-a) % 1000000007 < 0 ? 1000000007 : 0));
else if (n == 5)
printf("%d\n",
(-b) % 1000000007 + ((-b) % 1000000007 < 0 ? 1000000007 : 0));
else if (n == 0)
printf("%d\n",
(a - b) % 1000000007 + ((a - b) % 1000000007 < 0 ? 1000000007 : 0));
return 0;
}
| 2 |
#include <bits/stdc++.h>
int gold(int m, int n, int k) {
int f, i = 1, tot, total = 0;
f = (((m + n) * 2) - 4);
total = f;
while (i <= (k - 1)) {
m = m - 4;
n = n - 4;
tot = (((m + n) * 2) - 4);
total = tot + total;
i++;
}
return total;
}
int main(int argc, char **argv) {
int g, h, t, k;
scanf("%d", &g);
scanf("%d", &h);
scanf("%d", &k);
t = gold(g, h, k);
printf("%d", t);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, f = 0;
cin >> n >> m;
long long arr[m + 1];
for (int i = 0; i < m; i++) {
cin >> arr[i];
if (arr[i] == n || arr[i] == 1) return cout << "NO", 0;
}
sort(arr, arr + m);
for (int i = 1; i < m; i++) {
if (arr[i] == arr[i - 1] + 1) {
f++;
} else
f = 0;
if (f == 2) return cout << "NO", 0;
}
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long x, y, z;
string s1, s2, s;
void memset_ll(long long a[], long long v, long long n) {
for (long long i = 0; i < n; i++) a[i] = v;
}
void memset_s(char a[], char v, long long n) {
for (long long i = 0; i < n; i++) a[i] = v;
}
int compare(const void* a, const void* b) {
return (*(long long*)a - *(long long*)b);
}
void q_sort(long long a[], long long n) {
qsort(a, n, sizeof(long long), compare);
}
static int compare1(const void* a, const void* b) {
if (*(double*)a > *(double*)b)
return 1;
else if (*(double*)a < *(double*)b)
return -1;
else
return 0;
}
void q_sort_d(double a[], long long n) {
qsort(a, n, sizeof(double), compare1);
}
long long sum(long long n) {
long long i = 0, a[6], j, k = 0;
while (n > 0) {
a[i] = n % 10;
n /= 10;
i++;
}
for (j = 0; j < i; j++) k += a[j];
return k;
}
string trans_upper(string ss) {
transform(ss.begin(), ss.end(), ss.begin(), ::toupper);
return ss;
}
int main() {
long long t, l, p, q, r, i, j, h, k, e = 0, f = 0, g = 0;
long long temp = 0, n, m, d = 0;
cin >> n;
long long a[n], b[n];
for (i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
q_sort(b, n);
for (i = 0; i < n; i++) {
p = b[n - 1];
if (a[i] == p) {
q = i + 1;
break;
}
}
r = b[n - 2];
cout << q << " " << r;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char i = getchar();
long long f = 1, res = 0;
while (i < '0' || i > '9') {
if (i == '-') f = -1;
i = getchar();
}
while (i >= '0' && i <= '9') {
res = res * 10 + i - '0';
i = getchar();
}
return res * f;
}
const int N = 1e6 + 50;
int n, a[N], vis[N * 10];
long long k;
inline int dfs(int res, int mid) {
if (vis[res] != -1) return vis[res];
if (res == 1) {
vis[res] = 1;
return 1;
}
int ji = (res >> 1) + 1, ou = res >> 1;
if (res >= (mid << 1)) {
if (res & 1) {
return vis[res] = ((vis[ji] = dfs(ji, mid)) + (vis[ou] = dfs(ou, mid)));
} else {
return vis[res] = ((vis[ou] = dfs(ou, mid)) << 1);
}
} else if (res >= mid) {
vis[res] = 1;
return 1;
} else
return vis[res] = 0;
}
inline bool pd(long long mid) {
memset(vis, -1, sizeof(vis));
long long sum = 0;
for (register int i = 1; i <= n; ++i) {
if (a[i] >= mid) {
sum += dfs(a[i], int(mid));
} else
return 0;
if (sum >= k) return 1;
}
return 0;
}
int main() {
n = read();
k = read();
long long sum = 0;
for (register int i = 1; i <= n; ++i) {
a[i] = read();
sum += a[i];
}
if (sum < k) {
puts("-1");
return 0;
}
sort(a + 1, a + 1 + n, greater<int>());
long long l = 1, r = 1e7, mid, ans = -1;
while (l <= r) {
mid = (l + r) >> 1;
if (pd(mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
printf("%lld", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
const int fx[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const int fxx[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
template <typename T, typename TT>
ostream& operator<<(ostream& s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T> t) {
for (int i = 0; i < ((int)((t).size())); i++) s << t[i] << " ";
return s;
}
int main() {
long long n, k;
cin >> n >> k;
std::vector<char> t(n, 0);
for (size_t i = 0; i < n; i++) {
cin >> t[i];
}
long long index = 0;
for (size_t i = 1; i < n; i++) {
if (t[0] == t[i]) {
long long k = 1;
int flag = 1;
for (size_t j = i + 1; j < n; j++) {
if (t[j] != t[k]) {
flag = 0;
break;
} else {
k++;
}
}
if (flag == 1) {
index = i;
break;
}
}
}
if (index == 0) {
for (size_t i = 0; i < k; i++) {
for (size_t j = 0; j < n; j++) {
cout << t[j];
}
}
return 0;
}
index = n - 1 - index;
for (size_t i = 0; i < n; i++) {
cout << t[i];
}
for (size_t i = 0; i < k - 1; i++) {
for (size_t j = index + 1; j < n; j++) {
cout << t[j];
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, c = 0, i, ans = 0;
cin >> n;
vector<long long int> v(n), v1(n);
map<long long int, long long int> m;
for (i = 0; i < n; i++) {
cin >> v[i];
}
for (i = 0; i < n; i++) {
long long int a = v[i];
while (a != 0) {
ans++;
a = a / 2;
}
v[i] = ans;
ans = 0;
}
for (i = 0; i < n; i++) {
m[v[i]]++;
}
for (i = 0; i < m.size(); i++) {
if (m[i] >= 2) {
c = c + (m[i] * (m[i] - 1) / 2);
}
}
cout << c << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long double pi = acos(-1);
const int MOD = 1e9 + 7;
const long long int LINF = 0x3f3f3f3f3f3f3f3f;
const int MAXN = 300005;
int x[MAXN];
int y[MAXN];
int dp[MAXN][3];
int n, k;
void minv(int &a, int b) { a = min(a, b); }
int get(int a, int b, int lst, int ends) {
if (lst >= k or a < 0 or b < 0) return INF;
if (a > b) {
if (lst == 0) {
int need = (a + k - 1) / k - 1;
if (!ends) {
if (b < need) return INF;
if (b == need) return a % k + (a % k == 0) * k;
if (b > need) return 1;
} else {
if (b == need) return INF;
if (b > need) return 1;
}
}
return get(b, a - min(a, (k - lst)), 0, !ends);
} else {
return get(b, a - 1, 0, !ends);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &x[i]);
}
bool fck = false;
for (int i = 1; i <= n; i++) {
scanf("%d", &y[i]);
if (x[i] < (y[i] + k - 1) / k - 1) fck = true;
if (y[i] < (x[i] + k - 1) / k - 1) fck = true;
}
if (fck) {
puts("NO");
return 0;
}
memset(dp, INF, sizeof(dp));
dp[0][0] = dp[0][1] = 0;
for (int i = 1; i <= n; i++) {
int last_t = dp[i - 1][0];
int last_f = dp[i - 1][1];
if (last_f != INF) {
minv(dp[i][0], get(x[i], y[i], 0, 0));
minv(dp[i][0], get(y[i], x[i], last_f, 1));
minv(dp[i][1], get(x[i], y[i], 0, 1));
minv(dp[i][1], get(y[i], x[i], last_f, 0));
}
if (last_t != INF) {
minv(dp[i][0], get(x[i], y[i], last_t, 0));
minv(dp[i][0], get(y[i], x[i], 0, 1));
minv(dp[i][1], get(x[i], y[i], last_t, 1));
minv(dp[i][1], get(y[i], x[i], 0, 0));
}
}
if (dp[n][0] <= k or dp[n][1] <= k)
puts("YES");
else
puts("NO");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> n >> m;
vector<int> v(n);
for (int& i : v) cin >> i;
unordered_set<int> ust;
ust.insert(v.back());
v.back() = 1;
for (int i = n - 2; i > -1; --i) {
ust.insert(v[i]);
v[i] = ust.size();
}
while (m--) {
cin >> n;
cout << v[n - 1] << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int MOD = 1e9 + 7;
long long cnt = 1, mini;
string s = "";
long long a[N];
map<long long, long long> mp;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, lst = 0, k, flag = 0, i = 0, j;
cin >> n;
j = n - 1;
for (int i = 0; i < n; i++) cin >> a[i];
long long l = 0, r = n - 1;
while (l <= r) {
if (a[l] > lst && a[r] > lst) {
if (a[l] < a[r]) s += "L", lst = a[l], ++l;
if (a[r] < a[l]) s += "R", lst = a[r], --r;
if (a[l] == a[r]) {
string ss, sss;
l++;
lst = a[l - 1];
while (lst < a[l]) {
ss += "L";
lst = a[l];
l++;
}
r--;
lst = a[r + 1];
while (lst < a[r]) {
sss += "R";
lst = a[r];
r--;
}
if (ss.size() > sss.size())
s = s + "L" + ss;
else
s = s + "R" + sss;
break;
}
} else if (a[l] > lst) {
lst = a[l];
s += "L";
++l;
} else if (a[r] > lst) {
lst = a[r];
s += "R";
--r;
} else
break;
}
cout << s.size() << "\n" << s;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int inf_int = 2e9;
long long inf_ll = 2e18;
const double pi = 3.1415926535898;
long long binpow(long long a, long long n) {
if (n == 0) {
return 1;
}
long long res = 1;
while (n) {
if (n % 2 == 1) {
res *= a;
}
a *= a;
n /= 2;
}
return res;
}
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
const double EPS = 1e-7;
int siz(long long x) {
if (x < 1e1) {
return 1;
} else if (x < 1e2) {
return 2;
} else if (x < 1e3) {
return 3;
} else if (x < 1e4) {
return 4;
} else if (x < 1e5) {
return 5;
} else if (x < 1e6) {
return 6;
} else if (x < 1e7) {
return 7;
} else if (x < 1e8) {
return 8;
} else if (x < 1e9) {
return 9;
} else if (x < 1e10) {
return 10;
}
}
long long a, b;
queue<long long> q;
map<long long, bool> used;
map<long long, long long> p;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> a >> b;
q.push(a);
used[a] = 1;
p[a] = -1;
while (!q.empty()) {
long long v = q.front();
q.pop();
long long next;
next = v * 2;
if (next <= b && !used[next]) {
q.push(next);
p[next] = v;
used[next] = 1;
}
next = v * 10 + 1;
if (next <= b && !used[next]) {
q.push(next);
p[next] = v;
used[next] = 1;
}
}
if (used[b]) {
cout << "YES" << endl;
vector<long long> ans;
for (long long v = b; v != -1; v = p[v]) {
ans.push_back(v);
}
reverse(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i];
if (i != ans.size() - 1) {
cout << " ";
}
}
cout << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void null() { return; }
const long long INF = 3e18 + 9237;
const long long maxn = 1e5 + 7;
const long long mod = 1e9 + 7;
const long long sqN = 320;
const long long lgN = 20;
long long bit[12][3];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 0; i <= 11; i++) bit[i][1] = 1;
for (long long i = 0, x; i < n; i++) {
char c;
cin >> c >> x;
for (long long i = 0; i < 11; i++)
for (long long j = 0; j < 2; j++) {
long long tmp = x & (1 << i);
if (c == '^')
bit[i][j] ^= (tmp != 0);
else if (c == '|')
bit[i][j] |= (tmp != 0);
else
bit[i][j] &= (tmp != 0);
}
}
cout << "2\n| ";
long long tmp = 0;
for (long long i = 0; i < 10; i++)
if (bit[i][0] == bit[i][1]) tmp += (1 << i);
cout << tmp << "\n^ ";
tmp = 0;
for (long long i = 0; i < 10; i++)
if (bit[i][1] == 0) tmp += (1 << i);
cout << tmp;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
long long n, x;
while (t--) {
cin >> n >> x;
cout << x * 2 << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void r1(T &x) {
x = 0;
char c(getchar());
int f(1);
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x * 10) + (c ^ 48);
x *= f;
}
const int maxn = 3e5 + 5;
int f[maxn], last[maxn], first[maxn], a[maxn];
int n;
int main() {
int i, j, t;
r1(t);
while (t--) {
r1(n);
for (i = 1; i <= n; ++i) {
r1(a[i]);
if (!first[a[i]]) first[a[i]] = i;
last[a[i]] = i;
}
sort(a + 1, a + n + 1);
int len = unique(a + 1, a + n + 1) - a - 1;
int res(0);
for (i = 1; i <= len; ++i) {
if (first[a[i]] > last[a[i - 1]])
f[i] = f[i - 1] + 1;
else
f[i] = 1;
res = max(res, f[i]);
}
printf("%d\n", len - res);
for (i = 1; i <= len; ++i) f[i] = first[a[i]] = last[a[i]] = 0;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100;
int a, b, p1, p2;
int main() {
cin >> a >> b;
p1 = (a > 0) ? (1) : (-1);
p2 = (b > 0) ? (1) : (-1);
a = abs(a), b = abs(b);
int x = a + b;
if (p1 > 0 && p2 > 0)
cout << "0 " << x << " " << x << " 0" << endl;
else if (p1 < 0 && p2 > 0)
cout << -x << " 0 0 " << x << endl;
else if (p1 > 0 && p2 < 0)
cout << "0 " << -x << " " << x << " 0" << endl;
else
cout << -x << " 0 0 " << -x << endl;
fclose(stdin);
fclose(stdout);
return 0;
}
| 1 |
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#include<bits/stdc++.h>
using namespace std;
#define ull unsigned long long
const int N=1e6+7;
int n,q,siz; ull sum;
long long w[N],g[N],P[N<<2],Q;
struct node{
int t; long long u;
}e[N];
struct Tree{
ull F[N<<2],G[N<<2],H[N<<2]; int st[N],siz[N<<2],res[N];
inline void add(int l,int r,int t,int ql,int qr,ull T){
if(l==ql&&r==qr){
F[t]=F[t]+siz[t]*T,G[t]+=T,H[t]+=T; return;
}
if(G[t]){
F[t<<1]+=G[t]*siz[t<<1],F[t<<1|1]+=G[t]*siz[t<<1|1];
G[t<<1]+=G[t],G[t<<1|1]+=G[t],G[t]=0;
}
int d=(l+r)>>1;
if(ql<=d) add(l,d,t<<1,ql,min(d,qr),T);
if(d+1<=qr) add(d+1,r,t<<1|1,max(d+1,ql),qr,T);
F[t]=F[t<<1]+F[t<<1|1];
}
inline ull getpos(int l,int r,int t,int x){
ull ans=0;
while(l!=r){
ans+=H[t];
int d=(l+r)>>1;
if(siz[t<<1]>=x) r=d,t=t<<1;
else l=d+1,x-=siz[t<<1],t=t<<1|1;
}
return ans+H[t];
}
inline ull getans(int l,int r,int t,int ql,int qr){
if(l==ql&&r==qr) return F[t];
if(G[t]){
F[t<<1]+=G[t]*siz[t<<1],F[t<<1|1]+=G[t]*siz[t<<1|1];
G[t<<1]+=G[t],G[t<<1|1]+=G[t],G[t]=0;
}
int d=(l+r)>>1; ull ans=0;
if(ql<=d) ans+=getans(l,d,t<<1,ql,min(d,qr));
if(d+1<=qr) ans+=getans(d+1,r,t<<1|1,max(d+1,ql),qr);
return ans;
}
inline ull getval(int l,int r,int t,int x){
ull ans=0;
while(l!=r&&siz[t]!=x){
if(G[t]){
F[t<<1]+=G[t]*siz[t<<1],F[t<<1|1]+=G[t]*siz[t<<1|1];
G[t<<1]+=G[t],G[t<<1|1]+=G[t],G[t]=0;
}
int d=(l+r)>>1;
if(siz[t<<1]>=x) t=t<<1,r=d;
else ans+=F[t<<1],x-=siz[t<<1],l=d+1,t=t<<1|1;
}
return ans+F[t];
}
inline void getsiz(int l,int r,int t,int C,int x){
st[0]=0;
t=P[C];
while(t>0) st[++st[0]]=t,t=t>>1;
for(int i=st[0];i>=1;i--){
t=st[i];
if(G[t]){
F[t<<1]+=G[t]*siz[t<<1],F[t<<1|1]+=G[t]*siz[t<<1|1];
G[t<<1]+=G[t],G[t<<1|1]+=G[t],G[t]=0;
}
}
t=P[C];
siz[t]+=x,F[t]=Q,t=t>>1;
while(t>0){
siz[t]+=x,F[t]=F[t<<1]+F[t<<1|1],t=t>>1;
}
}
inline int lowbit(int u){
return (u&(-u));
}
inline void addx(int u,int c){
while(u<=g[0]) res[u]+=c,u+=lowbit(u);
}
inline int getres(int u){
int sum=0;
while(u>0) sum+=res[u],u-=lowbit(u); return sum;
}
}A,B;
inline int F(long long u){
int l=1,r=g[0];
while(l<=r){
int d=(l+r)>>1;
if(g[d]==u) return d;
else if(g[d]>u) r=d-1; else l=d+1;
}
}
inline void add(long long u){
int x=F(u); Q=u,siz++,sum+=u,A.addx(x,1);
if(A.getres(x)>1) Q+=A.getpos(1,g[0],1,A.getres(x)-1);
A.add(1,g[0],1,x,g[0],u);
A.getsiz(1,g[0],1,x,1);
x=g[0]-x+1; Q=u,B.addx(x,1);
if(B.getres(x)>1) Q+=B.getpos(1,g[0],1,B.getres(x)-1);
B.add(1,g[0],1,x,g[0],u);
B.getsiz(1,g[0],1,x,1);
}
inline void del(long long u){
int x=F(u); Q=0,siz--,sum-=u,A.addx(x,-1);
A.add(1,g[0],1,x,g[0],-u);
A.getsiz(1,g[0],1,x,-1);
x=g[0]-x+1; Q=0,B.addx(x,-1);
B.add(1,g[0],1,x,g[0],-u);
B.getsiz(1,g[0],1,x,-1);
}
inline void write(ull u){
if(u>9) write(u/10); putchar(u%10+'0');
}
inline ull getA(int u){
if(u==0) return u;
return A.getpos(1,g[0],1,u);
}
inline ull getB(int u){
if(u==0) return u;
return B.getpos(1,g[0],1,u);
}
inline ull sol(){
ull ans=B.F[1];
int l=0,r=siz/2,pos=siz/2,pot=siz/2;
if(getA(siz/2+1)>getB(siz/2)){
ans=ans-A.F[1]; return ans;
}
while(l<=r){
int d=(l+r)>>1;
if(getA(d+1)<=getB(d)) pos=d,r=d-1; else l=d+1;
}
l=siz/2+1,r=siz-1;
while(l<=r){
int d=(l+r)>>1;
if(getA(d+1)<=getB(d)) pot=d,l=d+1; else r=d-1;
}
if(pos>0) ans=ans-A.getval(1,g[0],1,pos);
ans=ans-B.getval(1,g[0],1,pot);
if(pos>1) ans=ans+B.getval(1,g[0],1,pos-1);
ans=ans-A.F[1]+A.getval(1,g[0],1,pot+1); return ans;
}
inline long long read(){
long long num=0; char g=getchar(); while(g<48||57<g) g=getchar();
while(47<g&&g<58) num=(num<<1)+(num<<3)+g-48,g=getchar(); return num;
}
inline void build(int l,int r,int t){
if(l==r){
P[l]=t; return;
}
int d=(l+r)>>1;
build(l,d,t<<1),build(d+1,r,t<<1|1);
}
int main(){
// freopen("in.txt","r",stdin);
// freopen("p.txt","w",stdout);
cin>>n>>q;
for(int i=1;i<=n;i++) w[i]=read(),g[i]=w[i]; g[0]=n;
for(int i=1;i<=q;i++){
e[i].t=read(),e[i].u=read(),g[++g[0]]=e[i].u;
}
sort(g+1,g+g[0]+1); build(1,g[0],1);
for(int i=1;i<=n;i++) add(w[i]);
write(sol()),putchar('\n');
for(int i=1;i<=q;i++){
if(e[i].t==1) add(e[i].u); else del(e[i].u); write(sol()),putchar('\n');
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void debug_out(T t) {
cerr << t;
}
template <typename A, typename B>
void debug_out(pair<A, B> u) {
cerr << "(" << u.first << " " << u.second << ")";
}
template <typename T>
void debug_out(vector<T> t) {
int sz = t.size();
for (int i = 0; i < sz; i++) {
debug_out(t[i]);
if (i != sz - 1) cerr << ", ";
}
}
template <typename T>
void debug_out(vector<vector<T>> t) {
int sz = t.size();
for (int i = 0; i < sz; i++) {
debug_out(t[i]);
if (i != sz - 1) cerr << endl;
}
}
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
debug_out(H);
cerr << " ";
debug_out(T...);
}
template <typename T>
void debug_out(set<T> a) {
vector<T> _a;
for (T t : a) _a.push_back(t);
debug_out(_a);
}
int n;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
vector<string> g;
vector<int> deg;
vector<int> was;
long long res;
long long pos;
int edge(int x, int y) {
char c = g[x][y / 4];
int to = (c >= '0' && c <= '9' ? (c - '0') : (c - 'A' + 10));
return ((to >> ((((3 - y) % 4) + 4) % 4)) & 1);
}
void sort(vector<int> &id, int l, int r) {
if (l == r) return;
shuffle(id.begin() + l, id.begin() + r + 1, rng);
int cur = r;
for (int i = r; i > l; i--) {
if (edge(id[l], id[i])) {
swap(id[i], id[cur]);
cur--;
}
}
swap(id[l], id[cur]);
if (l < cur) sort(id, l, cur - 1);
if (cur < r) sort(id, cur + 1, r);
}
void solve(vector<int> id, vector<int> cp) {
if (id.empty()) return;
vector<int> from, to;
int root = -1;
for (int i : id) {
if (root == -1 || cp[i] < cp[root]) root = i;
}
for (int i = 0; i < n; i++) {
if (edge(root, i)) to.push_back(i);
}
for (int i = 0; i < n; i++) {
if (i == root || edge(i, root)) from.push_back(i);
}
if (!to.empty()) sort(to, 0, (int)to.size() - 1);
sort(from.begin(), from.end(), [&](int x, int y) { return edge(x, y); });
int sz = to.size();
reverse(from.begin(), from.end());
reverse(to.begin(), to.end());
vector<int> l(sz), r(sz);
vector<int> ret(n, -1);
for (int i = 0; i < sz; i++) {
if (i > 0) l[i] = l[i - 1];
while (l[i] < (int)from.size() && edge(from[l[i]], to[i])) l[i]++;
int lo = l[i], hi = from.size();
if (lo == hi) {
r[i] = lo;
continue;
}
while (hi - lo > 1) {
int mid = (hi + lo) >> 1;
if (!edge(from[mid], to[i]))
lo = mid;
else
hi = mid;
}
r[i] = lo;
ret[l[i]] = max(ret[l[i]], r[i]);
}
set<int> cur;
sz = from.size();
for (int i = sz - 1; i > -1; i--) {
if (!was[from[i]]) {
was[from[i]] = 1;
int left = deg[root] - (deg[from[i]] - i);
res += 2 * left;
pos -= left;
if (i < sz - 1) {
while (cur.size() && *cur.begin() <= ret[i + 1]) cur.erase(cur.begin());
}
int cnt = sz - 1 - i - cur.size();
res += 2 * cnt;
pos -= cnt;
}
cur.insert(i);
}
vector<int> nxt;
vector<int> cxt(n);
for (int i = 0; i < (int)to.size(); i++) {
if (!was[to[i]]) {
nxt.push_back(to[i]);
cxt[to[i]] = i;
}
}
solve(nxt, cxt);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
g.resize(n);
deg.resize(n);
was.resize(n);
for (int i = 0; i < n; i++) {
cin >> g[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
deg[i] += edge(i, j);
}
}
res = n * (n - 1) / 2;
pos = n * (n - 1) / 2;
int root = 0;
for (int i = 0; i < n; i++) {
if (deg[i] < deg[root]) root = i;
}
vector<int> cur;
for (int i = 0; i < n; i++) {
if (edge(i, root)) cur.push_back(i);
}
sort(cur.begin(), cur.end(), [&](int x, int y) { return edge(x, y); });
int cnt = 0;
int sz = cur.size();
for (int i = 0; i < sz; i++) {
if (deg[cur[i]] == deg[root] + sz - i) {
cnt++;
} else {
break;
}
}
res += 614LL * n * (cnt * (n - cnt) + cnt * (cnt - 1) / 2);
pos -= cnt * (n - cnt) + cnt * (cnt - 1) / 2;
vector<int> id(n);
iota(id.begin(), id.end(), 0);
solve(id, deg);
res += pos * 3;
cout << res;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int qwerg = 0; qwerg < t; qwerg++) {
int n, k;
cin >> n >> k;
vector<long> a(n);
vector<int> w(k);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < k; i++) {
cin >> w[i];
}
sort(a.begin(), a.end());
sort(w.begin(), w.end());
vector<int> delet;
int sum = 0;
long long answer = 0;
for (int i = 0; i < k; i++) {
if (w[i] == 1) {
answer += a[n - i - 1];
delet.push_back(i);
}
answer += a[n - i - 1];
}
for (int i = delet.size() - 1; i > -1; i--) {
w.erase(w.begin() + delet[i]);
}
k = k - delet.size();
for (int i = k - 1; i > -1; i--) {
answer += a[sum];
sum = sum + w[i] - 1;
}
cout << answer << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T read1() {
T t = 0;
char k;
bool vis = 0;
do (k = getchar()) == '-' && (vis = 1);
while ('0' > k || k > '9');
while ('0' <= k && k <= '9')
t = (t << 3) + (t << 1) + (k ^ '0'), k = getchar();
return vis ? -t : t;
}
struct A {
int l, r, w, c;
A(int _l = 0, int _r = 0, int _w = 0, int _c = 0)
: l(_l), r(_r), w(_w), c(_c) {}
bool operator<(const A &b) const { return w < b.w; }
} a[200005];
pair<int, int> fr[100005];
int s, f[200005];
bool vis[100005], use[100005];
priority_queue<int> q[800005], q_[800008];
int mx[800005], mn[800005];
void pushup(int d, bool x) {
x ? mx[d] = mn[d] = 0 : mx[d] = max(mx[d << 1], mx[d << 1 | 1]),
mn[d] = min(mn[d << 1], mn[d << 1 | 1]);
if (q[d].size())
use[q[d].top()] ? mn[d] = max(mn[d], q[d].top())
: mx[d] = max(mx[d], q[d].top());
if (mx[d] < mn[d]) mx[d] = 0;
}
void add(int l, int r, int tl, int tr, int w, int d) {
if (l == tl && r == tr) {
if (w)
if (vis[w])
q_[d].push(w);
else
q[d].push(w);
while (q_[d].size() && q[d].top() == q_[d].top()) q[d].pop(), q_[d].pop();
pushup(d, tl == tr);
return;
}
int mid = tl + tr >> 1;
if (r <= mid)
add(l, r, tl, mid, w, d << 1);
else if (mid < l)
add(l, r, mid + 1, tr, w, d << 1 | 1);
else
add(l, mid, tl, mid, w, d << 1),
add(mid + 1, r, mid + 1, tr, w, d << 1 | 1);
pushup(d, 0);
}
int main() {
s = read1<long long>();
int n = s << 1;
for (int i = 0; i < s; ++i) {
int lx = read1<long long>(), ly = read1<long long>(),
rx = read1<long long>(), ry = read1<long long>();
a[i << 1] = A(ly, ry, lx, i + 1);
a[i << 1 | 1] = A(ly, ry, rx, i + 1);
f[++f[0]] = ly;
f[++f[0]] = ry;
fr[i + 1] = make_pair(ly, ry);
}
sort(f + 1, f + f[0] + 1);
f[0] = unique(f + 1, f + f[0] + 1) - f - 1;
sort(a, a + n);
for (int i = 1; i <= s; ++i)
fr[i] = make_pair((lower_bound(f + 1, f + f[0] + 1, fr[i].first) - f),
(lower_bound(f + 1, f + f[0] + 1, fr[i].second) - f));
int ans = 1;
for (int i = 0; i < n;) {
do
add(a[i].l = (lower_bound(f + 1, f + f[0] + 1, a[i].l) - f),
a[i].r = (lower_bound(f + 1, f + f[0] + 1, a[i].r) - f) - 1, 1, f[0],
a[i].c, 1),
vis[a[i].c] = 1;
while (++i < n && a[i].w == a[i - 1].w);
while (mx[1]) {
use[mx[1]] = 1;
++ans;
add(fr[mx[1]].first, fr[mx[1]].second - 1, 1, f[0], 0, 1);
}
}
cout << ans;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INV2 = (MOD + 1) / 2;
int n, k;
vector<int> G[100005];
int dp[100005][205];
int siz[100005];
int tmp[205];
void poly_mul(int dp0[], int sz0, int dp1[], int sz1) {
for (int i = 0; i <= min(sz0 + sz1, k); i++) tmp[i] = 0;
for (int i = 0; i <= min(sz0, k); i++)
for (int j = 0; j <= min(sz1, k); j++)
if (i + j <= k) tmp[i + j] = (tmp[i + j] + 1LL * dp0[i] * dp1[j]) % MOD;
for (int i = 0; i <= min(sz0 + sz1, k); i++) dp0[i] = tmp[i];
}
int inv[205];
int fac[205], ifac[205];
int S[205][205];
int pw2[100005], ipw2[100005];
void gen_comb() {
inv[1] = 1;
for (int i = 2; i <= k; i++)
inv[i] = MOD - 1LL * inv[MOD % i] * (MOD / i) % MOD;
fac[0] = ifac[0] = 1;
for (int i = 1; i <= (int)(k); i++) {
fac[i] = 1LL * fac[i - 1] * i % MOD;
ifac[i] = 1LL * ifac[i - 1] * inv[i] % MOD;
}
pw2[0] = ipw2[0] = 1;
for (int i = 1; i <= (int)(n); i++) {
pw2[i] = pw2[i - 1] * 2 % MOD;
ipw2[i] = 1LL * ipw2[i - 1] * INV2 % MOD;
}
S[0][0] = 1;
for (int i = 1; i <= (int)(k); i++)
for (int j = 1; j <= (int)(i); j++)
S[i][j] = (S[i - 1][j - 1] + 1LL * S[i - 1][j] * j) % MOD;
}
int comb(int n, int m) {
return fac[n] * (1LL * ifac[m] * ifac[n - m] % MOD) % MOD;
}
void gen_dp(int v, int par) {
siz[v] = 0;
dp[v][0] = 1;
for (int i = 0; i < (int)(G[v].size()); i++) {
int u = G[v][i];
if (u == par) continue;
gen_dp(u, v);
poly_mul(dp[v], siz[v], dp[u], siz[u]);
siz[v] += siz[u];
}
siz[v]++;
for (int i = min(siz[v], k); i > 0; i--) {
dp[v][i] = (dp[v][i] + dp[v][i - 1]) % MOD;
if (i == 1)
dp[v][i] =
(dp[v][i] - 1LL * dp[v][i - 1] * ipw2[siz[v]] % MOD + MOD) % MOD;
}
}
int getans(int k) {
int ans = 0;
if (k == 1) {
for (int i = 1; i <= (int)(n); i++) {
ans = (ans + pw2[n] + G[i].size() - 1) % MOD;
for (int j = 0; j < (int)(G[i].size()); j++) {
int nj = G[i][j];
if (siz[nj] > siz[i])
ans = (ans - pw2[n - siz[i]] + MOD) % MOD;
else
ans = (ans - pw2[siz[nj]] + MOD) % MOD;
}
}
} else {
ans = dp[1][k];
for (int i = 1; i <= (int)(n); i++)
for (int j = 0; j < (int)(G[i].size()); j++)
if (siz[G[i][j]] < siz[i])
ans = (ans - 1LL * dp[G[i][j]][k - 1] * ipw2[n - siz[G[i][j]]] % MOD +
MOD) %
MOD;
ans = 1LL * pw2[n] * ans % MOD;
}
return ans;
}
int cans[205], pans[205];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < (int)(n - 1); i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
gen_comb();
gen_dp(1, -1);
cans[0] = pw2[n] - 1;
for (int i = 1; i <= (int)(k); i++) cans[i] = getans(i);
for (int i = 0; i <= k; i++)
for (int j = 0; j <= i; j++)
pans[i] = (pans[i] + 1LL * S[i][j] * fac[j] % MOD * cans[j]) % MOD;
int ans = 0;
for (int i = 0; i <= k; i++)
ans = (ans + 1LL * comb(k, i) * pans[i] % MOD * (k - i & 1 ? MOD - 1 : 1)) %
MOD;
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long a, b;
bool operator<(const node& y) const {
return a < y.a || (a == y.a && b < y.b);
}
} h;
struct stu {
long long t, a, b;
} s[500005];
long long q, _, tv, n, i, m, c, sum = 0, mr, c0, kc, ans = 0;
multiset<node> st;
multiset<node>::iterator it;
bool cmp(stu a, stu b) {
if (a.t != b.t) return a.t < b.t;
if (a.a != b.a) return a.a < b.a;
return a.b < b.b;
}
int main() {
scanf("%lld", &q);
for (_ = 1; _ <= q; _++) {
scanf("%lld%lld%lld%lld", &n, &m, &c, &c0);
st.clear();
for (i = 1; i <= n; i++) scanf("%lld%lld%lld", &s[i].t, &s[i].a, &s[i].b);
sort(s + 1, s + n + 1, cmp);
ans = 0;
st.insert((node){0, c0});
kc = c0;
tv = 0;
for (i = 1; i <= n; i++) {
while (tv < s[i].t) {
if (st.empty()) {
printf("-1\n");
goto tag;
}
h = *(st.begin());
it = st.begin();
st.erase(it);
kc -= h.b;
mr = min(h.b, s[i].t - tv);
tv += mr;
if (mr < h.b) st.insert((node){h.a, h.b - mr}), kc += h.b - mr;
}
mr = min(s[i].a, c - kc);
kc += mr;
while (mr < s[i].a && !st.empty()) {
it = st.end();
--it;
h = *it;
if (h.a <= s[i].b) break;
sum = min(h.b, s[i].a - mr);
ans -= h.a * sum;
mr += sum;
st.erase(it);
if (sum < h.b) st.insert((node){h.a, h.b - sum});
}
ans += s[i].b * mr;
st.insert((node){s[i].b, mr});
}
while (tv < m) {
if (st.empty()) {
printf("-1\n");
goto tag;
}
h = *(st.begin());
it = st.begin();
st.erase(it);
kc -= h.b;
mr = min(h.b, m - tv);
tv += mr;
if (mr < h.b) st.insert((node){h.a, h.b - mr}), kc += h.b - mr;
}
while (!st.empty()) {
it = st.begin();
h = *it;
st.erase(it);
ans -= h.a * h.b;
}
printf("%lld\n", ans);
tag:;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long b, long long p, long long md) {
if (p == 0) return 1;
if (p % 2 == 1) {
return ((b % md) * bigmod(b, p - 1, md)) % md;
} else {
long long y = bigmod(b, p / 2, md);
return (y * y) % md;
}
}
long long arr[306][306];
long long brr[306][306];
long long n, m;
long long dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
long long check(long long a, long long b) {
long long cnt = 0;
for (long long i = 0; i < 4; i++) {
long long x = a + dx[i];
long long y = b + dy[i];
if (x < n && x >= 0 && y >= 0 && y < m) cnt++;
}
return cnt;
}
int main() {
long long t;
cin >> t;
while (t--) {
cin >> n >> m;
bool flag = true;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> arr[i][j];
brr[i][j] = check(i, j);
if (arr[i][j] > brr[i][j]) flag = false;
}
}
if (flag == false)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cout << brr[i][j] << " ";
cout << endl;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<string> ans;
bool check(string &email) {
if (email.length() < 2) return 0;
if (email[0] == '@') return 0;
bool was_dog = 0;
for (int i = 1; i < email.length() - 1; i++) {
if (email[i] == '@' && was_dog) return 0;
if (email[i] == '@') was_dog = 1;
}
if (email.back() == '@') return 0;
if (!was_dog) return 0;
return 1;
}
int main() {
string s;
cin >> s;
for (int i = 1; i < s.length(); i++) {
if (s[i] == s[i - 1] && s[i] == '@') {
cout << "No solution";
return 0;
}
}
if (s.back() == '@' || s[0] == '@') {
cout << "No solution";
return 0;
}
string a = "";
for (int i = 0; i < s.length(); i++) {
if (s[i] != '@') {
a += s[i];
continue;
}
a += s[i];
a += s[i + 1];
ans.push_back(a);
a = "";
i++;
}
if (ans.size()) ans.back() += a;
for (int i = 0; i < ans.size(); i++) {
if (!check(ans[i])) {
cout << "No solution";
return 0;
}
}
if (ans.size() == 0) {
cout << "No solution";
return 0;
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i];
if (i != ans.size() - 1) cout << ",";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-12;
class Pt3d {
public:
int x, y, z;
Pt3d() {}
Pt3d(int x, int y, int z) {
this->x = x;
this->y = y;
this->z = z;
}
};
class Pt2d {
public:
double x, y;
Pt2d() {}
Pt2d(double x, double y, int t = -1) {
this->x = x;
this->y = y;
}
void operator=(const Pt2d &pt2) {
this->x = pt2.x;
this->y = pt2.y;
}
friend bool operator==(const Pt2d &pt1, const Pt2d &pt2) {
return fabs(pt1.x - pt2.x) < eps && fabs(pt1.y - pt2.y) < eps;
}
friend bool operator!=(const Pt2d &pt1, const Pt2d &pt2) {
return fabs(pt1.x - pt2.x) > eps && fabs(pt1.y - pt2.y) > eps;
}
};
struct MyLine {
double A, B, C;
MyLine() {}
};
int n, m;
Pt3d pt3[900];
Pt2d pt[900];
Pt2d rCenter;
double r = 0.0;
unsigned int ptR[4];
unsigned int ptRSize = 0;
void init() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i)
scanf("%d %d %d", &pt3[i].x, &pt3[i].y, &pt3[i].z);
}
double lenPt2(Pt2d &pt1, Pt2d &pt2) {
return sqrt(pow(pt1.x - pt2.x, 2.0) + pow(pt1.y - pt2.y, 2.0));
}
Pt2d centerPt2(const Pt2d &pt1, const Pt2d &pt2) {
return Pt2d((pt1.x + pt2.x) / 2, (pt1.y + pt2.y) / 2);
}
void calcLine(Pt2d pt2d, MyLine &myline) {
myline.C = -pt2d.x * myline.A - pt2d.y * myline.B;
}
Pt2d centerCircle(const Pt2d &pt1, const Pt2d &pt2) {
return Pt2d((pt1.x + pt2.x) / 2, (pt1.y + pt2.y) / 2);
}
Pt2d centerCircle(const Pt2d &pt1, const Pt2d &pt2, const Pt2d &pt3) {
Pt2d res;
MyLine myline[2];
myline[0].A = pt1.x - pt2.x;
myline[0].B = pt1.y - pt2.y;
calcLine(centerPt2(pt1, pt2), myline[0]);
myline[1].A = pt1.x - pt3.x;
myline[1].B = pt1.y - pt3.y;
calcLine(centerPt2(pt1, pt3), myline[1]);
double d = (myline[0].A * myline[1].B - myline[1].A * myline[0].B);
res.x = (-myline[0].C * myline[1].B + myline[1].C * myline[0].B) / d;
res.y = (-myline[0].A * myline[1].C + myline[1].A * myline[0].C) / d;
return res;
}
bool isOneLine(const Pt2d &pt1, const Pt2d &pt2, const Pt2d &pt3) {
return (pt3.x - pt1.x) * (pt2.y - pt1.y) == (pt3.y - pt1.y) * (pt2.x - pt1.x);
}
bool isNotEqual(const Pt2d &pt1, const Pt2d &pt2, const Pt2d &pt3) {
return pt1 != pt2 && pt2 != pt3;
}
void createCircle() {
Pt2d *superPt = &pt[ptR[ptRSize - 1]];
unsigned int arr[2] = {111111, 111111};
bool flag = true;
bool resizeR = false;
for (unsigned int i = 0; i < ptRSize - 1; ++i) {
Pt2d newRCenter = centerCircle(pt[ptR[i]], *superPt);
double newR = lenPt2(newRCenter, pt[ptR[i]]);
if (resizeR && newR > r) continue;
bool isRightCircle = true;
for (unsigned int j = 0; j < ptRSize - 1; ++j)
if (j != i) {
double d = lenPt2(newRCenter, pt[ptR[j]]);
if (d > newR + eps) {
isRightCircle = false;
break;
}
}
if (isRightCircle) {
arr[0] = ptR[i];
r = newR;
rCenter = newRCenter;
resizeR = true;
}
}
if (resizeR) {
ptR[0] = arr[0];
ptR[1] = ptR[ptRSize - 1];
ptR[2] = 1111111;
ptR[3] = 1111111;
ptRSize = 2;
rCenter = centerCircle(pt[ptR[0]], pt[ptR[1]]);
r = lenPt2(rCenter, pt[ptR[0]]);
return;
}
arr[0] = 111111;
flag = true;
resizeR = false;
for (unsigned int i = 0; i < ptRSize - 2; ++i)
for (unsigned int j = i + 1; j < ptRSize - 1; ++j)
if (!isOneLine(pt[ptR[i]], pt[ptR[j]], *superPt)) {
Pt2d newRCenter = centerCircle(*superPt, pt[ptR[i]], pt[ptR[j]]);
double newR = lenPt2(newRCenter, *superPt);
if (resizeR && newR > r) continue;
flag = true;
for (unsigned int k = 0; k < ptRSize - 1; ++k)
if (k != i && k != j) {
double d = lenPt2(newRCenter, pt[ptR[k]]);
if (d > newR + eps) {
flag = false;
break;
}
}
if (flag) {
rCenter = newRCenter;
r = newR;
arr[0] = ptR[i];
arr[1] = ptR[j];
resizeR = true;
}
}
ptR[0] = arr[0];
ptR[1] = arr[1];
ptR[2] = ptR[ptRSize - 1];
ptR[3] = 1111111;
ptRSize = 3;
rCenter = centerCircle(pt[ptR[0]], pt[ptR[1]], pt[ptR[2]]);
r = lenPt2(rCenter, pt[ptR[0]]);
}
bool isOutsideCircle(unsigned int &id) {
return lenPt2(rCenter, pt[id]) > r + eps;
}
void calcNewR(unsigned int id) {
ptR[ptRSize] = id;
++ptRSize;
createCircle();
bool flag = true;
while (flag) {
flag = false;
for (unsigned int i = 0; i < id; ++i)
if (i != ptR[0] && i != ptR[1] && i != ptR[2] && i != ptR[3]) {
if (lenPt2(rCenter, pt[i]) > r + eps) {
ptR[ptRSize] = i;
++ptRSize;
createCircle();
flag = true;
break;
}
}
}
}
double calcR() {
if (n == 1) return 0;
ptRSize = 2;
ptR[0] = 0;
ptR[1] = 1;
ptR[2] = 100000;
ptR[3] = 100000;
rCenter = centerPt2(pt[ptR[0]], pt[ptR[1]]);
r = lenPt2(pt[ptR[0]], rCenter);
for (int j = 2; j < n; ++j)
if (lenPt2(rCenter, pt[j]) > r + eps) {
calcNewR(j);
}
return r;
}
Pt2d calcPt2d(int &A, int &B, int &C, Pt3d &pt3d) {
if (A == 0 && B == 0) return Pt2d(pt3d.x, pt3d.y);
if (B == 0 && C == 0) return Pt2d(pt3d.y, pt3d.z);
if (C == 0 && A == 0) return Pt2d(pt3d.z, pt3d.x);
double t =
-(A * pt3d.x + B * pt3d.y + C * pt3d.z) / (double)(A * A + B * B + C * C);
double x = pt3d.x + t * A, y = pt3d.y + t * B, z = pt3d.z + t * C;
double aa = sqrt(x * x + y * y + z * z), bb = sqrt(B * B + C * C),
cc = sqrt(x * x + (C + y) * (C + y) + (z - B) * (z - B));
if (fabs(aa) < eps) return Pt2d(0, 0);
double ang = acos((aa * aa + bb * bb - cc * cc) / (2 * aa * bb));
if (x < 0) ang = -ang;
return Pt2d(aa * cos(ang), aa * sin(ang));
}
int main() {
init();
for (int i = 0; i < m; ++i) {
int A, B, C;
scanf("%d %d %d", &A, &B, &C);
for (unsigned int j = 0; j < (unsigned int)n; ++j) {
pt[j] = calcPt2d(A, B, C, pt3[j]);
}
printf("%.7f\n", calcR());
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long PR = 1000000009;
set<int> nbr[500];
int cnt = 0, ht[500], fl = 0, h, qr[500];
void query(int a) {
if (qr[a]) {
cout << "NONONO" << '\n';
}
qr[a] = 1;
cout << '?' << ' ' << a << '\n';
fflush(stdout);
int nb, br[3];
cin >> nb;
if (nb == 0) {
exit(0);
}
nbr[a].clear();
for (int i = 0; i < nb; ++i) {
cin >> br[i];
nbr[a].insert(br[i]);
}
if (nb == 1) {
ht[a] = 1;
}
if (nb == 2) {
fl = 1;
}
}
void answer(int a) {
cout << "! " << a << '\n';
fflush(stdout);
}
void solve(int st) {
int pres = *(nbr[st].begin()), prev = st;
vector<int> path;
ht[pres] = ht[st] + 1;
if (ht[pres] == h) {
answer(pres);
fl = 0;
return;
}
if (ht[pres] >= 5) {
set<int> toquery;
query(pres);
if (fl) {
answer(pres);
fl = 0;
return;
}
nbr[pres].erase(st);
set<int>::iterator it = nbr[pres].begin();
query(*it);
if (fl) {
answer(*it);
fl = 0;
return;
}
nbr[*it].erase(pres);
for (set<int>::iterator it1 = nbr[*it].begin(); it1 != nbr[*it].end();
it1++)
toquery.insert(*it1);
it++;
query(*it);
if (fl) {
answer(*it);
fl = 0;
return;
}
nbr[*it].erase(pres);
for (set<int>::iterator it1 = nbr[*it].begin(); it1 != nbr[*it].end();
it1++)
toquery.insert(*it1);
while (toquery.size() > 1) {
query(*(toquery.begin()));
if (fl) {
answer(*(toquery.begin()));
fl = 0;
return;
}
toquery.erase(*(toquery.begin()));
}
answer(*(toquery.begin()));
return;
}
path.push_back(pres);
while (1) {
query(pres);
ht[pres] = ht[prev] + 1;
if (fl) {
answer(pres);
fl = 0;
return;
}
nbr[pres].erase(prev);
if (nbr[pres].empty()) break;
int t = pres;
pres = *(nbr[pres].begin());
prev = t;
nbr[t].erase(pres);
path.push_back(pres);
}
int next = path.back();
for (int i = path.size() - 1; i >= 0; i--) {
ht[path[i]] = min(ht[path[i]], (int)(path.size() - i));
if (ht[path[i]] > ht[next]) next = path[i];
}
solve(next);
}
void startup(int st) {
vector<int> p1, p2;
int pres = st, prev = -1;
p1.push_back(st);
while (1) {
query(pres);
if (fl) {
answer(pres);
fl = 0;
return;
}
if (nbr[pres].size() == 1) break;
nbr[pres].erase(prev);
if (nbr[pres].empty()) break;
int t = pres;
pres = *(nbr[pres].begin());
prev = t;
nbr[t].erase(pres);
p1.push_back(pres);
}
if (p1.size() == 1) {
ht[st] = 1;
solve(st);
return;
}
pres = *(nbr[st].begin()), prev = st;
nbr[st].erase(pres);
p2.push_back(pres);
while (1) {
query(pres);
if (fl) {
answer(pres);
fl = 0;
return;
}
if (nbr[pres].size() == 1) break;
nbr[pres].erase(prev);
if (nbr[pres].empty()) break;
int t = pres;
pres = *(nbr[pres].begin());
prev = t;
nbr[t].erase(pres);
p2.push_back(pres);
}
vector<int> total;
for (int i = p1.size() - 1; i >= 0; i--) {
total.push_back(p1[i]);
}
for (int i = 0; i < p2.size(); i++) {
total.push_back(p2[i]);
}
ht[total[total.size() / 2]] = total.size() / 2 + 1;
solve(total[total.size() / 2]);
}
int main() {
ios::sync_with_stdio(false);
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
cin >> h;
fl = 0;
for (int i = 1; i < 500; i++) {
nbr[i].clear();
qr[i] = 0;
}
startup(1);
}
return 0;
};
| 10 |
#include <bits/stdc++.h>
#define MAX 1000000001
#define f for
//#define OFFLINE 1
using namespace std;
/********************************************/
void arrayInput(int a[],int n){
f(int i=0;i<n;i++) cin>>a[i];
}
vector<int> vectorArray(int n){
vector <int> toReturn;
for(int i=0;i<n;i++){int t;cin>>t;toReturn.push_back(t);}return toReturn;
}
/********************************************/
typedef pair<int, int> Pair;
void findPairs(int arr[], int n)
{
map<int, vector<Pair> > map;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
int sum = arr[i] + arr[j];
if (map.find(sum) != map.end()) {
for (auto pair : map.find(sum)->second) {
int m = pair.first, n = pair.second;
if ((m != i && m != j) && (n != i && n != j)) {
cout<<"YES\n";
cout << 1+i << " "
<< 1+j << " "
<< m+1 << " " << n+1<<endl;
return;
}
}
}
map[sum].push_back({ i, j });
}
}
cout << "NO\n";
}
int main(){
#ifdef OFFLINE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
ios :: sync_with_stdio(false);
cin.tie(0);
int n;cin>>n;
int a[n],s=-1;
map<int,int> m;
for(int i=0;i<n;i++){
cin>>a[i];
m[a[i]]++;
if(m[a[i]]>=4)
s=a[i];
}
if(s==-1)
findPairs(a,n);
else{
cout<<"YES\n";
int k=0;
for(int i=0;i<n;i++){
if(a[i]==s && k<4){
cout<<i+1<<" ";
k++;
}
}
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
const int BIG=100,nmax=2e5+42;
const long long base=1e9+42;
vector< pair<int/*value*/,int/*id*/> > active[nmax];
vector< int/*value*/ > seen[nmax];
int n;
void compress()
{
vector< int > nums={};
for(int i=1;i<=n;i++)
{
for(auto w:seen[i])
nums.push_back(w);
}
sort(nums.begin(),nums.end());
for(int i=1;i<=n;i++)
{
vector<int> seen_new={};
for(auto w:seen[i])
{
int pos=lower_bound(nums.begin(),nums.end(),w)-nums.begin();
seen_new.push_back(pos);
}
seen[i]=seen_new;
//for(auto w:seen[i])cout<<w<<" ";cout<<endl;
}
}
int cnt[nmax];
void push(int id,int coeff)
{
for(auto w:seen[id])
cnt[w]+=coeff;
}
void solve()
{
scanf("%i",&n);
//n=200;
int pointer=0;
for(int i=1;i<=n;i++)
{
int SZ;
scanf("%i",&SZ);
pointer+=SZ;
//SZ=1000;
seen[i]={};
for(int j=1;j<=SZ;j++)
{
int num;
scanf("%i",&num);
seen[i].push_back(num);
}
sort(seen[i].begin(),seen[i].end());
}
for(int i=0;i<=pointer;i++)active[i]={};
compress();
for(int i=1;i<=n;i++)
{
if(seen[i].size()<BIG)
{
for(auto p:seen[i])
for(auto q:seen[i])
if(p<q)
{
active[p].push_back({q,i});
}
}
else
{
push(i,1);
for(int j=1;j<=n;j++)
if(j!=i)
{
int cur=0;
for(auto w:seen[j])
{
if(cnt[w])cur++;
//cout<<"test "<<w<<" -> "<<seen[i].count(w)<<endl;
}
//cout<<i<<" "<<j<<" -> "<<cur<<endl;
if(cur>=2)
{
printf("%i %i\n",j,i);
push(i,-1);
return;
}
}
push(i,-1);
}
}
for(int i=0;i<=pointer;i++)
{
sort(active[i].begin(),active[i].end());
for(int j=1;j<active[i].size();j++)
if(active[i][j-1].first==active[i][j].first)
{
printf("%i %i\n",active[i][j-1].second,active[i][j].second);
return;
}
}
printf("-1\n");
}
int main()
{
int t;
scanf("%i",&t);
//t=1;
while(t)
{
t--;
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int n, k, i;
char c0[100100], c1[100100];
int points[26][100100];
int main(void) {
scanf("%d %d %s", &n, &k, c0);
memset(points, 0xff, sizeof(points));
for (i = 0; i < k; i++) {
points[c0[i] - 'a'][i] = 0;
}
int x;
for (x = 'a'; x <= 'z'; x++) {
int curpos = 0;
while (curpos < k) {
int nxpos = -1;
for (i = curpos; i < k; i++) {
if (points[x - 'a'][i] == 0) {
nxpos = i;
break;
}
}
for (i = curpos; i < nxpos; i++) {
if (points[x - 'a'][i] >= 0) {
if (nxpos != -1) {
points[x - 'a'][i] =
((points[x - 'a'][i]) <= (nxpos - i) ? (points[x - 'a'][i])
: (nxpos - i));
}
} else {
points[x - 'a'][i] = (nxpos == -1) ? -1 : nxpos - i;
}
}
curpos = nxpos + 1;
if (nxpos == -1) {
break;
}
}
curpos = k - 1;
while (curpos >= 0) {
int nxpos = -1;
for (i = curpos; i >= 0; i--) {
if (points[x - 'a'][i] == 0) {
nxpos = i;
break;
}
}
for (i = curpos; i > nxpos; i--) {
if (points[x - 'a'][i] >= 0) {
if (nxpos != -1) {
points[x - 'a'][i] =
((points[x - 'a'][i]) <= (i - nxpos) ? (points[x - 'a'][i])
: (i - nxpos));
}
} else {
points[x - 'a'][i] = (nxpos == -1) ? -1 : i - nxpos;
}
}
curpos = nxpos - 1;
if (nxpos == -1) {
break;
}
}
}
for (i = 0; i < n; i++) {
scanf("%s", c1);
long long int result = 0;
int len = strlen(c1);
char* p = c1;
int j = 0;
while (*p != 0) {
if (points[*p - 'a'][j < k ? j : k - 1] == -1) {
result += (long long int)len;
} else {
if (j < k) {
result += (long long int)points[*p - 'a'][j];
} else {
result += (long long int)points[*p - 'a'][k - 1] + (j - (k - 1));
}
}
p++;
j++;
}
printf("%I64d\n", result);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int MAXN = 200000;
using namespace std;
inline int read() {
int x = 0, w = 1;
char c = ' ';
while (!isdigit(c)) {
c = getchar();
if (c == '-') w = -1;
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return x * w;
}
long long k, n, a, b;
void init() {
k = read();
n = read();
a = read();
b = read();
}
int main() {
int q = read();
while (q--) {
init();
long long ans2;
double ans = (k - n * b) * 1.0 / (a - b);
if ((k - n * b) % (a - b)) {
ans2 = floor(ans);
} else {
ans2 = ans - 1;
}
if (ans > 0) {
printf("%I64d\n", min(n, max(0LL, ans2)));
} else {
puts("-1");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j;
cin >> n >> k;
vector<int> a, b;
int s = 0;
for (i = 0; i < n; i++) {
int x;
cin >> x;
s += x;
a.push_back(x);
b.push_back(s);
}
cout.precision(15);
cout << fixed;
int ss = 0, d = 0;
for (i = n; i >= k; i--) {
int c = 0;
if (i == n) {
ss = b[n - 1];
d = n;
} else {
for (j = 0; j <= n - i; j++) {
if (j == 0) {
if (ss / (d * 1.0) < (b[j + i - 1]) / (1.0 * i)) {
ss = b[j + i - 1];
d = i;
c = 1;
}
} else if (ss / (d * 1.0) < (b[j + i - 1] - b[j - 1]) / (1.0 * i)) {
ss = b[j + i - 1] - b[j - 1];
d = i;
c = 1;
}
}
}
}
cout << ss / (d * 1.0);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
struct T {
int x, y;
} a[maxn];
bool operator<(const T& a, const T& b) { return a.x < b.x; }
long long ans = 1;
int n, m, c[maxn], Mod;
void solve() {
int del = 0, k;
long long tmp = 1;
sort(c, c + m);
for (int i = 0; i < m - 1; i++)
if (c[i] == c[i + 1]) del++;
for (int i = 2; i <= m; i++) {
k = i;
while ((~k & 1) && (del > 0)) k = k >> 1, del--;
tmp = tmp * k % Mod;
}
ans = ans * tmp % Mod;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].x);
a[i].y = i;
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[i + n].x);
a[i + n].y = i;
}
sort(a, a + n + n);
cin >> Mod;
int i, j;
for (i = 0; i < n * 2; i = j + 1) {
for (j = i + 1; j < n * 2; j++)
if (a[i].x != a[j].x) break;
j--;
if (i == j) continue;
memset(c, 0, sizeof(c));
for (int k = i; k <= j; k++) c[k - i] = a[k].y;
m = j - i + 1;
solve();
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
const double PI = atan(1) * 4;
const double E = exp(1);
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
string arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int prev[n][m][4];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < 4; k++) prev[i][j][k] = 0;
if (arr[i][j] == '*') {
if (i)
prev[i][j][0] = 1 + prev[i - 1][j][0];
else
prev[i][j][0] = 1;
if (j)
prev[i][j][1] = 1 + prev[i][j - 1][1];
else
prev[i][j][1] = 1;
}
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
if (arr[i][j] == '*') {
if (i + 1 < n)
prev[i][j][2] = 1 + prev[i + 1][j][2];
else
prev[i][j][2] = 1;
if (j + 1 < m)
prev[i][j][3] = 1 + prev[i][j + 1][3];
else
prev[i][j][3] = 1;
}
}
}
vector<tuple<int, int, int> > res;
int ver[n][m], hor[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) ver[i][j] = hor[i][j] = -1;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int size = 2 * n;
for (int k = 0; k < 4; k++) size = min(size, prev[i][j][k] - 1);
if (size > 0) {
res.push_back(make_tuple(i, j, size));
ver[i][j] = max(ver[i][j], i + size);
ver[i - size][j] = max(ver[i - size][j], i + size);
hor[i][j] = max(hor[i][j], j + size);
hor[i][j - size] = max(hor[i][j - size], j + size);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i) ver[i][j] = max(ver[i][j], ver[i - 1][j]);
if (j) hor[i][j] = max(hor[i][j], hor[i][j - 1]);
}
}
bool b = true;
for (int i = 0; i < n and b; i++) {
for (int j = 0; j < m and b; j++) {
if (arr[i][j] == '*' and ver[i][j] < i and hor[i][j] < j) {
b = false;
}
}
}
if (b) {
cout << ((int)((res).size())) << '\n';
for (auto t : res) {
int a, b, c;
tie(a, b, c) = t;
cout << a + 1 << ' ' << b + 1 << ' ' << c << '\n';
}
} else
cout << "-1\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const long long inv2 = (mod + 1) / 2;
const int MAXN = (1 << 17);
void fft(vector<int> &a, int low, int high) {
if (low == high - 1) return;
int len = (high - low) / 2, mid = low + len;
fft(a, low, mid);
fft(a, mid, high);
for (int i = low; i < mid; i++) {
int x1 = a[i];
int x2 = a[i + len];
a[i] = (x1 - x2) % mod;
a[i + len] = (x1 + x2) % mod;
}
}
void inv_fft(vector<int> &a, int low, int high) {
if (low == high - 1) return;
int len = (high - low) / 2, mid = low + len;
for (int i = low; i < mid; i++) {
int y1 = a[i];
int y2 = a[i + len];
a[i] = (y1 + y2) * inv2 % mod;
a[i + len] = (y2 - y1) * inv2 % mod;
}
inv_fft(a, low, mid);
inv_fft(a, mid, high);
}
vector<int> mul1(vector<int> A, vector<int> B) {
fft(A, 0, A.size());
fft(B, 0, B.size());
vector<int> res(A.size());
for (int i = 0; i < res.size(); i++) res[i] = A[i] * (long long)B[i] % mod;
inv_fft(res, 0, res.size());
return res;
}
vector<int> mul2(vector<int> A, vector<int> B) {
vector<int> res(A.size());
for (int m = 0; m < res.size(); ++m) {
long long sum = 0;
for (int s = m; s; s = (s - 1) & m) {
sum += A[s] * (long long)B[m ^ s];
}
sum += A[0] * (long long)B[m];
res[m] = sum % mod;
}
return res;
}
void conv(vector<int> &x) {
for (int b = 1; b < x.size(); b *= 2) {
for (int s = 0; s < x.size(); s += 2 * b)
for (int i = s; i < s + b; ++i) {
x[i] = (x[i] + x[i ^ b]) % mod;
}
}
}
void convinv(vector<long long> &x) {
for (int b = 1; b < x.size(); b *= 2) {
for (int s = 0; s < x.size(); s += 2 * b)
for (int i = s; i < s + b; ++i) {
x[i] = (x[i] - x[i ^ b]) % mod;
}
}
}
vector<int> f(vector<int> a) {
vector<int> fib(a.size());
fib[1] = 1;
for (int i = 2; i < fib.size(); ++i) fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
for (int i = 0; i < a.size(); ++i) {
a[i] = a[i] * (long long)fib[i] % mod;
}
conv(a);
return a;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n;
cin >> n;
vector<int> a(MAXN);
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
++a[x];
}
vector<int> b = mul1(a, a);
vector<int> c = mul2(a, a);
a = f(a);
b = f(b);
c = f(c);
vector<long long> res(a.size());
for (int i = 0; i < a.size(); ++i) {
res[i] = a[i] * (long long)b[i] % mod * c[i] % mod;
}
convinv(res);
long long sum = 0;
for (int b = 1; b < a.size(); b *= 2) {
sum += res[b];
}
cout << (sum % mod + mod) % mod << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long ans;
int main() {
cin >> n;
long long t = 9;
while (n > 0) {
ans += n;
n -= t;
t = t * 10;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
int main() {
int n, x, y;
cin >> n >> x >> y;
for (int i = 1; i <= n; i++) cin >> a[i];
if (x > y)
cout << n << endl;
else {
sort(a + 1, a + n + 1);
int sum = 0;
for (int i = 1; i <= n; i++) {
if (a[i] > x) break;
sum++;
}
if (sum % 2 == 1)
cout << sum / 2 + 1 << endl;
else
cout << sum / 2 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, xmn = INFINITY, xmx = -INFINITY, ymn = INFINITY, ymx = -INFINITY,
x;
int main() {
cin >> n;
while (n--) {
long long x1, y1;
cin >> x1 >> y1;
(xmx) = max((xmx), (x1));
(xmn) = min((xmn), (x1));
(ymx) = max((ymx), (y1));
(ymn) = min((ymn), (y1));
}
x = max(xmx - xmn, ymx - ymn);
return cout << x * x << '\n', false;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int ts, kk = 1;
vector<int> v;
int n;
char a[2005];
char b[2005];
char c[2005];
int fr[26];
int get(char c) {
int i;
for (i = n - 1; i > -1 && a[i] != c; i--)
;
return i;
}
void upd(int x) {
if (x == 0) return;
if (x < 0 || x > n) assert(0);
v.push_back(x);
int i, j;
for (i = 0, j = n - 1; i < x; i++, j--) c[i] = a[j];
for (j = 0; i < n; i++, j++) c[i] = a[j];
for (i = 0; i < n; i++) a[i] = c[i];
}
int main() {
int t, i, j, k;
scanf("%d %s %s", &n, a, b);
for (i = 0; i < n; i++) fr[a[i] - 'a']++;
bool sm = 1;
for (i = 0; i < n; i++) {
fr[b[i] - 'a']--;
if (a[i] != b[i]) sm = 0;
}
for (i = 0; i < 26; i++)
if (fr[i] != 0) {
printf("-1\n");
return 0;
}
if (sm) {
printf("0\n\n");
return 0;
}
k = (n - 1) / 2;
j = get(b[k]);
upd(n - j - 1);
upd(n);
int l, r;
l = r = k;
while (min(l, r) != 0 || max(l, r) != n - 1) {
if (l <= r) {
if (0 < l) {
k = get(b[l - 1]);
l--;
upd(n - k);
upd(k - (r - l));
} else
upd(n - (r - l + 1));
upd(n);
swap(l, r);
} else {
if (l < n - 1) {
k = get(b[l + 1]);
l++;
upd(n - k);
upd(k - (l - r));
} else
upd(n - (l - r + 1));
upd(n);
swap(l, r);
}
}
for (i = 0; i < n; i++)
if (a[i] != b[i]) break;
if (i < n) upd(n);
printf("%d\n", v.size());
for (i = 0; i < v.size(); i++) {
if (i)
printf(" %d", v[i]);
else
printf("%d", v[i]);
}
printf("\n");
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define ull unsigned long long int
#define mod 1000000007
#define mod2 998244353
#define pb push_back
#define mp make_pair
#define count_1(n) __builtin_popcountll(n) //set bits
#define fr first
#define sc second
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--)
{
ll r,b,d;
cin>>r>>b>>d;
ll dif=abs(r-b);
ll mnm=min(r,b);
ll d1=(dif+mnm-1)/mnm;
if(d1>d) cout<<"NO\n";
else cout<<"YES\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[31] = {0, 5};
long long b[31] = {0, 1};
string nms[5] = {"Sheldon", "Leonard", "Penny", "Rajesh", "Howard"};
int main() {
int u = 5;
for (int i = 2; i < 31; i++) {
u *= 2;
a[i] = a[i - 1] + u;
b[i] = b[i - 1] * 2;
}
int n;
cin >> n;
int i = 0;
while (n > a[i]) i++;
n -= a[i - 1];
int j = 0;
while (n - b[i] > 0) {
n -= b[i];
j++;
}
cout << nms[j];
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> l(n), r(n);
for (int i = 0; i < n; ++i) {
cin >> l[i] >> r[i];
}
vector<int> maxPrefL(n), maxSuffL(n), minPrefR(n), minSuffR(n);
maxPrefL[0] = l[0];
minPrefR[0] = r[0];
for (int i = 1; i < n; ++i) {
maxPrefL[i] = max(l[i], maxPrefL[i - 1]);
minPrefR[i] = min(r[i], minPrefR[i - 1]);
}
maxSuffL[n - 1] = l[n - 1];
minSuffR[n - 1] = r[n - 1];
for (int i = n - 2; i >= 0; --i) {
maxSuffL[i] = max(l[i], maxSuffL[i + 1]);
minSuffR[i] = min(r[i], minSuffR[i + 1]);
}
int ans = 0;
for (int i = 0; i < n; ++i) {
int left = max((i == 0 ? -100 : maxPrefL[i - 1]),
(i == n - 1 ? -100 : maxSuffL[i + 1]));
int right = min((i == 0 ? 1000000009 : minPrefR[i - 1]),
(i == n - 1 ? 1000000009 : minSuffR[i + 1]));
ans = max(ans, right - left);
}
cout << ans << '\n';
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.