solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
#define forn(i,s,t) for(register int i=(s);i<=(t);++i)
using namespace std;
typedef long long LL;
const int N = 1e5 + 3, M = 24;
struct List {int dir, nxt;} E[N<<1];
int G[N], cnt;
inline void Add(int u, int v) {
E[++cnt].dir = v, E[cnt].nxt = G[u], G[u] = cnt;
}
int n, k; LL a[N], F[N][M][2], Ans[N];
void F_dfs(int u, int fa) {
F[u][0][0] = a[u];
for(register int i=G[u];i;i=E[i].nxt) {
int v = E[i].dir;
if(v == fa) continue ;
F_dfs(v, u);
forn(j,0,k - 2) {
F[u][j + 1][0] ^= F[v][j][0];
F[u][j + 1][1] ^= F[v][j][1];
}
F[u][0][0] ^= F[v][k - 1][1];
F[u][0][1] ^= F[v][k - 1][0];
}
}
inline void Opt(int u, int v) {
forn(j,0,k - 2) {
F[u][j + 1][0] ^= F[v][j][0];
F[u][j + 1][1] ^= F[v][j][1];
}
F[u][0][0] ^= F[v][k - 1][1];
F[u][0][1] ^= F[v][k - 1][0];
}
void S_dfs(int u, int fa) {
(u != 1) && (Opt(u, fa), 0);
forn(i,0,k - 1) Ans[u] ^= F[u][i][1];
for(register int i=G[u];i;i=E[i].nxt) {
int v = E[i].dir;
if(v == fa) continue ;
Opt(u, v), S_dfs(v, u);
Opt(u, v);
}
(u != 1) && (Opt(u, fa), 0);
}
int main() {
scanf("%d%d", &n, &k);
forn(i,2,n) {
static int u, v;
scanf("%d%d", &u, &v);
Add(u, v), Add(v, u);
}
forn(i,1,n) scanf("%lld", a + i);
F_dfs(1, -1), S_dfs(1, -1);
forn(i,1,n) printf("%d%c", (!!Ans[i]), " \n"[i == n]);
return 0;
}// OJ:: LG | 8 |
#include <bits/stdc++.h>
using namespace std;
int thing(int a, int b, int n) { return ((b - a) % n + n) % n; }
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<set<int>> gr(n);
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
gr[a].insert(thing(a, b, n));
gr[b].insert(thing(b, a, n));
}
vector<int> fact = {1};
for (int i = 2; i * i <= n; ++i) {
if (n % i) continue;
fact.push_back(i);
if (i * i < n) fact.push_back(n / i);
}
for (auto &i : fact) {
bool ok = 1;
for (int j = 0; j < n; ++j)
if (gr[j] != gr[(j + i) % n]) {
ok = 0;
break;
}
if (ok) {
printf("Yes\n");
return 0;
}
}
printf("No\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
if (m > n)
cout << -1;
else if (n == m)
cout << n;
else {
int x = n;
while (x) {
int div = x / 2;
int y = div + (n - (div * 2));
if (y % m == 0) {
cout << y;
break;
} else
x -= 2;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int uf[n], sz[n], x[n], y[n];
for (int i = 0; i < n; i++) {
uf[i] = i;
cin >> x[i] >> y[i];
for (int j = 0; j < i; j++) {
if (x[j] == x[i]) {
int k = j, m = i;
while (uf[k] != k) k = uf[k];
while (uf[m] != m) m = uf[m];
if (k != m) {
if (sz[k] > sz[m]) {
sz[k] += sz[m];
uf[m] = k;
} else {
sz[m] += sz[k];
uf[k] = m;
}
}
}
if (y[j] == y[i]) {
int k = j, m = i;
while (uf[k] != k) k = uf[k];
while (uf[m] != m) m = uf[m];
if (k != m) {
if (sz[k] > sz[m]) {
sz[k] += sz[m];
uf[m] = k;
} else {
sz[m] += sz[k];
uf[k] = m;
}
}
}
}
}
int ct = -1;
for (int i = 0; i < n; i++) {
if (uf[i] == i) ct++;
}
cout << ct << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int i, j, n, m, p[4], a[1001];
bool cmp(int x, int y) { return a[x] < a[y]; }
int cnt = 0;
int top = 0;
int o1[100001], o2[100001];
void add(int a, int b) {
top++;
o1[top] = a;
o2[top] = b;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] != 0) {
cnt++;
}
}
if (cnt <= 1) {
printf("-1");
return 0;
}
for (p[2] = 1, p[3] = 2, i = 3; i <= n; ++i) {
p[1] = i;
while (1) {
if (a[p[1]] > a[p[2]]) swap(p[1], p[2]);
if (a[p[2]] > a[p[3]]) swap(p[2], p[3]);
if (a[p[1]] > a[p[2]]) swap(p[1], p[2]);
if (a[p[1]] == 0) {
break;
}
for (j = a[p[2]] / a[p[1]]; j; j >>= 1) {
if (j & 1) {
add(p[1], p[2]);
a[p[2]] -= a[p[1]];
} else {
add(p[1], p[3]);
a[p[3]] -= a[p[1]];
}
a[p[1]] *= 2;
}
}
}
printf("%d\n", top);
for (int i = 1; i <= top; i++) {
printf("%d %d\n", o1[i], o2[i]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
int ans = a * b * c;
ans = max(ans, (a + b) * c);
ans = max(ans, a * (b + c));
ans = max(ans, a + b + c);
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, k, a[N], l[N], r[N], vis[N], pre[N];
vector<int> G[N];
vector<pair<int, int> > vec;
void bfs1() {
for (int i = 1; i <= n; i++) vis[i] = 0;
queue<int> q;
q.push(1);
vis[1] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto v : G[u]) {
if (vis[v]) continue;
l[v] = l[u] + 1;
q.push(v);
vis[v] = 1;
}
}
}
void bfs2() {
for (int i = 1; i <= n; i++) vis[i] = 0;
queue<int> q;
q.push(n);
vis[n] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto v : G[u]) {
if (vis[v]) continue;
r[v] = r[u] + 1;
q.push(v);
vis[v] = 1;
}
}
}
bool cmp(pair<int, int> a, pair<int, int> b) { return a.first < b.first; }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
a[i] = x;
}
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
bfs1();
bfs2();
for (int i = 1; i <= k; i++) {
vec.push_back({l[a[i]] - r[a[i]], a[i]});
}
sort(vec.begin(), vec.end(), cmp);
pre[0] = vec[0].second;
for (int i = 1; i < k; i++) {
int u = vec[i].second;
if (l[u] > l[pre[i - 1]])
pre[i] = u;
else
pre[i] = pre[i - 1];
}
int mx = -1;
for (int i = 1; i < k; i++) {
int u = vec[i].second;
int now = r[u] + l[pre[i - 1]] + 1;
mx = max(mx, now);
}
int ans = min(l[n], mx);
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
const int N = (int)2e5 + 7;
const int inf = (int)1e9 + 7;
const int mod = (int)1e9 + 7;
const long long linf = (long long)1e18 + 7;
const int dx[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
using namespace std;
int n, m;
int a[N];
long long tme;
vector<int> pos[N];
vector<int> cmp;
long long t[N << 2];
int cnt[N << 2];
void build(int v = 1, int tl = 1, int tr = n) {
if (tl == tr) {
if ((long long)a[tl] <= tme) {
t[v] = a[tl];
cnt[v] = 1;
} else {
t[v] = cnt[v] = 0;
}
return;
}
int tm = tl + tr >> 1;
build(v << 1, tl, tm);
build(v << 1 | 1, tm + 1, tr);
t[v] = t[v << 1] + t[v << 1 | 1];
cnt[v] = cnt[v << 1] + cnt[v << 1 | 1];
}
void upd(int p, int v = 1, int tl = 1, int tr = n) {
if (tl == tr) {
t[v] = cnt[v] = 0;
return;
}
int tm = tl + tr >> 1;
if (p <= tm)
upd(p, v << 1, tl, tm);
else
upd(p, v << 1 | 1, tm + 1, tr);
t[v] = t[v << 1] + t[v << 1 | 1];
cnt[v] = cnt[v << 1] + cnt[v << 1 | 1];
}
int kth(int x, int v = 1, int tl = 1, int tr = n) {
if (tl == tr) return tl;
int tm = tl + tr >> 1;
if (cnt[v << 1] >= x) return kth(x, v << 1, tl, tm);
return kth(x - cnt[v << 1], v << 1 | 1, tm + 1, tr);
}
pair<long long, int> get(int l, int r, int v = 1, int tl = 1, int tr = n) {
if (l <= tl && tr <= r) {
return {t[v], cnt[v]};
}
if (tl > r || tr < l) return {0ll, 0};
int tm = tl + tr >> 1;
pair<long long, int> L = get(l, r, v << 1, tl, tm);
pair<long long, int> R = get(l, r, v << 1 | 1, tm + 1, tr);
L.first += R.first;
L.second += R.second;
return L;
}
long long calc(int p) {
pair<long long, int> cur = get(1, p);
if (cur.second < m) return cur.first;
if (cur.second % m) {
int mid = kth((cur.second / m) * m);
long long res = get(1, mid).first * 2;
if (mid < p) res += get(mid + 1, p).first;
return res;
} else {
if (cur.second == m) return get(1, p).first;
int mid = kth(cur.second - m);
long long res = get(1, mid).first * 2;
if (mid < p) res += get(mid + 1, p).first;
return res;
}
}
void solve() {
cin >> n >> m >> tme;
cmp.clear();
for (int i = (1); i <= (n); i++) {
cin >> a[i];
if (a[i] > tme) continue;
cmp.push_back(a[i]);
pos[a[i]].push_back(i);
}
sort(cmp.begin(), cmp.end());
cmp.erase(unique(cmp.begin(), cmp.end()), cmp.end());
reverse(cmp.begin(), cmp.end());
build();
int p = 0, mx = 0, ans = 0;
for (auto it : cmp) {
while (p + 1 <= n && calc(p + 1) <= tme) ++p;
while (p > 0 && calc(p) > tme) --p;
int now = get(1, p).second;
if (now > mx) {
mx = now, ans = it;
}
for (auto p : pos[it]) upd(p);
pos[it].clear();
}
ans = max(ans, 1);
if (ans > tme) ans = tme;
cout << mx << ' ' << ans << '\n';
}
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) solve();
exit(0);
}
| 6 |
#include <bits/stdc++.h>
int is_right(int x1, int y1, int x2, int y2, int x3, int y3) {
if (x1 == x2 && y1 == y2) return 0;
if (x2 == x3 && y2 == y3) return 0;
if (x3 == x1 && y3 == y1) return 0;
int s1 = pow(x1 - x2, 2) + pow(y1 - y2, 2);
int s2 = pow(x2 - x3, 2) + pow(y2 - y3, 2);
int s3 = pow(x3 - x1, 2) + pow(y3 - y1, 2);
if (s1 == s2 + s3 || s2 == s1 + s3 || s3 == s1 + s2)
return 1;
else
return 0;
}
using namespace std;
int main() {
int i, j, n, x[7], ans;
for (i = 1; i <= 6; i++) cin >> x[i];
ans = is_right(x[1], x[2], x[3], x[4], x[5], x[6]);
if (ans) {
cout << "RIGHT";
return 0;
}
for (i = 1; i <= 6; i++) {
x[i]++;
ans = is_right(x[1], x[2], x[3], x[4], x[5], x[6]);
if (ans) {
cout << "ALMOST";
return 0;
}
x[i]--;
}
for (i = 1; i <= 6; i++) {
x[i]--;
ans = is_right(x[1], x[2], x[3], x[4], x[5], x[6]);
if (ans) {
cout << "ALMOST";
return 0;
}
x[i]++;
}
cout << "NEITHER";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, q;
char s[maxn];
struct Tree {
int d, mx1, mx2, mx3, mx4, mx5;
} tree[maxn * 4];
void updown(int rt) {
tree[rt].d = tree[rt << 1].d + tree[rt << 1 | 1].d;
tree[rt].mx1 =
max(tree[rt << 1].mx1, tree[rt << 1].d + tree[rt << 1 | 1].mx1);
tree[rt].mx2 =
max(tree[rt << 1].mx2, -2 * tree[rt << 1].d + tree[rt << 1 | 1].mx2);
tree[rt].mx3 =
max(max(tree[rt << 1].mx3, -tree[rt << 1].d + tree[rt << 1 | 1].mx3),
tree[rt << 1].mx1 - 2 * tree[rt << 1].d + tree[rt << 1 | 1].mx2);
tree[rt].mx4 =
max(max(tree[rt << 1].mx4, -tree[rt << 1].d + tree[rt << 1 | 1].mx4),
tree[rt << 1].mx2 + tree[rt << 1].d + tree[rt << 1 | 1].mx1);
tree[rt].mx5 =
max(max(tree[rt << 1].mx5, tree[rt << 1 | 1].mx5),
max(tree[rt << 1].mx1 - tree[rt << 1].d + tree[rt << 1 | 1].mx4,
tree[rt << 1].mx3 + tree[rt << 1].d + tree[rt << 1 | 1].mx1));
}
void build(int rt, int l, int r) {
if (l == r) {
if (s[l] == '(') {
tree[rt].d = 1;
tree[rt].mx1 = 1;
tree[rt].mx2 = 0;
tree[rt].mx3 = 0;
tree[rt].mx4 = 1;
tree[rt].mx5 = 1;
} else {
tree[rt].d = -1;
tree[rt].mx1 = 0;
tree[rt].mx2 = 2;
tree[rt].mx3 = 2;
tree[rt].mx4 = 1;
tree[rt].mx5 = 1;
}
return;
}
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
updown(rt);
}
void update(int rt, int l, int r, int x) {
if (l == r) {
if (s[x] == '(')
s[x] = ')';
else
s[x] = '(';
if (s[x] == '(') {
tree[rt].d = 1;
tree[rt].mx1 = 1;
tree[rt].mx2 = 0;
tree[rt].mx3 = 0;
tree[rt].mx4 = 1;
tree[rt].mx5 = 1;
} else {
tree[rt].d = -1;
tree[rt].mx1 = 0;
tree[rt].mx2 = 2;
tree[rt].mx3 = 2;
tree[rt].mx4 = 1;
tree[rt].mx5 = 1;
}
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
update(rt << 1, l, mid, x);
else
update(rt << 1 | 1, mid + 1, r, x);
updown(rt);
}
int main() {
scanf("%d%d%s", &n, &q, s + 1);
build(1, 1, 2 * (n - 1));
cout << tree[1].mx5 << endl;
for (int x, y, i = 1; i <= q; i++) {
scanf("%d%d", &x, &y);
update(1, 1, 2 * (n - 1), x);
update(1, 1, 2 * (n - 1), y);
cout << tree[1].mx5 << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using namespace rel_ops;
const double pi = acos(-1.0);
const double eps = 1e-11;
const int inf = 0x7FFFFFFF;
template <class T>
inline bool checkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
inline bool checkmax(T &a, T b) {
return b > a ? a = b, 1 : 0;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
const int N = 1e6 + 1000;
struct Node {
Node *l, *r, *fa;
int w, s, rev;
int v, sav;
void init(int t = 0) {
l = r = fa = NULL;
w = rand() * rand();
v = t;
s = 1;
sav = 0;
}
void up() { s = (l ? l->s : 0) + (r ? r->s : 0) + 1; }
void dn() {
if (sav) {
v += sav;
if (l) {
l->sav += sav;
}
if (r) {
r->sav += sav;
}
sav = 0;
}
if (rev) {
swap(l, r);
if (l) l->rev ^= 1;
if (r) r->rev ^= 1;
rev = 0;
}
}
} p[N];
void split(Node *p, Node *&a, Node *&b, int sz) {
p->dn();
if (sz <= 0)
a = NULL, b = p;
else if (sz >= (p ? p->s : 0))
a = p, b = NULL;
else if (sz <= (p->l ? p->l->s : 0)) {
split(p->l, a, p->l, sz), b = p;
a->fa = NULL;
if (p->l) p->l->fa = p;
} else {
split(p->r, p->r, b, sz - (p->l ? p->l->s : 0) - 1), a = p;
b->fa = NULL;
if (p->r) p->r->fa = p;
}
p->up();
}
Node *merge(Node *a, Node *b) {
if (!a || !b) return a ? a : b;
a->dn();
b->dn();
if (a->w > b->w) {
a->r = merge(a->r, b), a->r->fa = a;
a->up();
return a;
} else {
b->l = merge(a, b->l), b->l->fa = b;
b->up();
return b;
}
}
int getpos(Node *a) {
int ret = (a->l ? a->l->s : 0);
if (a->rev) ret = (a ? a->s : 0) - 1 - ret;
for (Node *b = a->fa; b; a = b, b = b->fa) {
if (a == b->r) ret += (b->l ? b->l->s : 0) + 1;
if (b->rev) ret = (b ? b->s : 0) - 1 - ret;
}
return ret;
}
void trace(Node *a) {
if (!a) return;
a->dn();
trace(a->l);
printf("%d\n", a->v);
trace(a->r);
}
Node *vis[N];
int main() {
int n, m;
srand(1);
while (~scanf("%d%d", &n, &m)) {
Node *root = NULL, *l, *r, *cur;
memset(vis, 0, sizeof(vis));
for (int i = 0; i < int(n); i++) {
p[i].init(0);
root = merge(root, p + i);
}
for (int i = 0; i < int(m); i++) {
int x, pp;
scanf("%d%d", &x, &pp);
split(root, l, r, pp - 1);
split(r, cur, r, 1);
root = merge(l, r);
if (vis[x] && vis[x] != cur) {
puts("-1");
return 0;
}
if (cur->v && cur->v != x) {
puts("-1");
return 0;
}
cur->v = x;
vis[x] = cur;
root = merge(cur, root);
}
int tot = 0;
for (int i = 0; i < n; i++) {
if (!p[i].v) {
while (vis[++tot])
;
p[i].v = tot;
}
}
for (int i = 0; i < int(n); i++) printf("%d ", p[i].v);
puts("");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long dobar(long long vr) {
long long sol = 0;
vr--;
for (int i = 1; i <= n; i++) sol += min(vr / i, m);
return sol;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> m >> k;
long long low = 1;
long long high = n * m + 1;
while (low < high) {
long long x = (low + high) / 2;
if (dobar(x) < k)
low = x + 1;
else
high = x;
}
cout << low - 1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, q;
cin >> n >> q;
while (q--) {
long long a;
cin >> a;
while (a % 2 == 0) {
a = a / 2 + n;
}
cout << (a + 1) / 2 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
int vis[MAXN];
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
memset(vis, 0, sizeof(vis));
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
vis[a] = vis[b] = 1;
}
printf("%d\n", n - 1);
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
for (int j = 1; j <= n; j++) {
if (i != j) {
printf("%d %d\n", i, j);
}
}
break;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> get_bin(int n) {
vector<int> ret;
while (n > 0) {
if (n % 2 == 0)
ret.push_back(0);
else
ret.push_back(1);
n /= 2;
}
return ret;
}
int main() {
int t;
t = 1;
while (t--) {
vector<pair<int, int> > pts;
for (int i = 0; i < 3; i++) {
int x, y;
cin >> x >> y;
pts.push_back({x, y});
}
set<pair<int, int> > sm_x;
set<pair<int, int> > sm_y;
if (pts[0].first == pts[1].first) sm_x.insert(pts[0]), sm_x.insert(pts[1]);
if (pts[1].first == pts[2].first) sm_x.insert(pts[1]), sm_x.insert(pts[2]);
if (pts[0].first == pts[2].first) sm_x.insert(pts[0]), sm_x.insert(pts[2]);
if (pts[0].second == pts[1].second)
sm_y.insert(pts[0]), sm_y.insert(pts[1]);
if (pts[1].second == pts[2].second)
sm_y.insert(pts[1]), sm_y.insert(pts[2]);
if (pts[0].second == pts[2].second)
sm_y.insert(pts[0]), sm_y.insert(pts[2]);
if (sm_x.size() == 3 || sm_y.size() == 3)
cout << 1 << endl;
else if (sm_x.size() == 2) {
int y1 = min((*(sm_x.begin())).second, (*(++sm_x.begin())).second);
int y2 = max((*(sm_x.begin())).second, (*(++sm_x.begin())).second);
int y3 = pts[0].second + pts[1].second + pts[2].second - y1 - y2;
if (y3 >= y2 || y3 <= y1)
cout << 2 << endl;
else
cout << 3 << endl;
} else if (sm_y.size() == 2) {
int x1 = min((*(sm_y.begin())).first, (*(++sm_y.begin())).first);
int x2 = max((*(sm_y.begin())).first, (*(++sm_y.begin())).first);
int x3 = pts[0].first + pts[1].first + pts[2].first - x1 - x2;
if (x3 >= x2 || x3 <= x1)
cout << 2 << endl;
else
cout << 3 << endl;
} else
cout << 3 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55 + 5;
const int inf = 0x3f3f3f3f;
int k, t, ans[N], c[N][N];
void init() {
c[0][0] = 1;
for (int i = (1); i < (N); i++) {
c[i][0] = 1;
for (int j = (1); j < (i + 1); j++) c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
}
}
int cnt[N];
long long f[N][N];
int gao(int len) {
memset(f, 0, sizeof(f));
f[0][0] = 1;
for (int i = (1); i < (16 + 1); i++) {
for (int j = 0; j <= len; j++) {
for (int k = 0; k <= min(j, cnt[i]); k++) {
f[i][j] += f[i - 1][j - k] * c[len - (j - k)][k];
}
}
}
return f[16][len];
}
long long calc(int len) {
long long res = 0;
for (int i = 2; i <= 16; i++) {
cnt[i]--;
res += gao(len - 1);
cnt[i]++;
}
return res;
}
int main() {
init();
cin >> k >> t;
for (int i = (1); i < (16 + 1); i++) cnt[i] = t;
int len = 1;
long long tmp;
while ((tmp = calc(len)) < k) {
len++;
k -= tmp;
}
for (int i = (1); i < (17); i++) cnt[i] = t;
for (int i = 1; i <= len; i++) {
int st = 1;
if (i == 1) st = 2;
for (int j = st; j <= 16; j++) {
if (cnt[j]) {
cnt[j]--;
long long cur = gao(len - i);
if (k <= cur) {
ans[i] = j;
break;
} else
k -= cur;
cnt[j]++;
}
}
}
for (int i = 1; i <= len; i++) {
ans[i]--;
if (ans[i] < 10)
cout << ans[i];
else {
char ch = ans[i] - 10 + 'a';
cout << ch;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[3010][3010];
int d[3010][3010];
bool used[3010];
void add_neighbor(int u, int v) {
int last = 0;
while (a[u][last] != -1) last++;
a[u][last] = v;
a[u][last + 1] = -1;
}
void bfs(int u) {
for (int i = 0; i < n; i++) used[i] = false;
d[u][u] = 0;
used[u] = true;
queue<int> q;
q.push(u);
while (q.size() != 0) {
int cur = q.front();
q.pop();
int n_i = 0;
while (a[cur][n_i] != -1) {
if (!used[a[cur][n_i]]) {
q.push(a[cur][n_i]);
used[a[cur][n_i]] = true;
d[u][a[cur][n_i]] = d[u][cur] + 1;
}
n_i++;
}
}
}
int main() {
scanf("%d %d", &n, &m);
int l, k;
for (int i = 0; i < n; i++)
for (int j = 0; j <= n; j++) a[i][j] = 0;
for (int i = 0; i < n; i++) a[i][0] = -1;
for (int i = 0; i < m; i++) {
scanf("%d %d", &l, &k);
add_neighbor(l - 1, k - 1);
add_neighbor(k - 1, l - 1);
}
int s1, t1, l1;
int s2, t2, l2;
scanf("%d %d %d", &s1, &t1, &l1);
scanf("%d %d %d", &s2, &t2, &l2);
s1--;
t1--;
s2--;
t2--;
for (int i = 0; i < n; i++) bfs(i);
if (d[s1][t1] > l1 || d[s2][t2] > l2) {
printf("-1");
return 0;
}
int ans = d[s1][t1] + d[s2][t2];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (d[i][j] + d[s1][i] + d[t1][j] <= l1 &&
d[i][j] + d[s2][i] + d[t2][j] <= l2)
ans = min(ans, d[i][j] + d[s1][i] + d[s2][i] + d[t1][j] + d[t2][j]);
if (d[i][j] + d[s1][i] + d[t1][j] <= l1 &&
d[i][j] + d[s2][j] + d[t2][i] <= l2)
ans = min(ans, d[i][j] + d[s1][i] + d[t2][i] + d[s2][j] + d[t1][j]);
}
printf("%d", m - ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
function<void(void)> ____ = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
const int MOD = (int)1e9 + 7;
const int inv2 = (MOD + 1) / 2;
struct Matrix {
int mat[2][2];
Matrix(int x) {
mat[0][0] = mat[1][1] = x;
mat[1][0] = mat[0][1] = 0;
}
int* operator[](int I) { return mat[I]; }
Matrix operator*(Matrix rhs) {
Matrix ret(0);
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
ret[i][j] = (ret[i][j] + 1ll * mat[i][k] * rhs[k][j]) % MOD;
return ret;
}
Matrix operator^(long long b) {
Matrix ret(1), a(*this);
for (; b; b >>= 1, a = a * a)
if (b & 1) ret = ret * a;
return ret;
}
};
int ksm(int a, long long b) {
int ret = 1;
for (; b; b >>= 1, a = 1ll * a * a % MOD)
if (b & 1) ret = 1ll * ret * a % MOD;
return ret;
}
void solve() {
int n;
scanf("%d", &n);
Matrix den(0);
den[0][1] = 2;
den[1][0] = den[1][1] = 1;
int num = 2;
for (int i = 1; i <= n; i++) {
long long x;
scanf("%lld", &x);
num = ksm(num, x);
den = den ^ x;
}
num = 1ll * num * inv2 % MOD;
Matrix inv(0);
inv[0][0] = MOD - inv2;
inv[0][1] = 1;
inv[1][0] = inv2;
den = den * inv;
cout << den[1][0] << "/" << num << endl;
}
int main() {
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
int v, u, t;
scanf("%d%d%d", &v, &u, &t);
if (u == v)
printf("%d\n", t);
else {
int ans = 0;
if (v < u) {
while (ans + v - 1 < t) ans += 2 * m - 2;
ans += u - 1;
} else {
ans = m - 1;
while (ans + m - v < t) ans += 2 * m - 2;
ans += m - u;
}
printf("%d\n", ans);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[2000010];
for (int i = 0; i < n; i++) {
a[i] = i + 1;
}
for (int i = 0; i < n - 1; i++) {
int j;
for (j = i; j < i + n; j += i + 2) {
}
j -= i + 2;
for (; j >= i; j -= i + 2) {
if (j + i + 2 >= i + n) {
a[i + n] = a[j];
} else {
a[j + i + 2] = a[j];
}
}
}
for (int i = 0; i < n; i++) {
cout << a[n - 1 + i] << " ";
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
template <typename T>
class segment_tree {
private:
vector<T> tree_structure;
int data_size;
int pow2;
void upd_node(const T& left_child, const T& right_child, T& parent) {
parent = left_child + right_child;
}
public:
void update(const int index) {
for (int i = index | pow2; i > 1;) {
T value1 = tree_structure[i & (-2)], value2 = tree_structure[i | 1];
i >>= 1;
upd_node(value1, value2, tree_structure[i]);
}
}
segment_tree(){};
segment_tree(vector<T>& input, T&& trash_value) {
data_size = input.size();
pow2 = 1;
for (; pow2 <= data_size;) pow2 <<= 1;
tree_structure.resize(pow2 << 1);
for (int i = 0; i < data_size; ++i) {
tree_structure[pow2 | i] = input[i];
}
for (int i = data_size; i < pow2; ++i) {
tree_structure[pow2 | i] = trash_value;
}
for (int i = pow2 - 1; i; --i) {
T value1 = tree_structure[i << 1], value2 = tree_structure[(i << 1) | 1];
upd_node(value1, value2, tree_structure[i]);
}
}
T& operator[](const int index) { return tree_structure[index + pow2]; }
int power() { return pow2; }
};
const long double pi = acos(-1.0);
class mdf {
long double x, y;
int ang;
long double current_length;
static long double *cosin, *sinus, *radians;
public:
static void init() {
for (int i = 0; i < 360; ++i) {
radians[i] = (i * pi / 180);
cosin[i] = (cos(radians[i]));
sinus[i] = (sin(radians[i]));
}
}
mdf(long double x_ = 0.0, long double y_ = 0.0, int a_ = 0) {
x = x_, y = y_, ang = a_;
current_length = sqrt(x * x + y * y);
}
mdf enlarge(const long double len) {
x *= (current_length + len) / current_length;
y *= (current_length + len) / current_length;
current_length += len;
return *this;
}
mdf rotate(int degrees) {
long double angle = atan2(y, x) - radians[degrees];
x = current_length * cos(angle);
y = current_length * sin(angle);
ang += 360 - degrees;
ang %= 360;
return *this;
}
mdf operator+(const mdf& other) const {
return mdf(x + other.x * cosin[ang] - other.y * sinus[ang],
y + other.y * cosin[ang] + other.x * sinus[ang],
(ang + other.ang) % 360);
}
long double abscissa() { return x; }
long double ordinate() { return y; }
void print() const {
cout << double(x) << " " << double(y) << " " << ang << " "
<< double(current_length) << endl;
}
};
long double *mdf::cosin = new long double[360],
*mdf::sinus = new long double[360],
*mdf::radians = new long double[360];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y,
z;
cin >> n >> m;
mdf::init();
vector<mdf> helper;
const mdf one = mdf(1., 0., 0);
helper.assign(n, one);
segment_tree<mdf> rmq(helper, mdf(0, 0, 0));
int root = 1 - rmq.power();
for (i = 0; i < m; ++i) {
cin >> d >> x >> y;
--x;
if (d == 1) {
rmq[x].enlarge(y);
} else {
rmq[x].rotate(y);
}
rmq.update(x);
cout << (double)rmq[root].abscissa() << " " << (double)rmq[root].ordinate()
<< "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
bool isprime(long long n) {
if (n % 2 == 0) {
return false;
}
for (auto i = 3; i * i <= n; i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
long long digitsum(long long n) {
long long sum = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
long long Cnk(long long n, long long k) {
long long B[n + 1][n + 1];
for (long long i = 0; i <= n; ++i) {
B[i][0] = 1;
B[i][i] = 1;
for (long long j = 1; j < i; ++j) B[i][j] = B[i - 1][j - 1] + B[i - 1][j];
}
return B[n][k];
}
int pow(int a, int b) {
int r = 1;
for (auto i = 0; i < b; i++) r *= a;
return r;
}
struct cnt {
int i = 0;
};
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int q, n, m, x, y, sum, c1, c2, c;
string s;
cin >> q;
while (q--) {
cin >> n >> m >> x >> y;
c1 = 0, c2 = 0, sum = 0;
for (auto i = 0; i < n; i++) {
cin >> s;
c = 0;
for (auto j = 0; j < m; j++) {
if (s[j] == '.') c++;
if (s[j] == '*' || j == m - 1) c2 += c / 2, c1 += c % 2, c = 0;
}
}
cout << min(c2 * y + c1 * x, 2 * c2 * x + c1 * x) << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const long long mod = 1000000007;
const int INF = INT_MAX;
char mp[510][510];
struct node {
int x, y, id;
node(int x, int y, int id) : x(x), y(y), id(id){};
node() {}
};
vector<node> vec;
int main() {
for (int i = 0; i <= 500; i++) {
for (int j = 0; j <= 500; j++) {
mp[i][j] = 'c';
}
}
int a, b;
int sum_size = 0, L_size = -1, pos = -1;
for (int i = 0; i < 3; i++) {
scanf("%d%d", &a, &b);
if (a > b) swap(a, b);
if (L_size < b) {
L_size = b;
pos = i;
}
vec.push_back(node(a, b, i));
sum_size += a * b;
}
if (sum_size != L_size * L_size) {
puts("-1");
return 0;
}
for (int i = 1; i <= vec[pos].x; i++) {
for (int j = 1; j <= vec[pos].y; j++) {
mp[i][j] = ('A' + pos);
}
}
int L = vec[pos].x, R = vec[pos].y;
vector<node>::iterator it = vec.begin();
for (int i = 0; i < 3; i++, it++) {
if (i == pos) {
vec.erase(it);
break;
}
}
bool isok = true;
if (vec[0].y == L_size) {
for (int i = 1 + L; i <= 1 + L + vec[0].x; i++) {
for (int j = 1; j <= vec[0].y; j++) {
mp[i][j] = ('A' + vec[0].id);
}
}
for (int i = 1 + L + vec[0].x; i <= 1 + L + vec[0].x + vec[1].x; i++) {
for (int j = 1; j <= vec[1].y; j++) {
mp[i][j] = ('A' + vec[1].id);
}
}
} else {
if (vec[0].x + vec[1].x == L_size && vec[0].y == vec[1].y) {
swap(vec[0].x, vec[0].y);
swap(vec[1].x, vec[1].y);
} else if (vec[0].x + vec[1].y == L_size && vec[0].y == vec[1].x) {
swap(vec[0].x, vec[0].y);
} else if (vec[1].x + vec[0].y == L_size && vec[1].y == vec[0].x) {
swap(vec[1].x, vec[1].y);
}
for (int i = 1 + L; i <= 1 + L + vec[0].x; i++) {
for (int j = 1; j <= vec[0].y; j++) {
mp[i][j] = ('A' + vec[0].id);
}
}
for (int i = 1 + L; i <= 1 + L + vec[1].x; i++) {
for (int j = 1 + vec[0].y; j <= 1 + vec[0].y + vec[1].y; j++) {
mp[i][j] = ('A' + vec[1].id);
}
}
for (int i = 1; i <= L_size; i++) {
for (int j = 1; j <= L_size; j++) {
if (mp[i][j] == 'c') isok = false;
}
}
}
if (isok == false) {
puts("-1");
return 0;
}
printf("%d\n", L_size);
for (int i = 1; i <= L_size; i++) {
for (int j = 1; j <= L_size; j++) {
printf("%c", mp[i][j]);
}
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 222;
int n, m, k;
int sx[N], sy[N];
pair<int, int> f[N];
string ans;
int mx = INT_MIN;
int mn = INT_MAX;
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < k; ++i) {
scanf("%d %d", sx + i, sy + i);
mx = max(mx, sy[i]);
mn = min(mn, sx[i]);
}
for (int i = 0; i < k; ++i) {
scanf("%d %d", &f[i].first, &f[i].second);
}
for (int i = mn; i < n; ++i) {
ans += 'D';
}
for (int i = mx; i > 1; --i) {
ans += 'L';
}
sort(f, f + k);
int x = n, y = 1;
vector<bool> used(k);
for (;;) {
double dis = 1e9;
int _x = -1, _y;
int ind = -1;
for (int i = 0; i < k; ++i) {
if (!used[i] && dis > hypot(abs(f[i].first - x), abs(f[i].second - y))) {
dis = hypot(abs(f[i].first - x), abs(f[i].second - y));
_x = f[i].first;
_y = f[i].second;
ind = i;
}
}
if (ind == -1) break;
used[ind] = true;
while (x < _x) {
x++;
ans += 'D';
}
while (y < _y) {
y++;
ans += 'R';
}
while (x > _x) {
x--;
ans += 'U';
}
while (y > _y) {
y--;
ans += 'L';
}
}
assert(n * m * 2 >= (int)ans.size());
printf("%d\n", (int)ans.size());
puts(ans.c_str());
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200011;
const int MOD = 1e9 + 7;
long long int powmod(long long int a, long long int b) {
if (b == 0) return 1;
long long int x = powmod(a, b / 2);
long long int y = (x * x) % MOD;
if (b % 2) return (a * y) % MOD;
return y % MOD;
}
int main() {
int t;
scanf("%d", &t);
map<long long int, long long int> mm;
map<long long int, long long int>::iterator it;
long long int x;
char c;
vector<int> p;
while (t--) {
long long int k = 0;
p.clear();
cin >> c;
if (c != '?') {
scanf("%lld", &x);
while (x) {
if (((x % 10) % 2) == 0)
p.push_back(0);
else
p.push_back(1);
x /= 10;
}
long long int y = 1;
for (int i = 0; i < (int)(p.size()); i++) {
k += y * p[i];
y *= 2;
}
if (c == '+')
mm[k]++;
else
mm[k]--;
} else {
string s;
cin >> s;
reverse((s).begin(), (s).end());
long long int y = 1;
for (int i = 0; i < (int)(s.size()); i++) {
k += y * (s[i] - '0');
y *= 2;
}
it = mm.find(k);
if (it == mm.end())
printf("0\n");
else
printf("%lld\n", it->second);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> x;
if (x >= (1 << n)) x = 0;
int cur = x;
int target = 1;
int mx = (1 << n);
vector<int> ans;
set<int> usd;
usd.insert(x);
usd.insert(0);
while (target < mx) {
if (usd.count(target ^ x)) {
++target;
continue;
}
int nxt = (cur ^ target);
ans.push_back(nxt);
usd.insert(target);
cur ^= nxt;
++target;
}
int n1 = ans.size();
cout << n1 << "\n";
for (auto zkw : ans) cout << zkw << " ";
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t;
int n;
vector<pair<int, int> > vec;
bool ask_lt(int a, int b) {
cout << "? " << a << " " << b << endl;
char c;
cin >> c;
return c == '<';
}
int main() {
cin >> t;
while (t--) {
cin >> n;
vec.clear();
for (int i = 1; i <= n; i++) {
if (ask_lt(i, n + i)) {
vec.push_back({n + i, i});
} else {
vec.push_back({i, n + i});
}
}
for (int left = 2 * n; left > n; left--) {
sort(vec.begin(), vec.end());
int worst = -1;
for (int i = ((vec[0].first == -1) ? 1 : 0); i < vec.size(); i++) {
if (worst == -1) {
worst = vec[i].second;
} else if (ask_lt(vec[i].second, worst)) {
worst = vec[i].second;
}
}
if (vec[0].first == -1) {
if (ask_lt(vec[0].second, worst)) {
worst = vec[0].second;
}
}
for (int i = 0; i < vec.size(); i++) {
if (vec[i].second == worst) {
vec[i].second = vec[i].first;
vec[i].first = -1;
break;
}
}
if (left == n + 1) {
break;
}
sort(vec.begin(), vec.end());
if (vec[0].second == -1) {
reverse(vec.begin(), vec.end());
vec.pop_back();
} else if (vec.size() > 1 && vec[1].first == -1) {
vec[1].first = vec[0].second;
if (ask_lt(vec[1].first, vec[1].second)) {
swap(vec[1].first, vec[1].second);
}
reverse(vec.begin(), vec.end());
vec.pop_back();
}
}
cout << "!" << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> pos[27];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
int x = (int)s[i] - (int)'a';
pos[x].push_back(i);
}
for (int i = 0, cnt = 0; i < 27 && cnt < k; i++) {
if (pos[i].size() > 0) {
for (int j = 0; j < pos[i].size() && cnt < k; j++) {
s[pos[i][j]] = '-';
cnt++;
}
}
}
for (int i = 0; i < s.size(); i++)
if (s[i] != '-') cout << s[i];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n, m, l, t;
scanf("%d %d %d", &n, &m, &k);
for (i = 1, l = 0, t = 0; i <= n; i++) {
scanf("%d", &j);
if (j == 1) l++;
if (j == 2) t++;
}
i = l - m;
j = t - k;
if (j > 0 && i < 0) j -= (-i);
if (i < 0) i = 0;
if (j < 0) j = 0;
printf("%d\n", i + j);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int MAXN = 11;
int c[MAXN], pre[MAXN], n, ans, mx;
long long a[MAXN], b[MAXN];
void dfs(int dep, int sum) {
if (dep > n) {
int cnt = 0;
for (int i = 1; i <= n; ++i)
if (pre[i] == 0) ++cnt;
if (cnt == 1) ++sum;
if (sum > mx) mx = sum;
return;
}
for (int i = 1; i <= n; ++i)
if (dep != i && b[i] % a[dep] == 0) {
pre[dep] = i;
b[i] /= a[dep];
dfs(dep + 1, sum + (c[dep] == 0 ? 1 : c[dep]));
b[i] *= a[dep];
}
pre[dep] = 0;
dfs(dep + 1, sum);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%I64d", &a[i]);
long long t = b[i] = a[i];
for (long long j = 2; j * j <= a[i]; ++j)
for (; t % j == 0; t /= j, ++c[i])
;
if (t > 1) ++c[i];
if (c[i] == 1) c[i] = 0;
ans += c[i];
}
dfs(1, 0);
printf("%d\n", ans + n + 1 - mx);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
;
int n, m, z;
cin >> n >> m >> z;
int cnt = 0;
for (int i = 0; i <= z; i += n) {
if (i % m == 0 && i != 0) {
cnt++;
}
}
cout << cnt;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s[1005];
int dis[1005][1005];
struct state {
int x, y, dis;
bool operator<(const state &now) const { return dis > now.dis; }
};
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
for (int i = 0; i < n; i++) cin >> s[i];
memset(dis, -1, sizeof dis);
priority_queue<state> pq;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int t = 0; t < 4; t++) {
int nx = i + dx[t], ny = j + dy[t];
if (nx < 0 || ny < 0 || nx >= n || ny >= m) continue;
if (s[i][j] == s[nx][ny]) {
dis[i][j] = 0;
pq.push(state{i, j, 0});
}
}
while (!pq.empty()) {
state now = pq.top();
pq.pop();
int x = now.x, y = now.y;
for (int t = 0; t < 4; t++) {
int nx = x + dx[t], ny = y + dy[t];
if (nx < 0 || ny < 0 || nx >= n || ny >= m) continue;
if (dis[nx][ny] != -1) continue;
dis[nx][ny] = dis[x][y] + (s[x][y] != s[nx][ny] ? 1 : 0);
pq.push(state{nx, ny, dis[nx][ny]});
}
}
while (q--) {
int x, y;
long long tim;
cin >> x >> y >> tim;
x--;
y--;
int c = s[x][y] - '0';
if (dis[x][y] == -1 || (long long)dis[x][y] > tim)
cout << c << '\n';
else
cout << (c ^ ((tim - dis[x][y]) & 1)) << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int aray[100002];
int main() {
int n, i, count = 0, num;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &aray[i]);
if (aray[i] == i) {
count++;
}
}
if (count == n) {
printf("%d", count);
return 0;
}
for (i = 0; i < n; i++) {
if (aray[i] != i && aray[aray[i]] == i) {
printf("%d", count + 2);
return 0;
}
}
printf("%d", count + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[200005];
map<long long, int> mp;
int main() {
int n;
cin >> n;
long double ans = 0, sum = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
ans += (i - 1) * a[i] - sum + mp[a[i] + 1] - mp[a[i] - 1];
mp[a[i]]++;
sum += a[i];
}
cout << fixed << setprecision(0) << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using ld = long double;
const int N = 51;
const lli MOD = 998244353;
int lol(int a, int b) {
if (a < b) {
return 0;
}
return a / b + lol(a / b, b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int l = 0, r = n;
while (l < r) {
int mid = (l + r) / 2;
if (lol(mid, k) + mid >= n) {
r = mid;
} else {
l = mid + 1;
}
}
cout << l << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int i = 0; i < q; i++) {
long long a, b, c;
cin >> a >> b >> c;
cout << ((a + b + c) / 2) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
int i, count = 0, c4 = 0, c7 = 0;
cin >> s1 >> s2;
for (i = 0; i < s1.size(); i++) {
if (s1[i] == '4' && s2[i] == '7')
c4++;
else if (s1[i] == '7' && s2[i] == '4')
c7++;
}
count = max(c4, c7);
cout << count;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int64_t mod = (long long)1e9 + 7;
const int64_t primm = 998244353;
long long n, x, y, a[100005], d = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(10);
cin >> n >> x >> y;
for (long long i = 0; i < (long long)n; i++) cin >> a[i];
for (long long i = 0; i < (long long)n; i++) {
d = 0;
for (long long j = (long long)max((long long)0, i - x);
j < (long long)min(n, i + y + 1); j++) {
if (j != i && a[j] <= a[i]) {
d++;
break;
}
}
if (d == 0) {
cout << i + 1 << endl;
return 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int N = 1e5 + 5;
int n, m, i, x, y, d[N], h[N], ans[N * 3], xb;
struct edge {
int to, next;
} e[N * 6];
int ecnt = 1;
inline void addedge(int x, int y) {
e[++ecnt] = (edge){y, h[x]};
h[x] = ecnt;
e[++ecnt] = (edge){x, h[y]};
h[y] = ecnt;
}
bool vi[N * 3];
void dfs(int x) {
for (int& i = h[x]; i;) {
int y = e[i].to, t = i;
i = e[i].next;
if (vi[t >> 1]) continue;
vi[t >> 1] = 1;
dfs(y);
ans[++xb] = t;
}
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= m; ++i)
scanf("%d%d", &x, &y), d[x] ^= 1, d[y] ^= 1, addedge(x, y);
x = 0;
for (i = 1; i <= n; ++i)
if (d[i]) x ? addedge(x, i), ++m, x = 0 : x = i;
if (m & 1) addedge(1, 1), ++m;
dfs(1);
printf("%d\n", m);
for (i = 1; i <= m; ++i)
printf("%d %d\n", e[ans[i] ^ (i & 1)].to, e[ans[i] ^ (i & 1) ^ 1].to);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, ans;
long long a[200005], nxt[200005];
int main() {
scanf("%I64d%I64d", &n, &k);
for (long long(i) = (1); (i) <= (n); (i)++) scanf("%I64d", &a[i]);
nxt[n] = n + 1;
for (long long(i) = (n - 1); (i) >= (1); (i)--)
if (a[i + 1] != 1)
nxt[i] = i + 1;
else
nxt[i] = nxt[i + 1];
for (long long(i) = (1); (i) <= (n); (i)++) {
long long now = i, pro = 1ll, sum = 0ll, prev = i - 1;
while (now != n + 1 && pro <= (1000000000000000000LL / a[now])) {
pro *= a[now];
sum = sum + a[now] + now - prev - 1;
if (pro % k == 0 && pro / k - sum <= nxt[now] - now - 1 &&
pro / k - sum >= 0) {
ans++;
}
prev = now;
now = nxt[now];
}
}
printf("%I64d", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a1[n], a2[n];
string s;
cin >> s;
for (int i = 0; i < n; i++) {
a1[i] = s[i] - '0';
a2[i] = s[i + n] - '0';
}
sort(a1, a1 + n);
sort(a2, a2 + n);
if (a1[n - 1] > a2[n - 1]) {
for (int i = 0; i < n; i++) {
if (a1[i] <= a2[i]) {
cout << "NO";
return 0;
}
}
} else if (a1[n - 1] == a2[n - 1]) {
cout << "NO";
return 0;
} else {
for (int i = 0; i < n; i++) {
if (a1[i] >= a2[i]) {
cout << "NO";
return 0;
}
}
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int i, long long int j) {
if (i % j == 0) return j;
return gcd(j, i % j);
}
int main() {
long long int n, a, b, p, q;
cin >> n >> a >> b >> p >> q;
long long int h = gcd(a, b);
h = a / h;
h = h * b;
long long int e = n / a;
long long int w = n / b;
long long int r = n / h;
if (p > q) {
long long int ans = e * p + (w - r) * q;
cout << ans << endl;
} else {
long long int ans = w * q + (e - r) * p;
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double a[5005], s[5005];
int main() {
int n, k;
double maxj, ans = 0;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lf", &a[i]);
s[i] = s[i - 1] + a[i];
}
for (int i = k; i <= n; i++) {
maxj = 0;
for (int j = i; j <= n; j++) maxj = max(maxj, s[j] - s[j - i]);
ans = max(ans, maxj / i);
}
printf("%.9lf\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100010;
int n, m, x, y;
int k;
bool top[MAX], bottom[MAX], lft[MAX], rgt[MAX];
const int dx[] = {1, 1, -1, -1};
const int dy[] = {1, -1, 1, -1};
int getCnt() {
bool res = x % 2 == y % 2;
int ret = 0;
for (int i = 0; i < (int)(m); i++) ret += (0 == i % 2) == res;
for (int i = 0; i < (int)(m); i++) ret += ((n - 1) % 2 == i % 2) == res;
for (int i = (int)(1); i < (int)(n - 1); i++) ret += (0 == i % 2) == res;
for (int i = (int)(1); i < (int)(n - 1); i++)
ret += ((m - 1) % 2 == i % 2) == res;
return ret;
}
long long solve() {
int cnt = getCnt();
long long ret = 0;
for (int _ = 0; _ < (int)(3000000); _++) {
if (x == 0) {
if (!top[y]) --cnt;
top[y] = true;
} else if (x == n - 1) {
if (!bottom[y]) --cnt;
bottom[y] = true;
} else if (y == 0) {
if (!lft[x]) --cnt;
lft[x] = true;
} else {
if (!rgt[x]) --cnt;
rgt[x] = true;
}
if (cnt == 0) break;
if (k == 0) {
if (x == n - 1 && y == m - 1)
k = 3;
else if (x == n - 1)
k = 2;
else if (y == m - 1)
k = 1;
} else if (k == 1) {
if (x == n - 1 && y == 0)
k = 2;
else if (x == n - 1)
k = 3;
else if (y == 0)
k = 0;
} else if (k == 2) {
if (x == 0 && y == m - 1)
k = 1;
else if (x == 0)
k = 0;
else if (y == m - 1)
k = 3;
} else {
if (x == 0 && y == 0)
k = 0;
else if (x == 0)
k = 1;
else if (y == 0)
k = 2;
}
int d;
if (k == 0)
d = min(n - 1 - x, m - 1 - y);
else if (k == 1)
d = min(n - 1 - x, y);
else if (k == 2)
d = min(x, m - 1 - y);
else
d = min(x, y);
x += d * dx[k];
y += d * dy[k];
ret += d;
}
if (cnt) return -1;
return ret;
}
int main() {
cin >> n >> m >> x >> y;
string dir;
cin >> dir;
if (dir[0] == 'U') k = 1;
k <<= 1;
if (dir[1] == 'L') k |= 1;
--x, --y;
long long ret = solve();
if (ret != -1) ++ret;
cout << ret << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[200100], b[200100], max = 1, num = -1;
memset(b, 0, sizeof(b));
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
b[a[i]]++;
if (b[a[i]] >= max) {
max = b[a[i]];
num = a[i];
}
}
printf("%d\n", (n - max));
for (int k = 1; k < n; k++) {
if (a[k] != num && a[k - 1] == num) {
if (a[k] > a[k - 1]) {
printf("2 %d %d\n", k + 1, k);
} else if (a[k] < a[k - 1]) {
printf("1 %d %d\n", k + 1, k);
}
a[k] = a[k - 1];
}
}
for (int x = n - 1; x >= 0; x--) {
if (a[x] != num && a[x + 1] == num) {
if (a[x] > a[x + 1]) {
printf("2 %d %d\n", x + 1, x + 2);
} else if (a[x] < a[x + 1]) {
printf("1 %d %d\n", x + 1, x + 2);
}
a[x] = a[x + 1];
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, con = 2;
cin >> n;
set<pair<string, int>> nod;
for (int i = 0; i < n; i++) {
string a, b, c;
cin >> a >> b >> c;
for (int j = 0; j < a.size(); j++) {
a[j] = tolower(a[j]);
}
for (int j = 0; j < c.size(); j++) {
c[j] = tolower(c[j]);
}
if (i != 0) {
auto it = nod.lower_bound({c, 0});
if (it != nod.end()) {
int nu = it->second;
if (nu + 1 > con) {
con++;
nod.insert({a, con});
} else {
nod.insert({a, nu + 1});
}
}
} else {
nod.insert(make_pair(a, 2));
nod.insert(make_pair(c, 1));
}
}
cout << con;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[100002];
int n;
int main() {
scanf("%d", &n);
int mx = 0, idx;
for (int i = 0; i < (int)n; i++) {
scanf("%d", &arr[i]);
if (arr[i] > mx) {
mx = arr[i];
idx = i;
}
}
if (mx > 1)
arr[idx] = 1;
else
arr[idx] = 2;
sort(arr, arr + n);
for (int i = 0; i < (int)n; i++) printf("%d ", arr[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
int n, a[MAXN], u[MAXN], v[MAXN];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
vector<int> c[MAXN];
long long f[MAXN];
int x[MAXN], fa[MAXN], siz[MAXN];
int getfa(int u) { return u == fa[u] ? u : fa[u] = getfa(fa[u]); }
inline void merge(int j, int u, int v) {
u = getfa(u);
v = getfa(v);
if (u == v) return;
f[j] += (long long)siz[u] * siz[v];
fa[u] = v;
siz[v] += siz[u];
}
int mu[MAXN], prm[MAXN], pn;
bool notp[MAXN];
void table(int n) {
notp[0] = notp[1] = 1;
mu[1] = 1;
for (int i = 2; i <= n; i++) {
if (!notp[i]) {
prm[++pn] = i;
mu[i] = -1;
}
for (int j = 1; j <= pn && prm[j] * i <= n; j++) {
notp[prm[j] * i] = 1;
if (i % prm[j])
mu[prm[j] * i] = -mu[i];
else {
mu[prm[j] * i] = 0;
break;
}
}
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
for (int j = 1; j * j <= a[i]; j++)
if (!(a[i] % j)) {
f[j]++;
if (j * j != a[i]) ++f[a[i] / j];
}
}
for (int i = 1; i < n; i++) {
cin >> u[i] >> v[i];
int t = gcd(a[u[i]], a[v[i]]);
for (int j = 1; j * j <= t; j++)
if (!(t % j)) {
c[j].push_back(i);
if (j * j != t) c[t / j].push_back(i);
}
}
int m = 200000;
for (int i = 1; i <= m; i++) {
for (int j = 0; j < c[i].size(); j++) {
fa[u[c[i][j]]] = u[c[i][j]];
siz[u[c[i][j]]] = 1;
fa[v[c[i][j]]] = v[c[i][j]];
siz[v[c[i][j]]] = 1;
}
for (int j = 0; j < c[i].size(); j++) merge(i, u[c[i][j]], v[c[i][j]]);
}
table(m);
for (int k = 1; k <= m; k++) {
long long ans = 0;
for (int i = 1; i * k <= m; i++) ans += mu[i] * f[i * k];
if (ans) cout << k << ' ' << ans << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, m, z;
cin >> n >> m >> z;
int result = 0;
for (int i = 1; i <= z; i++) {
if ((i % n) == 0 && (i % m) == 0) {
result++;
}
}
cout << result;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:64000000")
using namespace std;
int a[16];
int b[4][4];
int n;
bool check() {
int s = 0, x = 0, y = 0;
for (int(i) = 0; (i) < (n); (i)++) {
s += b[0][i];
x += b[i][i];
y += b[i][n - 1 - i];
}
if (s != x || s != y) {
return false;
}
for (int(i) = 0; (i) < (n); (i)++) {
x = y = 0;
for (int(j) = 0; (j) < (n); (j)++) {
x += b[i][j];
y += b[j][i];
}
if (s != x || s != y) {
return false;
}
}
return true;
}
void print() {
int s = 0;
for (int(i) = 0; (i) < (n); (i)++) s += b[0][i];
printf("%d\n", s);
for (int(i) = 0; (i) < (n); (i)++) {
for (int(j) = 0; (j) < (n); (j)++) printf("%d ", b[i][j]);
printf("\n");
}
}
int main() {
scanf("%d", &n);
for (int(i) = 0; (i) < (n * n); (i)++) scanf("%d", &a[i]);
sort(a, a + n * n);
do {
for (int(i) = 0; (i) < (n * n); (i)++) b[i / n][i % n] = a[i];
if (check()) {
print();
break;
}
} while (next_permutation(a, a + n * n));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100002;
int n;
int query(string &a) {
cout << a << endl;
int x;
cin >> x;
if (!x) exit(0);
return x;
}
int main() {
string a(300, 'a'), b(300, 'b'), ans;
int numA = 300 - query(a);
int numB = 300 - query(b);
int n = numA + numB, x = numA;
b = b.substr(0, n);
for (int i = 0; i <= n - 2; ++i) {
b[i] = 'a';
int y = query(b);
b[i] = 'b';
if (y < x)
ans += 'a', --numA;
else
ans += 'b', --numB;
}
if (numA) ans += 'a', --numA;
if (numB) ans += 'b', --numB;
assert(!numA and !numB);
query(ans);
assert(false);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
int main()
{
IOS;
int q;
cin >> q;
int id = 0;
map<int, queue<int> > m;
set<int> have;
while(q--)
{
int type;
cin >> type;
if(type == 1)
{
id++;
have.insert(id);
int val;
cin >> val;
m[val].push(id);
}
else if(type == 2)
{
int val = *have.begin();
cout << val << " ";
have.erase(val);
}
else
{
int val = -1;
while(val == -1)
{
auto it = m.rbegin();
if(have.find(it->second.front()) == have.end())
{
it->second.pop();
if(it->second.size() == 0)
m.erase(it->first);
}
else
{
val = it->second.front();
it->second.pop();
if(it->second.size() == 0)
m.erase(it->first);
have.erase(val);
}
}
cout << val << " ";
}
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int a[128];
int main() {
int n, m, x;
scanf("%d %d %d", &n, &m, &x);
map<int, int> aa;
while (n--) {
for (int i = 0; i < m; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if ((a[i] < a[j]) == x) {
int t = a[i];
a[i] = a[j];
a[j] = t;
if (x == 0)
aa[i * 1000 + j] = 1;
else
aa[j * 1000 + i] = 1;
}
}
}
}
printf("%d\n", aa.size());
for (map<int, int>::iterator it = aa.begin(); it != aa.end(); it++) {
printf("%d %d\n", it->first / 1000 + 1, it->first % 1000 + 1);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 2e4 + 42;
int n, k, inp[nmax];
int dp[nmax], help[nmax];
int MX[nmax];
int pointer = 0;
pair<int, int> lines[nmax];
void init() { pointer = 0; }
pair<int, int> meet(pair<int, int> a, pair<int, int> b) {
pair<int, int> ret = {a.second - b.second, b.first - a.first};
if (ret.second < 0) ret.first = -ret.first, ret.second = -ret.second;
return ret;
}
bool my_remove(pair<int, int> prv, pair<int, int> to_remove,
pair<int, int> cur) {
if (prv.first > cur.first) swap(prv, cur);
pair<int, int> meet_1 = meet(prv, to_remove);
pair<int, int> meet_2 = meet(prv, cur);
return 1LL * meet_1.first * meet_2.second <=
1LL * meet_1.second * meet_2.first;
}
void add_line(pair<int, int> cur) {
while (pointer >= 1 && lines[pointer].first >= cur.first &&
lines[pointer].second >= cur.second)
pointer--;
if (pointer >= 1 && lines[pointer].first <= cur.first &&
lines[pointer].second <= cur.second)
return;
while (pointer >= 2 && my_remove(lines[pointer - 1], lines[pointer], cur))
pointer--;
pointer++;
lines[pointer] = cur;
}
int NOW = 1e9;
int eval(int i, int x) {
int ret = 1LL * x * lines[i].first + lines[i].second;
NOW = min(NOW, ret);
return ret;
}
int solve_left(int x) {
eval(1, x);
eval(pointer, x);
int ok = 1, not_ok = pointer;
while (not_ok - ok > 1) {
int av = (ok + not_ok) / 2;
if (eval(av, x) > eval(av + 1, x))
ok = av;
else
not_ok = av;
}
eval(ok, x);
eval(not_ok, x);
}
int solve_right(int x) {
eval(1, x);
eval(pointer, x);
int ok = pointer, not_ok = 1;
while (ok - not_ok > 1) {
int av = (ok + not_ok) / 2;
if (eval(av, x) < eval(av + 1, x))
ok = av;
else
not_ok = av;
}
eval(ok, x);
eval(not_ok, x);
}
int query(int x) {
NOW = 1e9;
if (pointer == 0) return NOW;
solve_left(x);
solve_right(x);
return NOW;
}
void dc(int l, int r) {
if (l == r) {
help[l] = min(help[l], dp[l - 1] + inp[l]);
return;
}
int av = (l + r) / 2;
dc(l, av);
dc(av + 1, r);
MX[av] = inp[av];
for (int i = av - 1; i >= l; i--) MX[i] = max(MX[i + 1], inp[i]);
MX[av + 1] = inp[av + 1];
for (int i = av + 2; i <= r; i++) MX[i] = max(MX[i - 1], inp[i]);
init();
int j = l;
for (int i = r; i >= av + 1; i--) {
while (j <= av && MX[j] >= MX[i]) {
add_line({MX[j], dp[j - 1] + MX[j] * (-j + 1)});
j++;
}
help[i] = min(help[i], query(i));
}
init();
j = av;
for (int i = av + 1; i <= r; i++) {
while (j >= l && MX[j] <= MX[i]) {
add_line({-j, dp[j - 1]});
j--;
}
help[i] = min(help[i], query(MX[i]) + (i + 1) * MX[i]);
}
}
void push(int groups) {
for (int i = 0; i <= n; i++) help[i] = 1e9;
dc(1, n);
for (int i = 0; i <= n; i++) dp[i] = help[i];
}
int main() {
scanf("%i%i", &n, &k);
for (int i = 1; i <= n; i++) scanf("%i", &inp[i]);
for (int i = 1; i <= n; i++) dp[i] = 1e9;
for (int i = 1; i <= k; i++) push(i);
printf("%i\n", dp[n]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
pair<double, double> points[55];
set<pair<double, double>> st;
vector<pair<double, double>> lines;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> points[i].first >> points[i].second;
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (i == j) {
continue;
}
if (points[i].first == points[j].first) {
st.insert({100000, points[i].first});
continue;
}
double m = (points[i].second - points[j].second) /
(points[i].first - points[j].first);
double z = points[i].second - points[i].first * m;
st.insert({m, z});
}
}
for (auto x : st) {
lines.push_back(x);
}
int numLines = lines.size();
int res = 0;
for (int i = 0; i < numLines; ++i) {
for (int j = i + 1; j < numLines; ++j) {
if (lines[i].first != lines[j].first) {
res++;
}
}
}
cout << res << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string in;
int n;
int matrix[101][101];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) scanf("%d", &matrix[i][j]);
for (int i = 0; i < n; ++i) {
int number = 0;
for (int j = 0; j < n; ++j) {
if (matrix[i][j] > 0) number |= matrix[i][j];
}
printf("%d ", number);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
long long binpow(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long binpowmod(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long mod_inverse(long long n, long long p) {
return binpowmod(n, p - 2, p);
}
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
bool comp_pairs_by_s(pair<long long, long long> &x,
pair<long long, long long> &y) {
return x.second < y.second;
}
bool isPowerOfTwo(long long x) { return x && (!(x & (x - 1))); }
class cmp {
public:
bool operator()(pair<int, int> A, pair<int, int> B) {
if (abs(A.first - A.second) == abs(B.first - B.second))
return A.first > B.first;
return abs(A.first - A.second) < abs(B.first - B.second);
}
};
void swap(long long &x, long long &y) {
int temp = x;
x = y;
y = temp;
}
unsigned int onesComplement(unsigned int n) {
int number_of_bits = floor(log2(n)) + 1;
return ((1 << number_of_bits) - 1) ^ n;
}
bool comp(pair<long long, long long> x, pair<long long, long long> y) {
return x.second < y.second;
}
bool comp1(pair<long long, long long> x, pair<long long, long long> y) {
return x.second < y.second;
}
void solve() {
int n;
cin >> n;
string ss;
cin >> ss;
vector<int> ans(n + 1);
vector<set<int>> s(2);
for (int i = 0; i < n; ++i)
if (ss[i] == '1')
s[1].insert(i + 1);
else
s[0].insert(i + 1);
int i = (ss[0] - '0') ^ 1;
int prev = INT_MIN;
int cnt = 0;
while (!s[0].empty() || !s[1].empty()) {
auto cur = s[i ^ 1].upper_bound(prev);
if (cur == s[i ^ 1].end()) {
cnt++;
prev = min(*(s[0].begin()), *(s[1].begin()));
if (prev == *(s[0].begin())) {
ans[prev] = cnt + 1;
s[0].erase(prev);
i = 0;
} else {
ans[prev] = cnt + 1;
s[1].erase(prev);
i = 1;
}
} else {
ans[*cur] = cnt + 1;
i ^= 1;
prev = *cur;
s[i].erase(cur);
}
}
cout << cnt + 1 << '\n';
for (int i = 1; i <= n; ++i) cout << ans[i] << ' ';
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void PrintMap(map<int, int> mp) {
for (auto a : mp) {
cout << a.first << "->" << a.second << endl;
}
}
long long int modular(int base, unsigned int exp, unsigned int mod) {
long long int x = 1;
long long int power = base % mod;
for (int i = 0; i < sizeof(int) * 8; i++) {
int least_sig_bit = 0x00000001 & (exp >> i);
if (least_sig_bit) x = (x * power) % mod;
power = (power * power) % mod;
}
return x;
}
int subset(vector<int> arr, int l, int r, int sum = 0, int res = 0) {
if (l > r) {
if (sum == r - l + 1) {
cout << "REs" << res << endl;
res++;
}
return res;
}
return subset(arr, l + 1, r, sum + arr[l], res);
return subset(arr, l + 1, r, sum, res);
}
bool isPerfect(unsigned long long int N) {
if ((sqrt(N) - floor(sqrt(N))) != 0) return false;
return true;
}
int merge(int arr[], int temp[], int left, int mid, int right) {
int inv_count = 0;
int i = left;
int j = mid;
int k = left;
while ((i <= mid - 1) && (j <= right)) {
if (arr[i] <= arr[j])
temp[k++] = arr[i++];
else {
temp[k++] = arr[j++];
inv_count = inv_count + (mid - i);
}
}
while (i <= mid - 1) temp[k++] = arr[i++];
while (j <= right) temp[k++] = arr[j++];
for (i = left; i <= right; i++) arr[i] = temp[i];
return inv_count;
}
int _mergeSort(int arr[], int temp[], int left, int right) {
int mid, inv_count = 0;
if (right > left) {
mid = (right + left) / 2;
inv_count = _mergeSort(arr, temp, left, mid);
inv_count += _mergeSort(arr, temp, mid + 1, right);
inv_count += merge(arr, temp, left, mid + 1, right);
}
return inv_count;
}
int countSwaps(int arr[], int n) {
int temp[n];
return _mergeSort(arr, temp, 0, n - 1);
}
bool arraySortedOrNot(vector<int> arr, int n) {
if (n == 0 || n == 1) return true;
for (int i = 1; i < n; i++) {
if (arr[i - 1] > arr[i]) return false;
}
return true;
}
bool isSubsequemce(string s1, string s2, int m, int n) {
if (m == 0) return true;
if (n == 0) return false;
if (s1[m - 1] == s2[n - 1]) {
return isSubsequemce(s1, s2, m - 1, n - 1);
}
return isSubsequemce(s1, s2, m, n - 1);
}
int search(int money, vector<int> &arr) {
for (int i = 0; i < arr.size(); i++) {
if (arr[i] >= money) {
return i;
}
}
return arr.size() - 1;
}
int binary(long long int coins, vector<long long int> prices) {
long long int start = 0;
long long int end = prices.size() - 1;
long long int ans_index = -1;
while (start <= end) {
int mid = (start + end) / 2;
if (prices[mid] > coins) {
end = mid - 1;
} else {
ans_index = mid;
start = mid + 1;
}
}
return (ans_index);
}
vector<int> prefix_sum(vector<int> prices) {
vector<int> prefix(prices[prices.size() - 1] + 1, prices[prices.size() - 1]);
int start = 0;
int last_value = 0;
for (int i = 0; i < prices.size(); i++) {
for (int j = start; j < prices[i]; j++) {
prefix[j] = last_value;
}
prefix[prices[i]] = last_value + 1;
start = prices[i] + 1;
last_value += 1;
}
return prefix;
}
bool compareSize(string s1, string s2) { return (s1.size() < s2.size()); }
bool isSubstr(string s1, string s2) {
int M = s1.length();
int N = s2.length();
for (int i = 0; i <= N - M; i++) {
int j;
for (j = 0; j < M; j++)
if (s2[i + j] != s1[j]) break;
if (j == M) return true;
}
return false;
}
int main() {
long long int testcase;
cin >> testcase;
while (testcase--) {
long long int n, k;
cin >> n >> k;
vector<long long int> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr.begin(), arr.end(), greater<long long int>());
if (k == 0 || n == 1) {
cout << (arr[0] - arr[n - 1]) << endl;
continue;
}
long long int max_diff = arr[0];
for (long long int i = 1; i < min(k + 1, n); i++) {
max_diff += arr[i];
}
cout << max_diff << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt;
int a[33][33];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int s = 0, u = 0;
for (int k = 0; k < n; k++) {
s += a[i][k];
u += a[k][j];
}
if (u > s) cnt++;
}
}
cout << cnt << " ";
return 0;
}
| 0 |
// Author : shreyas
// McMurdo Station, Antartica
// Pengiun Intelligence Agency
// Date :
#include <bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL);
#define time cerr<<"Time taken : " <<(float)clock()/CLOCKS_PER_SEC <<" secs"<<"\n" ;
#define F first
#define S second
#define pb push_back
typedef long long int ll ;
const ll INF = (ll)1e18 ;
const ll MOD = (ll)1e9 + 7 ;
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ','); cerr.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...);
}
#else
#define trace(...)
#endif
ll GCD (ll a , ll b) {
if (b == 0) {
return a ;
}
return GCD(b , a % b) ;
}
ll LCM(ll a , ll b) {
return (a * b) / GCD(a , b) ;
}
vector<bool>sieveOfErato(ll n ) {
vector<bool>isPrime(n + 1 , true ) ;
isPrime[1] = false ;
isPrime[0] = false ;
for (ll i = 2 ; i * i <= n; i++) {
for (ll j = 2 * i ; j <= n; j += i) {
isPrime[j] = false;
}
}
return isPrime ;
}
/*-------------------------------------------------------------------------------------------------------------*/
void solve() {
int n ;
cin >> n;
int a[n] ;
for (int i = 0 ; i < n ; i++)
cin >> a[i] ;
bool ok = 0 ;
for (int i = 1; i < n ; i++) {
if (a[i] & a[i - 1] != a[i - 1]) {
ok = 1;
break ;
}
}
if (ok) {
for (int i = 0 ; i < n ; i++)
cout << 0 << " " ;
}
else {
vector<int>ans ;
ans.pb(0) ;
for (int i = 1 ; i < n; i++) {
int r = (a[i - 1] ^ a[i]) ;
r = r & a[i - 1] ;
ans.pb(r) ;
a[i] = a[i] ^ r ;
}
for (auto j : ans) {
cout << j << " " ;
}
}
cout << "\n" ;
}
int32_t main() {
fast ; time;
#ifndef ONLINE_JUDGE
freopen("input.txt" , "r" , stdin) ;
freopen("output.txt" , "w" , stdout) ;
#endif
int t = 1;
cin >> t;
while (t--) {
solve() ;
}
return 0 ;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k;
int main() {
cin >> n;
k = (n + 1) / 2;
cout << (k) * (n - k) << endl;
for (i = 1; i <= k; i++)
for (j = k + 1; j <= n; j++) cout << i << " " << j << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int v1, v2, c;
double ans;
} e[300100];
int v[300100];
bool comp(const Edge a, const Edge b) { return a.ans > b.ans; }
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d", v + i);
}
int a, b, c;
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &a, &b, &c);
e[i].v1 = v[a];
e[i].v2 = v[b];
e[i].c = c;
e[i].ans = (double)1.0 * (v[a] + v[b]) / c;
}
sort(e + 1, e + 1 + m, comp);
double ans = 0.0;
if (m > 0) ans = max(ans, e[1].ans);
printf("%.15f\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct ST {
int l, r;
ST *ch[2];
long long lz;
int ex[2], ans, h[2];
long long s[2];
} p[300005 << 1], *root;
int x[300005];
int stcnt = 0;
int n;
int l(ST *a) { return a->r - a->l + 1; }
void upd(ST *a) {
a->ans = max(a->ch[0]->ans, a->ch[1]->ans);
for (int i = 0; i < 2; i++)
a->ex[i] = a->ch[i]->ex[i], a->s[i] = a->ch[i]->s[i],
a->h[i] = a->ch[i]->h[i];
if (a->ch[0]->s[1] < a->ch[1]->s[0]) {
if (a->ex[1] == l(a->ch[1])) a->ex[1] += a->ch[0]->ex[1];
int ls = a->ch[0]->r - a->ch[0]->ex[1] + 1,
rs = a->ch[1]->l + a->ch[1]->h[0] - 1;
if (ls == a->l) a->h[0] = rs - ls + 1;
if (rs == a->r) a->h[1] = rs - ls + 1;
a->ans = max(a->ans, rs - ls + 1);
}
if (a->ch[0]->s[1] > a->ch[1]->s[0]) {
if (a->ex[0] == l(a->ch[0])) a->ex[0] += a->ch[1]->ex[0];
int ls = a->ch[0]->r - a->ch[0]->h[1] + 1,
rs = a->ch[1]->l + a->ch[1]->ex[0] - 1;
if (ls == a->l) a->h[0] = rs - ls + 1;
if (rs == a->r) a->h[1] = rs - ls + 1;
a->ans = max(a->ans, rs - ls + 1);
}
}
void bdtree(ST *a, int l, int r) {
a->l = l, a->r = r;
if (l == r) {
a->lz = 0, a->ex[0] = a->ex[1] = a->h[0] = a->h[1] = 1, a->ans = 1;
a->s[0] = a->s[1] = x[l];
return;
}
int mid = (l + r) >> 1;
a->ch[0] = &p[stcnt++], a->ch[1] = &p[stcnt++];
bdtree(a->ch[0], l, mid), bdtree(a->ch[1], mid + 1, r);
upd(a);
}
void actlz(ST *a, long long lz) { a->s[0] += lz, a->s[1] += lz, a->lz += lz; }
void pushdown(ST *a) {
if (a->lz) actlz(a->ch[0], a->lz), actlz(a->ch[1], a->lz), a->lz = 0;
}
void push(ST *a, int l, int r, int lz) {
if (a->l == l && a->r == r) {
actlz(a, lz);
return;
}
pushdown(a);
int mid = (a->l + a->r) >> 1;
if (r <= mid)
push(a->ch[0], l, r, lz);
else if (l > mid)
push(a->ch[1], l, r, lz);
else
push(a->ch[0], l, mid, lz), push(a->ch[1], mid + 1, r, lz);
upd(a);
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
root = &p[stcnt++];
bdtree(root, 1, n);
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
int l, r, d;
scanf("%d%d%d", &l, &r, &d);
push(root, l, r, d);
printf("%d\n", root->ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 7;
const long long INF = 1e9 + 7;
const long long mlog = 20;
const long long SQ = 400;
long long tav10[maxn];
long long inv10[maxn];
long long mod;
long long calc(vector<long long> &vecin,
vector<pair<long long, long long> > vecout) {
map<long long, long long> mp;
for (long long x : vecin) mp[x]++;
long long res = 0;
for (pair<long long, long long> p : vecout)
res += mp[(mod - p.second) * inv10[p.first] % mod];
return res;
}
long long n, m, k;
long long ans;
bool dead[maxn];
long long sz[maxn], h[maxn];
long long val_down[maxn], val_up[maxn];
vector<long long> G[maxn];
vector<pair<long long, long long> > G2[maxn];
long long dfs_sz(long long node, long long par) {
sz[node] = 1;
for (long long i : G[node])
if (!dead[i] && i != par) sz[node] += dfs_sz(i, node);
return sz[node];
}
long long centroid(long long node, long long par, long long n) {
for (long long v : G[node])
if (sz[v] * 2 > n && v != par && !dead[v]) return centroid(v, node, n);
return node;
}
void dfs_path(long long node, long long par, vector<long long> &vecin,
vector<pair<long long, long long> > &vecout) {
vecin.push_back(val_up[node]);
vecout.push_back({h[node] = h[par] + 1, val_down[node]});
for (pair<long long, long long> p : G2[node]) {
if (p.first != par && !dead[p.first]) {
val_up[p.first] = (tav10[h[node]] * p.second + val_up[node]) % mod;
val_down[p.first] = (val_down[node] * 10ll + p.second) % mod;
dfs_path(p.first, node, vecin, vecout);
}
}
}
void solve(long long node) {
dfs_sz(node, node);
long long root = centroid(node, node, sz[node]);
dead[root] = 1;
h[root] = 0;
vector<long long> vecin;
vector<pair<long long, long long> > vecout;
for (pair<long long, long long> p : G2[root]) {
if (!dead[p.first]) {
long long v = p.first;
long long w = p.second;
val_down[v] = val_up[v] = w;
vector<long long> vecin_tmp;
vector<pair<long long, long long> > vecout_tmp;
dfs_path(v, root, vecin_tmp, vecout_tmp);
ans -= calc(vecin_tmp, vecout_tmp);
for (long long tmp : vecin_tmp) vecin.push_back(tmp);
for (pair<long long, long long> tmp : vecout_tmp) vecout.push_back(tmp);
}
}
vecin.push_back(0);
vecout.push_back({0, 0});
ans += calc(vecin, vecout) - 1;
for (long long v : G[root])
if (!dead[v]) solve(v);
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(), cout.tie();
;
cin >> n >> mod;
tav10[0] = inv10[0] = 1;
for (long long i = 1; i < maxn; i++) tav10[i] = tav10[i - 1] * 10 % mod;
for (long long i = 1; i < 11; i++)
if ((i * mod + 1) % 10 == 0) inv10[1] = (i * mod + 1) / 10;
for (long long i = 2; i < maxn; i++) inv10[i] = inv10[1] * inv10[i - 1] % mod;
for (long long i = 1; i < n; i++) {
long long u, v, w;
cin >> u >> v >> w;
w %= mod;
G[++u].push_back(++v);
G[v].push_back(u);
G2[u].push_back({v, w});
G2[v].push_back({u, w});
}
solve(1);
cout << ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d, e, f, ans;
while (scanf("%d %d %d %d %d %d", &a, &b, &c, &d, &e, &f) == 6) {
ans = (a + b + c) * (a + b + c) - (a * a + c * c + e * e);
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int power = 0, min_power = INT_MAX, index;
for (int i = 0; i < k; i++) {
for (int j = 0; j < n; j += k) {
power += a[(i + j) % n];
}
if (min_power > power) {
min_power = power;
index = i + 1;
}
power = 0;
}
cout << index << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, K = 13, M = 4, MOD = 1e9 + 7;
long long dp[N][K][1 << M];
int main() {
int n, k, m;
cin >> n >> k >> m;
int all = (1 << m) - 1;
dp[n + 1][0][0] = 1;
for (int i = n; i > 0; i--) {
for (int j = 0; j <= k; j++) {
for (int mask = 0; mask < (1 << m); mask++) {
int nwmask = (mask << 1) & all;
dp[i][j][nwmask] += dp[i + 1][j][mask];
dp[i][j][nwmask] %= MOD;
if (j > 0) {
nwmask |= 1;
dp[i][j][nwmask] +=
(__builtin_popcount(mask) + 1) * dp[i + 1][j - 1][mask];
dp[i][j][nwmask] %= MOD;
}
}
}
}
long long ans = 0;
for (int mask = 0; mask < (1 << m); ++mask) ans += dp[1][k][mask];
cout << ans % MOD << endl;
}
| 10 |
#include <bits/stdc++.h>
const long long N = 4e5 + 7;
using namespace std;
long long n, m, k;
long long a[N], b[N];
long long fa[N], fb[N];
void getfa(long long f[], long long a[], long long n) {
long long res = 0;
for (long long i = 1; i <= n; i++) {
if (i == 1 && a[i] == 1)
res = 1;
else if (a[i] == 1 && a[i - 1] == 1)
res++;
else if (a[i] == 1 && a[i - 1] == 0)
res = 1;
else {
for (long long j = 1; j <= res; j++) f[j] += res - (j - 1);
res = 0;
}
}
for (long long j = 1; j <= res; j++) f[j] += res - (j - 1);
}
signed main() {
cin >> n >> m >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long j = 1; j <= m; j++) cin >> b[j];
getfa(fa, a, n);
getfa(fb, b, m);
long long res = 0;
for (long long i = 1; i <= min(k, n); i++) {
if (k % i == 0 && i <= n && k / i <= m) res += fa[i] * fb[k / i];
}
cout << res << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> tomb;
int main() {
int n;
cin >> n;
bool over = false;
long long hatar = UINT_MAX;
for (int x = 0; n > x && !over; ++x) {
string a;
cin >> a;
if (a == "for") {
int b;
cin >> b;
tomb.push_back(-b);
} else if (a == "add") {
tomb.push_back(1);
} else if (a == "end") {
long long szamolo = 0;
while (tomb.back() >= 0) {
szamolo += tomb.back();
tomb.pop_back();
}
long long ww = szamolo * tomb.back() * -1;
if (ww <= hatar) {
tomb.back() = ww;
} else {
over = true;
}
}
}
long long c = 0;
for (int x = 0; tomb.size() > x && !over; ++x) {
if (c + tomb[x] <= hatar) {
c += tomb[x];
} else {
over = true;
}
}
if (over) {
cout << "OVERFLOW!!!" << endl;
} else {
cout << c << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc;
cin >> tc;
while (tc--) {
int n, k;
cin >> n >> k;
int cur = 0;
for (int i = 0; i < (n); ++i) {
cout << (char)(cur + 97);
cur = (cur + 1) % k;
}
cout << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int OO = 0x3f3f3f3f, N = 1e2 + 5, mod = 1e9 + 7;
int ans, lst = OO, gt[26];
string s1, s2;
vector<int> idx[26];
int main() {
cin >> s1 >> s2;
for (int i = 0; i < s1.size(); ++i) idx[s1[i] - 'a'].push_back(i);
for (int i = 0; i < s2.size(); ++i) {
int ch = s2[i] - 'a';
if (!idx[ch].size()) exit(puts("-1"));
if (idx[ch].back() > lst && idx[ch][gt[ch]] <= lst)
gt[ch] =
lower_bound(idx[ch].begin(), idx[ch].end(), lst) - idx[ch].begin();
if (idx[ch].size() <= gt[ch] || idx[ch].back() <= lst) {
++ans, memset(gt, 0, sizeof gt);
gt[ch] = 1, lst = idx[ch][0];
} else
lst = (idx[ch][gt[ch]++]);
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, R, a, b, F, x;
int main() {
cin >> n;
R = 1;
a = 2;
m = n;
while (a * a <= n) {
if (n % a == 0) {
R *= a;
while (n % a == 0) n = n / a;
}
a++;
}
if (R != 1)
cout << R * n << endl;
else
cout << m << endl;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("omit-frame-pointer")
#pragma GCC optimize("unroll-loops")
const int MAXINT = 2147483640;
const long long MAXLL = 9223372036854775800LL;
const long long MAXN = 1000000;
const double pi = 3.1415926535897932384626433832795;
using namespace std;
int x1[300000];
long long n, m, k;
int check(int xx) {
if (xx * 2 >= n) return 1;
int val = 0;
long long sum1 = 0;
long long sum2 = 0;
long long l, r;
l = xx + 1 + xx * k;
r = n - xx - xx * k;
r = max(r, 0ll);
l = min(l, n);
for (int i = 1; i <= l; i++) sum1 += x1[i];
for (int i = n; i >= r; i--) sum2 += x1[i];
int l1 = xx + 1;
int r1 = n - xx;
int ff = 0;
while (1) {
if (ff == 1) ff = 2;
for (int i = 1; i <= k + val; i++) {
if (l == n or r == 0) return 1;
sum1 += x1[++l], sum2 += x1[--r];
}
if (ff == 0) ff = 1, val = 1;
sum1 -= m;
sum2 -= m;
if (sum1 < 0 or sum2 < 0) return 0;
if (l1 >= r1) return 1;
l1++;
r1--;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
srand(time(0));
int l, r;
cin >> n >> k >> m;
for (int i = 1; i <= n; i++) cin >> x1[i];
l = 0;
r = n + 1;
while (l < r) {
int c = (l + r) / 2;
if (check(c))
r = c;
else
l = c + 1;
}
if (check(l))
cout << l << endl;
else
cout << l + 1 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int tim[100010], ans[100010];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> tim[i];
for (int i = 1; i <= n; i++) {
ans[i] = ans[i - 1] + 20;
int pos = upper_bound(tim + 1, tim + 1 + i, tim[i] - 90) - tim - 1;
ans[i] = min(ans[i], ans[pos] + 50);
pos = upper_bound(tim + 1, tim + 1 + i, tim[i] - 1440) - tim - 1;
ans[i] = min(ans[i], ans[pos] + 120);
cout << ans[i] - ans[i - 1] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, q;
cin >> n >> q;
int JUMP = int(0.25 * sqrt(n)) + 1;
vector<int> p(n + 1), p_rev(n + 1), p_jump(n + 1);
auto compute_p_jump = [&](int u) -> int {
int steps = JUMP;
while (steps--) u = p[u];
return u;
};
for (int i = 1; i <= n; i++) {
cin >> p[i];
p_rev[p[i]] = i;
}
for (int i = 1; i <= n; i++) {
p_jump[i] = compute_p_jump(i);
}
while (q--) {
int op;
cin >> op;
if (op == 1) {
int x, y;
cin >> x >> y;
swap(p[x], p[y]);
swap(p_rev[p[x]], p_rev[p[y]]);
int px = compute_p_jump(x);
int py = compute_p_jump(y);
for (int i = 0; i < JUMP; i++) {
p_jump[x] = px;
p_jump[y] = py;
x = p_rev[x];
y = p_rev[y];
px = p_rev[px];
py = p_rev[py];
}
} else {
int id, k;
cin >> id >> k;
while (k >= JUMP) {
id = p_jump[id];
k -= JUMP;
}
while (k--) {
id = p[id];
}
cout << id << "\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[500001];
map<int, int> cnt, pos;
vector<int> ans;
struct mypair {
int left;
int right;
int value;
};
mypair Mypair[500001];
int pointer = 0;
void writeans(int a, int b) {
ans.push_back(a);
ans.push_back(b);
ans.push_back(a);
ans.push_back(b);
cnt.clear();
pos.clear();
pointer = 0;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
if (cnt.find(a[i]) != cnt.end()) {
cnt[a[i]]++;
} else
cnt[a[i]] = 1;
if (cnt[a[i]] == 4) {
writeans(a[i], a[i]);
continue;
}
if (pos.find(a[i]) == pos.end()) {
pos[a[i]] = i;
continue;
}
int left = pos[a[i]];
pos[a[i]] = i;
while (pointer > 0) {
int lastl = Mypair[pointer - 1].left;
int lastr = Mypair[pointer - 1].right;
if (lastl < left && left < lastr) {
writeans(Mypair[pointer - 1].value, a[i]);
break;
} else if (lastl >= left) {
pointer--;
} else {
Mypair[pointer].left = left;
Mypair[pointer].right = i;
Mypair[pointer].value = a[i];
pointer++;
break;
}
}
if (pointer == 0) {
Mypair[pointer].left = left;
Mypair[pointer].right = i;
Mypair[pointer].value = a[i];
pointer++;
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int arr[n][m], arr2[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
for (int j = 0; j < m; j++) {
for (int i = 0; i < m; i++) {
for (int a = 0; a < n; a++) {
for (int b = 0; b < m; b++) {
if (b == i)
arr2[a][b] = arr[a][j];
else if (b == j)
arr2[a][b] = arr[a][i];
else
arr2[a][b] = arr[a][b];
}
}
int flag = 1;
for (int a = 0; a < n; a++) {
int ct = 0;
for (int b = 0; b < m; b++) {
if (arr2[a][b] != b + 1) {
ct++;
}
}
if (ct > 2) {
flag = 0;
}
}
if (flag == 1) {
cout << "YES\n";
return 0;
}
}
}
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int A, N, P, H, R;
int F(long long a, int n, int p) {
int t = a * n / p;
if (!t) return a > p - a * n ? a : p - a * n;
if (a * n % p < a * (p / a - 1)) t--;
return F(min(p % a, a - p % a), t, a);
}
int main() {
for (scanf("%d", &R); R--;) {
scanf("%d%d%d%d", &A, &N, &P, &H);
int HH;
A %= P;
if (1LL * A * N < P)
HH = A;
else
HH = F(A, N, P);
puts(HH <= H ? "YES" : "NO");
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int time;
scanf("%d", &time);
while (time--) {
long long int n, ans = 1, anss = 1;
cin >> n;
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
for (long long int i = 0; i < n; i++) {
if (ans >= v[i])
anss = ans + 1, ans++;
else
ans++;
}
cout << anss << endl;
}
}
| 1 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
void solution(int t) {
long long n, k, step = 0, cur_k = 0, count_1 = 0;
std::cin >> n >> k;
std::vector<int> binN;
long long n_copy = n;
while (n_copy > 0) {
binN.push_back(n_copy % 2);
count_1 += n_copy % 2;
n_copy /= 2;
}
if (count_1 > k) {
std::cout << "No";
return;
} else {
std::cout << "Yes\n";
}
std::reverse(binN.begin(), binN.end());
cur_k = count_1;
step = (int)binN.size();
binN.resize(100000);
int last_1 = 0;
for (int i = 0; i < binN.size(); i++) {
if (binN[i] > 0) {
last_1 = i;
}
}
for (int i = 0; cur_k < k; i++) {
if (binN[i] > 0) {
if (i > last_1) {
last_1 = i;
}
if (binN[i] + cur_k > k) {
break;
} else {
cur_k += binN[i];
binN[i + 1] += binN[i] * 2;
binN[i] = 0;
}
}
}
for (int i = last_1; cur_k < k; i++, cur_k++) {
binN[i]--;
binN[i + 1] += 2;
}
for (int i = 0; i < 100000; i++)
for (int j = 0; j < binN[i]; j++) {
std::cout << step - i - 1 << " ";
}
}
int main() {
int t = 1;
for (int i = 0; i < t; i++) solution(i);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<long long> a, v;
map<long long, long long> mp;
long long solve();
int main() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
++mp[a[i]];
}
cout << solve() << endl;
return 0;
}
long long solve() {
long long ans = 0;
vector<long long> v;
for (auto now : mp) v.push_back(now.second);
sort(v.begin(), v.end());
n = v.size();
for (int i = 1; i <= v[n - 1]; ++i) {
long long sum = 0, now = i;
auto it = lower_bound(v.begin(), v.end(), i);
while (it != v.end()) {
sum += now;
now *= 2;
++it;
it = lower_bound(it, v.end(), now);
}
ans = max(ans, sum);
}
return ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int stop[100], n, xu, yu, num;
double t, S2U, b1, b2, vs, vb, ans = 100000000;
void go(int k) {
t = stop[k] / vb;
b1 = stop[k] - xu;
b1 *= b1;
b2 = yu * yu;
S2U = sqrt((b1 + b2));
t += (S2U / vs);
}
int main() {
cin >> n >> vb >> vs;
for (int i = 0; i < n; i++) {
cin >> stop[i];
}
cin >> xu >> yu;
for (int i = 1; i < n; i++) {
go(i);
if (t <= ans) {
ans = t;
num = i;
}
}
cout << num + 1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 0x3c3c3c3c;
const long long INFL = 0x3c3c3c3c3c3c3c3c;
int last[100003];
int N, x, d;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> x >> d;
int cnt = 0;
for (int j = 1; j * j <= x; j++) {
if (x % j) continue;
if (last[j] + d < i) cnt++;
if (j * j != x && last[x / j] + d < i) cnt++;
last[j] = i;
last[x / j] = i;
}
cout << cnt << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, pair<long long int, long long int>>> is;
priority_queue<pair<long long int, long long int>> q;
vector<pair<long long int, long long int>> vs;
long long int n, m, b, k, x1[200010], x2[210][210], z, c, s, a, ans, aa, ab, ac,
d;
string j;
set<int> ss;
int main() {
scanf("%I64d", &n);
for (int w = 0; w < n; w++) {
cin >> j;
c = 0;
sort(j.begin(), j.end());
for (int r = 0; r < j.length() / 2; r++) {
if (j[r] != j[j.length() - 1 - r]) {
cout << j << endl;
c = 1;
break;
}
}
if (c == 0) cout << -1 << endl;
}
return 0;
}
| 0 |
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const long long N=1e5+5,M=1e16+9;
string s;
long long d[N],a[N],b[N],c[N],p[N],g[N],gg[N];
long long n;
void make1(){
cout<<a[1];
for(long long i=2;i<=n;i++)cout<<s[0]<<a[i];
}
void make2(){
if(s[0]=='+' || s[1]=='+'){
cout<<a[1];
for(long long i=2;i<=n;i++)cout<<'+'<<a[i];
}else{
cout<<a[1];
for(long long i=2;i<=n;i++){
if(a[i]==0)cout<<'-';else
cout<<'*';
cout<<a[i];
}
}
}
bool check(long long l,long long r){
long long t=1ll;
for(;l<=r;){
t*=(long long)a[l++];
if(t>M)return 1;
}
return 0;
}
void find(long long l,long long r){
if(check(l,r)){
c[l]++;c[r]--;
return ;
}
d[l]=a[l];
g[l]=l;
p[l+1]=l;
for(long long i=l+1;i<=r;i++)
if(a[i]==1){
d[i]=d[i-1]+1;
g[i]=i;
p[i+1]=p[i];
}else{
p[i+1]=i;
long long sum=a[i];
for(long long j=i;j;j=p[j],sum*=a[j])
if(sum+d[j-1]>=d[i]){
d[i]=sum+d[j-1];
// cout<<j<<' '<<d[i]<<endl;
g[i]=j;
}
}
// cout<<d[1]<<' '<<d[2]<<endl;
// cout<<g[1]<<' '<<g[2]<<endl;
while(r!=l-1){
if(g[r]!=r){
c[g[r]]++;
c[r]--;
}
r=g[r]-1;
}
}
void make3(){
long long x=0;
//cout<<"???????????";
for(long long i=1;i<=n;i++)
if(a[i]!=0)b[i]=b[i-1]+1;
for(long long i=1;i<=n;i++)//????
if(b[i] && !b[i+1]){
long long r=i,l=i-b[i]+1;
while(a[r]==1)r--;
while(a[l]==1)l++;
if(l>=r)continue;
find(l,r);
/* while(x<r){
cout<<a[++x];
c[x]+=c[x-1];
if(x!=n)if(c[x])cout<<"*";else cout<<"+";
}*/
}
for(long long i=1;i<n;i++){
cout<<a[i];
c[i]+=c[i-1];
if(c[i])cout<<"*";else cout<<"+";
}
cout<<a[n];
/* while(x<n){
cout<<a[++x];
c[x]+=c[x-1];
if(x!=n)if(c[x])cout<<"*";else cout<<"+";
}*/
// cout<<a[n];
}
int main(){
scanf("%lld",&n);
// if(n==100000)cout<<"666";//5456456564
for(long long i=1;i<=n;i++)scanf("%lld",&a[i]);
cin>>s;
if(s.length()==1)make1();else
if(s.length()==2 && (s[0]=='-' || s[1]=='-'))make2();else
make3();
}
/*
7
0 1 2 3 4 1 0
*+-
*/
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n;
cin >> n;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i;
}
if (n == 1) {
cout << -1;
return 0;
}
sort(a.begin(), a.end());
int sum = 0;
for (int i = 1; i < n; i++) {
sum += a[i].first;
}
if (sum == a[0].first) {
cout << -1;
} else {
cout << "1\n";
cout << a[0].second + 1;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
const int MAXN = 5e5 + 7;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
struct edge {
int u, v, x;
};
int a[maxn];
int vis[(1 << 20) + 3];
vector<edge> edges;
vector<int> g[3 * MAXN];
vector<int> res;
queue<int> q;
int tot = 0;
int viss[3 * MAXN];
void dfs(int u) {
while (!g[u].empty()) {
int m = g[u].back();
g[u].pop_back();
if (viss[m]) continue;
viss[m] = 1;
edge e = edges[m];
if (u == e.u)
dfs(e.v);
else
dfs(e.u);
res.push_back(e.x);
}
return;
}
int main() {
int i, j, n, m, t, z;
int ans = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &a[2 * i - 1], &a[2 * i]);
}
int k;
for (k = 20; k >= 0; k--) {
tot = 0;
edges.clear();
int tmp = (1 << k) - 1;
for (i = 1; i <= n; i++) {
int tmp1, tmp2, tmp3;
if (vis[a[2 * i - 1] & tmp])
tmp1 = vis[a[2 * i - 1] & tmp];
else
tmp1 = ++tot;
vis[a[2 * i - 1] & tmp] = tmp1;
if (vis[a[2 * i] & tmp])
tmp2 = vis[a[2 * i] & tmp];
else
tmp2 = ++tot;
tmp3 = ++tot;
vis[a[2 * i] & tmp] = tmp2;
edges.push_back(edge{tmp1, tmp3, 2 * i - 1});
int m = edges.size() - 1;
g[tmp1].push_back(m);
g[tmp3].push_back(m);
edges.push_back(edge{tmp2, tmp3, 2 * i});
m = edges.size() - 1;
g[tmp2].push_back(m);
g[tmp3].push_back(m);
}
int flag = 0;
for (i = 1; i <= tot; i++) {
if (g[i].size() & 1) {
flag = 1;
}
}
if (!flag) {
ans = k;
res.clear();
dfs(1);
if (res.size() == 2 * n) break;
}
for (i = 0; i <= tot; i++) {
g[i].clear();
}
for (i = 0; i <= 2 * n; i++) viss[i] = 0;
tmp = (1 << k) - 1;
for (i = 0; i <= tmp; i++) vis[i] = 0;
}
printf("%d\n", ans);
for (int i = 0; i < res.size(); i++) {
printf("%d%c", res[i], i == res.size() - 1 ? '\n' : ' ');
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char arr[8][8];
string s;
for (int i = 0; i < 8; i++) {
cin >> s;
for (int j = 0; j < 8; j++) arr[i][j] = s[j];
}
int ans = 0;
int vi[8][8];
memset(vi, 0, sizeof vi);
for (int i = 0; i < 8; i++) {
int flag = 1;
for (int j = 0; j < 8; j++) {
if (arr[i][j] != 'B') {
flag = 0;
break;
}
}
if (flag) {
for (int j = 0; j < 8; j++) vi[i][j] = 1;
ans++;
}
}
for (int i = 0; i < 8; i++) {
int flag = 1, count = 0;
for (int j = 0; j < 8; j++) {
if (arr[j][i] != 'B') {
flag = 0;
break;
}
if (vi[j][i]) count++;
}
if (count == 8) flag = 0;
if (flag) ans++;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long 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 lcm(T a, T b) {
a = abs(a);
b = abs(b);
return (a / gcd(a, b)) * b;
}
template <class T, class X>
inline bool getbit(T a, X i) {
T t = 1;
return ((a & (t << i)) > 0);
}
template <class T, class X>
inline T setbit(T a, X i) {
T t = 1;
return (a | (t << i));
}
template <class T, class X>
inline T resetbit(T a, X i) {
T t = 1;
return (a & (~(t << i)));
}
inline long long getnum() {
char c = getchar();
long long num, sign = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') sign = -1;
for (num = 0; c >= '0' && c <= '9';) {
c -= '0';
num = num * 10 + c;
c = getchar();
}
return num * sign;
}
inline long long power(long long a, long long b) {
long long multiply = 1;
for (int i = (0); i < (b); i++) {
multiply *= a;
}
return multiply;
}
namespace mcmf {
const int MAX = 1000010;
const int INF = 1 << 25;
int cap[MAX], flow[MAX], cost[MAX], dis[MAX];
int n, m, s, t, Q[10000010], adj[MAX], link[MAX], last[MAX], from[MAX],
visited[MAX];
void init(int nodes, int source, int sink) {
m = 0, n = nodes, s = source, t = sink;
for (int i = 0; i <= n; i++) last[i] = -1;
}
void addEdge(int u, int v, int c, int w) {
adj[m] = v, cap[m] = c, flow[m] = 0, cost[m] = +w, link[m] = last[u],
last[u] = m++;
adj[m] = u, cap[m] = 0, flow[m] = 0, cost[m] = -w, link[m] = last[v],
last[v] = m++;
}
bool spfa() {
int i, j, x, f = 0, l = 0;
for (i = 0; i <= n; i++) visited[i] = 0, dis[i] = INF;
dis[s] = 0, Q[l++] = s;
while (f < l) {
i = Q[f++];
for (j = last[i]; j != -1; j = link[j]) {
if (flow[j] < cap[j]) {
x = adj[j];
if (dis[x] > dis[i] + cost[j]) {
dis[x] = dis[i] + cost[j], from[x] = j;
if (!visited[x]) {
visited[x] = 1;
if (f && rand() & 7)
Q[--f] = x;
else
Q[l++] = x;
}
}
}
}
visited[i] = 0;
}
return (dis[t] != INF);
}
pair<int, int> solve() {
int i, j;
int mincost = 0, maxflow = 0;
while (spfa()) {
int aug = INF;
for (i = t, j = from[i]; i != s; i = adj[j ^ 1], j = from[i]) {
aug = min(aug, cap[j] - flow[j]);
}
for (i = t, j = from[i]; i != s; i = adj[j ^ 1], j = from[i]) {
flow[j] += aug, flow[j ^ 1] -= aug;
}
maxflow += aug, mincost += aug * dis[t];
}
return make_pair(mincost, maxflow);
}
} // namespace mcmf
int n, a[3005];
int cnt[100005];
int main() {
int test, cases = 1;
scanf("%d", &n);
for (int i = (1); i < (n + 1); i++) scanf("%d", &a[i]);
int src = 0, mid = 2 * n + 2, sink = 2 * n + 4;
mcmf::init(2 * n + 5, src, sink);
mcmf::addEdge(src, mid, 4, 0);
for (int i = (1); i < (n + 1); i++) mcmf::addEdge(i, i + n, 1, -1);
for (int i = (1); i < (n + 1); i++) mcmf::addEdge(mid, i, 1, 0);
for (int i = (1); i < (n + 1); i++) mcmf::addEdge(i + n, sink, 1, 0);
for (int i = (1); i < (n + 1); i++) {
for (int j = (1); j < (n + 1); j++) cnt[a[j]] = 0;
for (int j = (i + 1); j < (n + 1); j++) {
cnt[a[j]]++;
if (abs(a[i] - a[j]) == 1 && cnt[a[j]] <= 5)
mcmf::addEdge(i + n, j, 1, 0);
}
}
for (int i = (1); i < (n + 1); i++) a[i] %= 7;
for (int i = (1); i < (n + 1); i++) {
for (int j = (1); j < (n + 1); j++) cnt[a[j]] = 0;
for (int j = (i + 1); j < (n + 1); j++) {
cnt[a[j]]++;
if (a[i] == a[j] && cnt[a[j]] <= 5) mcmf::addEdge(i + n, j, 1, 0);
}
}
pair<int, int> out = mcmf::solve();
cout << -out.first << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005], ansx, ansy, n, qst, qed, now, ansk, x, y, l;
bool find(int nx, int t) {
qst = 1;
qed = 1;
now = b[1];
while (qst <= n) {
if (now == nx) {
if (t == 0)
return 1;
else {
if (a[qed] - x >= 0 || a[qed] + y <= l) return 1;
}
}
if (qed < qst && now > nx) {
now -= b[qed];
qed++;
} else {
qst++;
now += b[qst];
}
}
return 0;
}
int main() {
int i, j, m;
scanf("%d%d%d%d", &n, &l, &x, &y);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[i - 1] = a[i] - a[i - 1];
}
n--;
if (!find(x, 0)) ansx++;
if (!find(y, 0)) ansy++;
if (x == y && ansx) {
printf("%d\n%d\n", 1, x);
} else if (x != y && ansx && ansy) {
if (find(x + y, 0)) ansk++;
if (ansk) {
printf("1\n%d\n", x + a[qed]);
} else {
if (find(y - x, 1)) ansk++;
if (ansk) {
printf("1\n");
if (a[qed] - x >= 0)
printf("%d\n", a[qed] - x);
else
printf("%d\n", a[qed] + y);
} else
printf("2\n%d %d\n", x, y);
}
} else {
if (ansx + ansy == 2) {
printf("2\n%d %d\n", x, y);
} else {
printf("%d\n", ansx + ansy);
if (ansx) printf("%d\n", x);
if (ansy) printf("%d\n", y);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
const int maxn = (int)1e5 + 10, maxk = (int)1e4 + 10;
long long a[maxn];
int c[maxn];
set<pair<int, int> > tres;
long long minGot[maxk];
vector<vector<pair<long long, int> > > rs;
bool update(int r, long long newval) {
if (minGot[r] <= newval) return false;
minGot[r] = newval;
while (((int)(rs[r]).size()) && rs[r].back().first >= newval) {
int id = rs[r].back().second;
tres.insert(make_pair(-c[id], id));
rs[r].pop_back();
}
return true;
}
void addGoType(long long x, int k) {
set<pair<long long, int> > cur;
for (int i = 0; i < k; ++i) {
cur.insert(make_pair(minGot[i], i));
}
int rx = x % k;
while (((int)(cur).size())) {
int id = cur.begin()->second;
cur.erase(cur.begin());
int nid = id + rx;
if (nid >= k) nid -= k;
long long newGot = minGot[id] + x;
if (minGot[nid] > newGot) {
cur.erase(make_pair(minGot[nid], nid));
assert(update(nid, minGot[id] + x));
cur.insert(make_pair(minGot[nid], nid));
}
}
}
bool solve() {
long long h;
int n, m, k;
if (scanf("%lld"
"%d%d%d",
&h, &n, &m, &k) < 4)
return 0;
for (int i = 0; i < n; ++i)
scanf(
"%lld"
"%d",
&a[i], &c[i]),
--a[i];
rs = vector<vector<pair<long long, int> > >(k);
for (int i = 0; i < n; ++i) {
rs[a[i] % k].push_back(make_pair(a[i], i));
}
for (int i = 0; i < k; ++i) sort(rs[i].begin(), rs[i].end());
for (int i = 0; i < k; ++i) minGot[i] = ((long long)2e18);
tres.clear();
update(0, 0);
for (int i = 0; i < m; ++i) {
int type;
scanf("%d", &type);
if (i == -1 || type == 1) {
long long x;
scanf("%lld", &x);
addGoType(x, k);
continue;
}
if (type == 2) {
int id, newVal;
scanf("%d%d", &id, &newVal);
--id;
if (a[id] >= minGot[a[id] % k]) tres.erase(make_pair(-c[id], id));
c[id] -= newVal;
if (a[id] >= minGot[a[id] % k]) tres.insert(make_pair(-c[id], id));
continue;
}
if (type == 3) {
if (((int)(tres).size()) == 0) {
printf("0\n");
} else {
pair<int, int> cur = *tres.begin();
tres.erase(tres.begin());
printf("%d\n", -cur.first);
}
continue;
}
assert(0);
}
return 1;
}
int main() {
srand(rdtsc());
while (1) {
if (!solve()) break;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string q[4];
bool can[4];
bool okey(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') return true;
return false;
}
bool ok(string a, string b) {
if ((int)a.length() < k || (int)b.length() < k) return false;
int aa = a.length();
int bb = b.length();
int an = -1, ans1 = 0;
int bn = -1, ans2 = 0;
for (int i = aa - 1; i >= 0; i--) {
if (okey(a[i])) ans1++;
if (ans1 == k) {
an = i;
break;
}
}
if (an == -1) return false;
for (int i = bb - 1; i >= 0; i--) {
if (okey(b[i])) ans2++;
if (ans2 == k) {
bn = i;
break;
}
}
if (bn == -1) return false;
if (a.substr(an, aa - an) == b.substr(bn, bb - bn)) return true;
return false;
}
void go(string g[4]) {
if (!(ok(g[0], g[1]) && ok(g[2], g[3]))) can[0] = false;
if (!(ok(g[0], g[2]) && ok(g[1], g[3]))) can[1] = false;
if (!(ok(g[0], g[3]) && ok(g[1], g[2]))) can[2] = false;
for (int i = 0; i < 4; i++)
for (int j = i + 1; j < 4; j++)
if (!ok(g[i], g[j])) {
can[3] = false;
return;
}
}
int main() {
q[0] = "aabb";
q[1] = "abab";
q[2] = "abba";
q[3] = "aaaa";
for (int i = 0; i <= 3; i++) can[i] = true;
scanf("%d%d\n", &n, &k);
for (int i = 1; i <= n; i++) {
string g[4];
char c = '+';
for (int j = 0; j < 4; j++) {
g[j] = "";
c = '+';
while (scanf("%c", &c) == 1)
if (c != '\n')
g[j] += c;
else
break;
}
go(g);
}
for (int i = 3; i >= 0; i--)
if (can[i]) {
cout << q[i];
return 0;
}
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
int n, k;
int arr[MAXN];
vector<int> pai[MAXN];
int deets[10000015];
int get(int a) { return deets[a]; }
int main() {
deets[0] = -1;
for (int i = 1; i <= 10000000; i++) {
if (!(i & (i - 1)))
deets[i] = deets[i - 1] + 1;
else
deets[i] = deets[i - 1];
}
scanf("%d %d\n", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &arr[i]);
for (int i = 1; i <= n; i++) {
int kt = arr[i];
int num0 = 1, num1 = 0;
while (1) {
pai[i].push_back(num1);
if (kt == 1) break;
if (kt & 1) {
int cp_num0 = num0;
int cp_num1 = num1;
kt /= 2;
num0 = cp_num0;
num1 = cp_num0 + 2 * cp_num1;
} else {
int cp_num0 = num0;
int cp_num1 = num1;
kt /= 2;
num0 = 2 * cp_num0 + cp_num1;
num1 = cp_num1;
}
}
reverse(pai[i].begin(), pai[i].end());
}
int lo = 0, hi = 1e7;
while (hi > lo) {
int mid = (hi + lo + 1) / 2;
long long tot = 0;
for (int i = 1; i <= n; i++) {
if (mid > arr[i]) continue;
if (mid == 1) {
tot += arr[i];
continue;
}
int maxi = 1 << (get(arr[i] / mid));
int lak = get(arr[i] / (mid - 1));
int ke = pai[i][pai[i].size() - 1 - lak];
maxi = max(maxi, ke);
tot += maxi;
}
if (tot >= k) {
lo = mid;
} else
hi = mid - 1;
}
if (lo == 0)
cout << -1 << '\n';
else
cout << lo << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
struct node {
int x, y;
} h[20005];
int kk(int x1, int y1, int x2, int y2, int x3, int y3) {
return ((x2 * y3 + x1 * y2 + x3 * y1 - x3 * y2 - x2 * y1 - x1 * y3));
}
int main() {
int a, b, c, d, e, f;
scanf("%d", &a);
for (b = 1; b <= a; b++) {
scanf("%d %d", &h[b].x, &h[b].y);
}
f = 0;
for (c = 1; c <= a; c++) {
for (d = c + 1; d <= a; d++) {
for (e = d + 1; e <= a; e++) {
if (kk(h[e].x, h[e].y, h[c].x, h[c].y, h[d].x, h[d].y)) f++;
}
}
}
printf("%d\n", f);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Dbg {
template <typename T>
Dbg& operator,(const T& v) {
cerr << v << ", ";
return *this;
}
} Dbg;
template <typename T>
ostream& operator<<(ostream& _o_, const vector<T>& _v_) {
if (!_v_.empty()) {
_o_ << '[';
copy(_v_.begin(), _v_.end(), ostream_iterator<T>(_o_, ", "));
_o_ << "\b\b]";
}
return _o_;
}
template <class C>
void mini(C& _a, C _b) {
_a = min(_a, _b);
}
template <class C>
void maxi(C& _a, C _b) {
_a = max(_a, _b);
}
vector<int> scn(int n) {
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long r;
cin >> r;
for (long long x = 1; x * x <= r; x++) {
if (r - x * x - x - 1 > 0 && (r - x * x - x - 1) % 2 == 0) {
long long y = (r - x * x - x - 1) / 2 / x;
cout << x << ' ' << y;
return 0;
}
}
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k1, t, k2;
cin >> t;
while (t--) {
cin >> n >> k1 >> k2;
int maxx = INT_MIN;
bool f = false;
for (int i = 0; i < k1; i++) {
int num;
cin >> num;
if (num == n) {
f = true;
}
}
for (int i = 0; i < k2; i++) {
int num;
cin >> num;
}
if (f)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[400005];
vector<int> v[20];
long long sum[20][20];
long long dp[1 << 20];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i]--;
v[a[i]].push_back(i);
}
for (int i = 0; i < 20; i++) {
for (int j = 0; j < 20; j++) {
if (i == j) continue;
int p = 0;
for (int k = 0; k < v[j].size(); k++) {
while (p < v[i].size() && v[i][p] < v[j][k]) p++;
sum[i][j] += p;
}
}
}
for (int i = 0; i < (1 << 20); i++) dp[i] = 1e18;
dp[0] = 0;
for (int i = 0; i < (1 << 20); i++) {
vector<int> v;
for (int j = 0; j < 20; j++) {
if ((i >> j) & 1) continue;
v.push_back(j);
}
for (int j = 0; j < 20; j++) {
if ((i >> j) & 1) {
long long res = 0;
for (int k = 0; k < v.size(); k++) res += sum[v[k]][j];
dp[i] = min(dp[i], dp[i ^ (1 << j)] + res);
}
}
}
printf("%lld\n", dp[(1 << 20) - 1]);
}
| 7 |
#include <bits/stdc++.h>
int n, m, d;
struct pair {
int c;
int w;
} phys[100000], info[100000];
uint64_t phys_pref_cost[100000], phys_pref_width[100000];
uint64_t info_pref_cost[100000], info_pref_width[100000];
uint64_t total_cost = 0;
int comp(const void *a, const void *b) {
const struct pair *pa = (struct pair *)a;
const struct pair *pb = (struct pair *)b;
if (pa->c > pb->c) return -1;
if (pa->c < pb->c) return 1;
if (pa->w < pb->w) return -1;
if (pa->w > pb->w) return 1;
return 0;
}
int main() {
int i, j;
int phys_width_pos = 0;
int info_width_pos = 0;
scanf("%d %d %d", &n, &m, &d);
for (i = 0; i < n; ++i) {
scanf("%d %d", &phys[i].c, &phys[i].w);
}
for (i = 0; i < m; ++i) {
scanf("%d %d", &info[i].c, &info[i].w);
}
qsort(phys, n, sizeof(phys[0]), comp);
qsort(info, m, sizeof(info[0]), comp);
phys_pref_cost[0] = phys[0].c;
phys_pref_width[0] = phys[0].w;
for (i = 1; i < n; ++i) {
phys_pref_cost[i] = phys_pref_cost[i - 1] + phys[i].c;
phys_pref_width[i] = phys_pref_width[i - 1] + phys[i].w;
}
info_pref_cost[0] = info[0].c;
info_pref_width[0] = info[0].w;
for (i = 1; i < m; ++i) {
info_pref_cost[i] = info_pref_cost[i - 1] + info[i].c;
info_pref_width[i] = info_pref_width[i - 1] + info[i].w;
}
if (phys[0].w + info[0].w > d) {
printf("0\n");
return 0;
}
{
uint64_t max_width = d - info[0].w;
i = 1;
while (i < n && phys_pref_width[i] <= max_width) {
++i;
}
phys_width_pos = --i;
if (total_cost < phys_pref_cost[i] + info[0].c) {
total_cost = phys_pref_cost[i] + info[0].c;
}
}
{
uint64_t max_width = d - phys[0].w;
i = 1;
while (i < m && info_pref_width[i] <= max_width) {
++i;
}
info_width_pos = --i;
if (total_cost < info_pref_cost[i] + phys[0].c) {
total_cost = info_pref_cost[i] + phys[0].c;
}
}
{
int c_info_pos = 1;
while (phys_width_pos &&
info_pref_width[c_info_pos] + phys_pref_width[phys_width_pos] > d) {
--phys_width_pos;
}
while (phys_width_pos && c_info_pos < m) {
while (info_pref_width[c_info_pos] + phys_pref_width[phys_width_pos] <=
d) {
++c_info_pos;
}
--c_info_pos;
if (info_pref_cost[c_info_pos] + phys_pref_cost[phys_width_pos] >
total_cost) {
total_cost =
info_pref_cost[c_info_pos] + phys_pref_cost[phys_width_pos];
}
--phys_width_pos;
}
}
{
int c_phys_pos = 1;
while (
info_width_pos &&
(info_pref_width[info_width_pos] + phys_pref_width[c_phys_pos] > d)) {
--info_width_pos;
}
while (info_width_pos && c_phys_pos < n) {
while (info_pref_width[info_width_pos] + phys_pref_width[c_phys_pos] <=
d) {
++c_phys_pos;
}
--c_phys_pos;
if (info_pref_cost[info_width_pos] + phys_pref_cost[c_phys_pos] >
total_cost) {
total_cost =
info_pref_cost[info_width_pos] + phys_pref_cost[c_phys_pos];
}
--info_width_pos;
}
}
printf("%I64d\n", total_cost);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long leftAns[21], rightAns[21];
int n, m, query, k, a[2000000], b[2000000];
int get_inver(int l1, int r1, int value) {
int res = 0;
int end = r1;
while (r1 - l1 > 1) {
int m = (l1 + r1) >> 1;
if (b[m] > value)
r1 = m;
else
l1 = m;
}
res = end - r1;
if (b[r1] > value) res++;
return res;
}
void my_m(int l1, int r1, int l2, int r2) {
int st = l1;
static int c[2000000];
int d = 0;
int v = r2 - l1 + 1;
for (int j = 1; j < v; j <<= 1, d++)
;
int cnt = -1;
while (l1 <= r1 || l2 <= r2) {
cnt++;
if (l1 <= r1 && (l2 > r2 || b[l1] <= b[l2])) {
rightAns[d] += get_inver(l2 - 1, r2, b[l1]);
c[cnt] = b[l1++];
} else {
leftAns[d] += get_inver(l1 - 1, r1, b[l2]);
c[cnt] = b[l2++];
}
}
for (int i = 0; i <= cnt; i++) {
b[st + i] = c[i];
}
}
void getValues(int l, int r) {
if (r - l <= 1) {
if (a[l] > a[r])
leftAns[1]++;
else if (a[l] < a[r])
rightAns[1]++;
b[l] = min(a[l], a[r]);
b[r] = max(a[l], a[r]);
} else {
int tm = (l + r) >> 1;
getValues(l, tm);
getValues(tm + 1, r);
my_m(l, tm, tm + 1, r);
}
}
int main() {
scanf("%d", &n);
int nD = n;
n = pow(2, n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
getValues(0, n - 1);
for (int i = 2; i <= nD; i++) {
leftAns[i] += leftAns[i - 1];
rightAns[i] += rightAns[i - 1];
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
long long addValue = 0;
scanf("%d", &query);
for (int j = 1; j <= query; j++) {
if (j == query) {
addValue = rightAns[j] - leftAns[j];
break;
}
long long sw = leftAns[j];
leftAns[j] = rightAns[j];
rightAns[j] = sw;
}
for (int j = query; j <= nD; j++) {
leftAns[j] += addValue;
rightAns[j] -= addValue;
}
printf("%I64d\n", leftAns[nD]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using LL = int64_t;
using LD = long double;
const LL INF = 0x3f3f3f3f;
const LL mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
LL n, k, d;
cin >> n >> k >> d;
vector<LL> a(n), dp(n), sum(n);
for (auto& i : a) cin >> i;
sort(a.begin(), a.end());
for (int i = 0; i < n; i++) {
int l = lower_bound(a.begin(), a.end(), a[i] - d) - a.begin();
if (i - l + 1 < k)
dp[i] = 0;
else {
if (l == 0)
dp[i] = 1;
else if (l == 1)
dp[i] = !!sum[i - k];
else
dp[i] = !!(sum[i - k] - sum[l - 2]);
}
if (i)
sum[i] = sum[i - 1] + dp[i];
else
sum[i] = dp[i];
}
if (dp.back())
cout << "YES\n";
else
cout << "NO\n";
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.