solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long inf = 1e9;
long long a[100005], ans[100005];
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
void solve() {
int n, m, l, ct = 0, ans;
bool ok = true;
cin >> n >> l >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i + 1 < n; i++) {
int gg = max(0ll, a[i + 1] - m);
l += a[i] - gg;
if (l < 0) ok = false;
}
cout << (ok ? "YES\n" : "NO\n");
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, ans, sum;
long long a[300009], b[300009], s[2][300009], ss[300009];
signed main() {
cin >> n;
s[0][0] = 1;
for (long long i = 1; i < n + 1; ++i) {
cin >> a[i];
a[i] = __builtin_popcountll(a[i]);
sum += a[i];
s[0][i] = s[0][i - 1], s[1][i] = s[1][i - 1];
if (sum % 2 == 0)
s[0][i]++;
else
s[1][i]++;
long long ma = a[i];
for (long long j = 1; j < 70 && j <= i; ++j) {
if ((sum - ss[i - j]) % 2 == 0 && ma * 2 <= (sum - ss[i - j])) ++ans;
ma = max(ma, a[i - j]);
}
if (i - 70 >= 0) {
if (sum % 2 == 1)
ans += s[1][i - 70];
else
ans += s[0][i - 70];
}
ss[i] = sum;
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
namespace {
using Val = unsigned long long int;
Val permuts(Val a, Val b, Val c, Val sum) {
if (sum == 0) return 1;
const auto biggest = max(a, max(b, c));
const auto smallest = min(a, min(b, c));
const auto middle = a + b + c - biggest - smallest;
Val res = 0;
const auto range =
make_pair(sum - min(biggest, sum), min(sum, smallest + middle));
if (range.first < smallest) {
const auto count = min(range.second, smallest - 1) - range.first + 1;
if (count > 0) res += (2 * (range.first + 1) + (count - 1)) * count / 2;
}
if (range.first <= middle && range.second >= smallest) {
const auto count =
min(range.second, middle) - max(range.first, smallest) + 1;
res += (smallest + 1) * count;
}
if (range.second >= middle + 1) {
const auto count =
min(range.second, middle + smallest) - max(range.first, middle + 1) + 1;
if (count > 0)
res += (2 * (middle + smallest - max(range.first, middle + 1) + 1) -
(count - 1)) *
count / 2;
}
return res;
}
Val ways(Val a, Val b, Val c, Val len) {
Val res = 0;
assert(permuts(1, 1, 1, 3) == 1);
assert(permuts(10, 8, 6, 1) == 3);
for (Val i = 0; i <= len; ++i) {
const auto m = (a + b + c + i + 1) / 2 - 1;
if (m >= a && m >= b && m >= c) {
const auto p = permuts(m - a, m - b, m - c, i);
res += p;
}
}
return res;
}
} // namespace
int main() {
Val a = 0, b = 0, c = 0, l = 0;
cin >> a >> b >> c >> l;
cout << ways(a, b, c, l) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> L[200005], W[200005];
vector<pair<long long, int> > path;
int a[200005], add[200005], rmv[200005];
void DFS(int u, long long dis) {
int v;
path.push_back(make_pair(dis, u));
for (int i = 0; i < L[u].size(); i++) DFS(L[u][i], dis + W[u][i]);
int pos = lower_bound(path.begin(), path.end(), make_pair(dis - a[u], -1)) -
path.begin();
if (pos != path.size() && path[pos].first >= dis - a[u]) {
v = path[pos].second;
rmv[v]--;
add[u]++;
}
path.pop_back();
}
int res[200005];
void solve(int u) {
int v, rem1 = 0, rem2 = 0;
for (int i = 0; i < L[u].size(); i++) {
v = L[u][i];
solve(v);
rem1 += add[v];
rem2 += rmv[v];
}
res[u] = rem1 + rem2;
add[u] += rem1;
rmv[u] += rem2;
}
int main() {
int n, u, v, w;
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n - 1; i++) {
u = i;
scanf("%d%d", &v, &w);
v--;
L[v].push_back(u);
W[v].push_back(w);
}
DFS(0, 0);
solve(0);
for (int i = 0; i < n; i++) {
if (i) printf(" ");
printf("%d", res[i]);
}
puts("");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101;
int e[N][N], f[N][N][2][30], n;
int dfs(int suck, int fuck, int dan, int c) {
int &azibint = f[suck][fuck][dan][c];
if (azibint != -1) return azibint;
azibint = 0;
if (dan == 0) {
for (int v = 1; v <= n; ++v) {
if (e[suck][v] >= c)
azibint = max(azibint, 1 - dfs(v, fuck, 1 - dan, e[suck][v]));
}
} else {
for (int v = 1; v <= n; ++v) {
if (e[fuck][v] >= c)
azibint = max(azibint, 1 - dfs(suck, v, 1 - dan, e[fuck][v]));
}
}
return azibint;
}
int main() {
memset(f, -1, sizeof f);
for (int i = 0; i < 101; i++)
for (int j = 0; j < 101; j++) e[i][j] = -1;
int m;
cin >> n >> m;
int suck, fuck;
char t;
for (int i = 1; i <= m; ++i) {
cin >> suck >> fuck >> t;
e[suck][fuck] = max(e[suck][fuck], int(t - 'a'));
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (dfs(i, j, 0, 0))
cout << 'A';
else
cout << 'B';
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, x, y;
cin >> n >> x >> y;
cout << min(max(x + y - n + 1, 1), n) << ' ' << min(x + y - 1, n) << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
printf("%d\n", (n + 1) / 2);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 25, mod = 1e9 + 7;
int a[N][N], used[N][N], cur, first, n, m, k;
long long ans;
int count(int x) {
int ans = 0;
for (; x; x -= x & -x) ans++;
return ans;
}
void dfs(int x, int y) {
if (x == n) {
int p = count(cur & ~first), q = count(((1 << k) - 1) & ~first);
long long curans = 1;
while (p--) {
curans = (curans * q) % mod;
q--;
}
ans = (ans + curans) % mod;
return;
}
int nx = x, ny = y + 1;
if (ny == m) {
nx++;
ny = 0;
}
if (a[x][y]) {
dfs(nx, ny);
return;
} else {
bool flag = true;
int can = (1 << k) - 1;
can &= ~used[x][y];
for (int i = 0; (1 << i) <= can; i++) {
if (!((can >> i) & 1)) continue;
bool preused[N][N], preusedcur;
preusedcur = true;
memset(preused, false, sizeof(preused));
if (!((cur >> i) & 1)) {
if (flag)
flag = false;
else
continue;
preusedcur = false;
}
cur |= 1 << i;
for (int px = x; px < n; px++)
for (int py = y; py < m; py++) {
if ((used[px][py] >> i) & 1)
preused[px][py] = true;
else
used[px][py] |= 1 << i;
}
dfs(nx, ny);
if (!preusedcur) cur &= ~(1 << i);
for (int px = x; px < n; px++)
for (int py = y; py < m; py++) {
if (!preused[px][py]) used[px][py] &= ~(1 << i);
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
if (n + m - 1 > k) {
printf("0\n");
return 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
if (a[i][j]) {
first |= 1 << a[i][j] - 1;
if ((used[i][j] >> a[i][j] - 1) & 1) {
printf("0\n");
return 0;
}
for (int r = 0; r < n; r++)
for (int c = 0; c < m; c++) {
if (r <= i && c <= j || r >= i && c >= j)
used[r][c] |= 1 << a[i][j] - 1;
}
}
}
cur = first;
dfs(0, 0);
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, z;
cin >> n;
int *arr = new int[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int min = 1100;
int index1 = 0, index2 = 0;
for (int i = 0; i < n; i++)
if (abs(arr[i] - arr[i + 1]) < min) {
min = abs(arr[i] - arr[i + 1]);
index1 = i + 1;
index2 = i + 2;
}
if (abs(arr[n - 1] - arr[0]) < min) {
index1 = n;
index2 = 1;
}
cout << index1 << " " << index2;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct data {
int x, y, l, bnd;
data(int a, int b, int c, int d) {
x = a, y = b, l = c;
bnd = d;
}
data(){};
};
int n, m, k, sx, sy, ex, ey;
bool use[30];
int ck[30];
int pos[55][55];
int d[55][55];
char a[55][55];
int xx[] = {1, 0, -1, 0};
int yy[] = {0, 1, 0, -1};
bool CK;
int S, E;
vector<pair<char, data> > v;
data from[55][55];
data q[5000];
string rst;
string go(int y, int x) {
string bur;
if (y == sy && x == sx) return "";
if (a[y][x] != 'T') bur += a[y][x];
return bur + go(from[y][x].y, from[y][x].x);
}
bool sf(pair<char, data> a, pair<char, data> b) { return a.first < b.first; }
int main() {
scanf("%d%d%d", &n, &m, &k);
int i, j;
for (i = 1; i <= n; i++) scanf("%s", &a[i][1]);
for (i = 1; i <= 4000; i++) rst += 'z';
for (i = 0; i < k; i++) use[i] = 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
if (a[i][j] == 'S') sx = j, sy = i;
if (a[i][j] == 'T') ex = j, ey = i;
}
while (1) {
next_permutation(use, use + 27);
if (use[0]) break;
int cnt = 0;
memset(ck, 0, sizeof(ck));
for (i = 1; i <= 26; i++)
if (use[i]) ck[i] = ++cnt;
if (ck[1] == 1 && ck[2] == 2 && ck[3] == 3) {
i = i;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) pos[i][j] = ck[a[i][j] - 'a' + 1];
pos[sy][sx] = pos[ey][ex] = 1;
S = E = 1;
memset(d, 0, sizeof(d));
memset(q, 0, sizeof(q));
q[S] = data(sx, sy, 1, 1);
d[sy][sx] = 1;
data K;
while (S <= E) {
int nE;
K = q[S];
if (K.x == ex && K.y == ey) {
break;
}
for (nE = S; nE <= K.bnd; nE++) {
int x = q[nE].x;
int y = q[nE].y;
if (q[nE].l == K.l && a[y][x] == a[K.y][K.x])
continue;
else
break;
}
for (int j = S; j < nE; j++) {
for (int i = 0; i < 4; i++) {
int nx = q[j].x + xx[i];
int ny = q[j].y + yy[i];
if (d[ny][nx] || !pos[ny][nx]) continue;
d[ny][nx] = q[j].l + 1;
from[ny][nx] = q[j];
v.push_back(make_pair(a[ny][nx], data(nx, ny, q[j].l + 1, 0)));
}
}
sort(v.begin(), v.end(), sf);
for (int i = 0; i < v.size(); i++) {
q[++E] = v[i].second;
}
for (int i = 0; i < v.size(); i++) {
q[E - i].bnd = E;
}
v.clear();
S = nE;
}
if (d[ey][ex] == 0) continue;
if (d[ey][ex] - 2 > rst.size()) continue;
CK = 1;
string bur = go(ey, ex);
reverse(bur.begin(), bur.end());
if (rst.size() < bur.size())
continue;
else if (rst.size() == bur.size())
rst = min(rst, bur);
else
rst = bur;
}
if (CK == 0)
printf("-1");
else
cout << rst;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int beavers[100005];
vector<int> tree[100005];
long long dp[100005];
int used[100005];
bool vis[100005];
int rootId;
bool cmp(int id1, int id2) { return dp[id1] < dp[id2]; }
int TreeDp(int id) {
if (vis[id]) return -1;
vis[id] = 1;
int i, sz = tree[id].size();
int childrenCt = 0;
vector<int> childrenBuff;
for (i = 0; i < sz; i++) {
int childId = tree[id][i];
if (TreeDp(childId) > 0) {
childrenBuff.push_back(childId);
childrenCt++;
}
}
sort(childrenBuff.begin(), childrenBuff.end(), cmp);
int availableBeavers = beavers[id];
if (id != rootId) availableBeavers--;
if (availableBeavers < 0) {
dp[id] = 0;
used[id] = 0;
} else {
if (id != rootId) {
dp[id] = 1;
used[id] = 1;
} else {
dp[id] = 0;
used[id] = 0;
}
sz = availableBeavers;
for (i = childrenCt - 1; i >= 0 && sz > 0; i--, sz--) {
dp[id] += dp[childrenBuff[i]] + 1;
used[id]++;
}
for (i = childrenCt - 1; i >= 0 && sz > 0; i--) {
int childId = childrenBuff[i];
int tmp = sz < (beavers[childId] - used[childId])
? sz
: (beavers[childId] - used[childId]);
dp[id] = dp[id] + (long long)tmp * 2;
used[id] += tmp;
sz -= tmp;
}
}
return 1;
}
int main() {
int i, n;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &beavers[i]);
}
for (i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
tree[a].push_back(b);
tree[b].push_back(a);
}
scanf("%d", &rootId);
rootId--;
memset(vis, 0, sizeof(vis));
TreeDp(rootId);
cout << dp[rootId] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct SegTree {
vector<int> tree, lazy;
vector<pair<int, int> > inter;
int intersect(pair<int, int> curr, pair<int, int> ori) {
if (ori.first <= curr.first && curr.second <= ori.second) return 0;
if (max(curr.first, ori.first) <= min(curr.second, ori.second)) return 1;
return 2;
}
int s;
pair<int, int> build(int x) {
tree[x] = INT32_MIN;
if (x >= s) return inter[x] = {x, x};
return inter[x] = {build(2 * x).first, build(2 * x + 1).second};
}
int ask(pair<int, int> ori) {
return askRec(1, {ori.first + s, ori.second + s});
}
int askRec(int x, pair<int, int> ori) {
int a = intersect(inter[x], ori);
if (a == 0) return tree[x] + lazy[x];
if (a == 2) return INT32_MIN;
return max(askRec(2 * x, ori), askRec(2 * x + 1, ori)) + lazy[x];
}
void updateInter(int val, pair<int, int> ori) {
updateInterRec(1, val, {ori.first + s, ori.second + s});
}
void updateInterRec(int x, int val, pair<int, int> ori) {
int a = intersect(inter[x], ori);
if (a == 0) lazy[x] += val;
if (a == 1) {
updateInterRec(2 * x, val, ori);
updateInterRec(2 * x + 1, val, ori);
}
if (x < s)
tree[x] =
max(tree[2 * x] + lazy[2 * x], tree[2 * x + 1] + lazy[2 * x + 1]);
}
void update(int x, int val) { updateRec(x + s, val); }
void updateRec(int x, int val) {
if (x == 0) return;
if (x >= s)
tree[x] = val;
else
tree[x] =
max(tree[2 * x] + lazy[2 * x], tree[2 * x + 1] + lazy[2 * x + 1]);
updateRec(x / 2, val);
}
SegTree(int n) {
s = pow(2, ceil(log2(n)));
tree.resize(4 * s);
lazy.resize(4 * s);
inter.resize(4 * s);
build(1);
}
};
vector<pair<int, int> > wep, arm;
struct monster {
int wep, arm, val, ind;
};
bool sortFunc(monster a, monster b) { return a.wep < b.wep; }
bool sortFunc2(monster a, monster b) { return a.arm < b.arm; }
vector<monster> mon;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
int n, m, p;
cin >> n >> m >> p;
wep.resize(n);
arm.resize(m);
mon.resize(p);
for (pair<int, int>& w : wep) cin >> w.first >> w.second;
for (pair<int, int>& a : arm) cin >> a.first >> a.second;
for (monster& mo : mon) cin >> mo.wep >> mo.arm >> mo.val;
arm.resize(m + 1);
arm[m] = {INT32_MAX, INT32_MAX};
SegTree tree = SegTree(m + 1);
sort(arm.begin(), arm.end());
sort(mon.begin(), mon.end(), sortFunc2);
int ind = 0;
for (int i = 0; i <= m; i++) {
tree.update(i, -arm[i].second);
pair<int, int> a = arm[i];
while (ind < p && mon[ind].arm < a.first) {
mon[ind].ind = i;
ind++;
}
}
sort(mon.begin(), mon.end(), sortFunc);
sort(wep.begin(), wep.end());
ind = 0;
int sol = INT32_MIN;
for (pair<int, int>& w : wep) {
while (ind < p && mon[ind].wep < w.first) {
tree.updateInter(mon[ind].val, {mon[ind].ind, m});
ind++;
}
sol = max(sol, tree.ask({0, m - 1}) - w.second);
}
cout << sol << "\n";
}
| 6 |
#include <iostream>
#include <vector>
#include <bitset>
#include <random>
#include <cmath>
#include <algorithm>
using namespace std;
const int MAXN = 1e5 + 7;
const long double EPS = 1e-9;
const long double INF = 1e18;
long double dp[MAXN][10];
int path[MAXN][10];
bool lseq(long double a, long double b) {
return a - b < EPS;
}
int main() {
#ifdef LOCAL
freopen("a.in", "r", stdin);
freopen("a.out", "w", stdout);
#endif
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, d;
cin >> n >> d;
vector<int> a(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
fill(&path[0][0], &path[0][0] + MAXN * 10, -1);
fill(&dp[0][0], &dp[0][0] + MAXN * 10, -INF);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 10; ++j) {
dp[i][j] = dp[i - 1][j];
path[i][j] = 11;
}
if (lseq(dp[i][a[i] % 10], log(a[i]))) {
dp[i][a[i] % 10] = log(a[i]);
path[i][a[i] % 10] = -1;
}
for (int j = 0; j < 10; ++j) {
long double new_res = dp[i - 1][j] + log(a[i]);
if (lseq(dp[i][(j * a[i]) % 10], new_res)) {
dp[i][(j * a[i]) % 10] = new_res;
path[i][(j * a[i]) % 10] = j;
}
}
}
vector<int> ans;
if (lseq(dp[n][d], 0.0)) {
cout << -1;
return 0;
}
int cur_n = n, cur_j = d;
while (cur_n && cur_j >= 0) {
if (path[cur_n][cur_j] <= 9) {
ans.push_back(a[cur_n]);
}
cur_j = (path[cur_n][cur_j] == 11) ? cur_j : path[cur_n][cur_j];
cur_n--;
}
sort(ans.begin(), ans.end());
if (ans.size() == 0) {
cout << -1;
return 0;
}
cout << ans.size() << endl;
for (int i : ans) {
cout << i << ' ';
}
}
| 6 |
#include <bits/stdc++.h>
long long n, a, b, c, r;
int main() {
scanf("%I64d %I64d %I64d %I64d", &n, &a, &b, &c);
r = b - c;
printf("%I64d", (n < a && n < b) ? 0
: (a < r || n < b)
? n / a
: ((n - b) / r) + 1 + ((n - b) % r + c) / a);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
void rd() {
cin >> s;
if (s != "start") exit(0);
}
int q(int x, int y) {
cout << "? " << x << ' ' << y << endl;
cin >> s;
if (s[0] == 'x') return 1;
if (s[0] == 'y') return 0;
exit(0);
}
int main() {
int i, l, r;
while (1) {
rd();
if (q(0, 1)) {
cout << "! " << 1 << endl;
continue;
}
for (i = 1; 1; i <<= 1)
if (q(i, i + i)) break;
for (l = i + 1, r = i + i; l < r;) {
i = ((long long)l + r) / 2;
if (q(i, r))
l = i + 1;
else
r = i;
}
cout << "! " << l << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n = 0, a_arr[200000 + 1] = {0};
vector<int> list_root;
int root[200000 + 1] = {0};
void find_root(int a_arr[200000 + 1], int i, int root[200000 + 1]) {
if (root[i] != 0) return;
stack<int> st;
while (true) {
st.push(i);
root[i] = -1;
int next = a_arr[i];
if (root[next] != 0) break;
i = next;
}
int temp_root;
if (root[a_arr[i]] != -1)
temp_root = root[a_arr[i]];
else {
temp_root = i;
list_root.push_back(temp_root);
}
while (!st.empty()) {
int temp = st.top();
root[temp] = temp_root;
st.pop();
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a_arr[i];
}
for (int i = 1; i <= n; i++) {
find_root(a_arr, i, root);
}
int main_root = 0;
int size = list_root.size();
for (int i = 0; i < size; i++) {
if (a_arr[list_root[i]] == list_root[i]) {
main_root = list_root[i];
break;
}
}
if (main_root == 0) {
cout << size << "\n";
main_root = list_root[0];
} else
cout << size - 1 << "\n";
for (int i = 0; i < size; i++) {
a_arr[list_root[i]] = main_root;
}
for (int i = 1; i <= n; i++) {
cout << a_arr[i] << " ";
}
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
inline int mulmd(long long a, long long b) {
long long ret = (a * b) % 1000000007;
return (int)ret;
}
inline int power(long long x, long long y, int m) {
long long res = 1;
x = x % m;
while (y > 0) {
if (y & 1) {
res = mulmd(res, x);
}
y = y >> 1;
x = mulmd(x, x);
}
return (int)res;
}
inline int submd(long long a, long long b) {
long long ret = (a - b);
if (ret < 0) ret += 1000000007;
return (int)ret;
}
inline int addmd(long long a, long long b) {
long long ret = (a + b) % 1000000007;
return (int)ret;
}
inline int invPow(long long a) { return power(a, 1000000007 - 2, 1000000007); }
inline int divmd(long long a, long long b) {
long long ret = mulmd(a, invPow(b));
return (int)ret;
}
const int N = 4e5 + 5;
long long arr[N];
long long pref[N];
long long totalSum[N];
void solve() {
long long n, x;
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (i == 0) {
pref[i] = arr[i];
totalSum[i] = arr[i] * (arr[i] + 1) / 2;
} else {
pref[i] = pref[i - 1] + arr[i];
totalSum[i] = totalSum[i - 1] + arr[i] * (arr[i] + 1) / 2;
}
}
for (int i = n; i < 2 * n; i++) {
arr[i] = arr[i - n];
pref[i] = pref[i - 1] + arr[i];
totalSum[i] = totalSum[i - 1] + arr[i] * (arr[i] + 1) / 2;
}
long long ans = 0;
for (int i = 0; i < n; i++) {
int idx = lower_bound(pref, pref + 2 * n, pref[i] - arr[i] + x) - pref;
long long diff = pref[idx] - (pref[i] - arr[i] + x);
long long mxInc = min(diff, arr[i] - 1);
long long toSub = diff - mxInc;
ans = max(ans, totalSum[idx] - (totalSum[i] - (arr[i] * (arr[i] + 1) / 2)) -
mxInc * (mxInc + 1) / 2 -
((arr[idx] * (arr[idx] + 1) / 2 -
((arr[idx] - toSub) * (arr[idx] - toSub + 1) / 2))));
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class segTree {
public:
int val[100005];
int tree[4 * 100005];
segTree() { memset(tree, 0, sizeof tree); }
void initialize(int n, int s, int e) {
if (s == e) {
tree[n] = val[s];
return;
}
int mid = (s + e) >> 1, l = 2 * n, r = 2 * n + 1;
initialize(l, s, mid);
initialize(r, mid + 1, e);
tree[n] = max(tree[l], tree[r]);
}
int qry(int n, int s, int e, int qs, int qe) {
if (s > qe || e < qs) return INT_MIN;
if (s >= qs && e <= qe) return tree[n];
int mid = (s + e) >> 1, l = 2 * n, r = 2 * n + 1;
int m1 = qry(l, s, mid, qs, qe);
int m2 = qry(r, mid + 1, e, qs, qe);
return max(m1, m2);
}
} trees[5];
int sum(vector<int>& v) {
int ans = 0;
for (int i = 0; i < (int)v.size(); i++) ans += v[i];
return ans;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &trees[j].val[i]);
for (int i = 0; i < m; i++) trees[i].initialize(1, 0, n - 1);
vector<int> mx(m, 0), res(m, 0);
int r = 0, l = 0, ans = 0;
while (r < n) {
for (int i = 0; i < m; i++) mx[i] = trees[i].qry(1, 0, n - 1, l, r);
if (sum(mx) <= k) {
if (ans < r - l + 1) {
res = mx;
ans = r - l + 1;
}
r++;
} else
l++;
}
for (int i = 0; i < m; i++) {
if (i) printf(" ");
printf("%d", res[i]);
}
printf("\n");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 1e6 + 1;
const long long MAXN = 1e2 + 1;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
long long n, a[MXN];
bool used[MXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (!used[i]) {
used[i] = 1;
long long cnt = 1;
for (int j = i + 1; j <= n; j++) {
if (a[j] >= cnt && !used[j]) {
used[j] = 1;
cnt++;
}
}
ans++;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void testCase() {}
map<int, int> m;
int nextsame[10000];
int nextsmall[10000];
int prevsame[10000];
int prevsmall[10000];
int howmany[10000];
int dp[2001][2];
bool done[2001][2];
vector<int> lista[10000];
int prevstate[10000][2];
int prevdir[10000][2];
bool visited[10000];
int n, s;
int dist(int a, int b) { return min(min(abs(a - b), a + n - b), b + n - a); }
int distright(int a, int b) {
if (b >= a)
return b - a;
else
return n - (a - b);
}
int distleft(int a, int b) {
if (a >= b)
return a - b;
else
return n - (b - a);
}
int a[10000];
int solve(int ind, int k) {
if (done[ind][k]) return dp[ind][k];
if (k == 0 && a[ind] == 1) {
dp[ind][k] = dist(ind, s);
done[ind][k] = true;
return dist(ind, s);
}
int ans = 1e9;
if (k == 0) {
int ind2 = nextsmall[ind];
if (ans > distright(ind, ind2) + solve(ind2, 1)) {
ans = distright(ind, ind2) + solve(ind2, 1);
prevstate[ind][k] = ind2;
prevdir[ind][k] = 1;
}
ind2 = prevsmall[ind];
if (ans > distleft(ind, ind2) + solve(ind2, 1)) {
ans = distleft(ind, ind2) + solve(ind2, 1);
prevstate[ind][k] = ind2;
prevdir[ind][k] = 0;
}
} else {
if (howmany[a[ind]] == 1) {
ans = solve(ind, 0);
} else if (howmany[a[ind]] == 2) {
int ind2 = nextsame[ind];
ans = dist(ind, ind2) + solve(ind2, 0);
prevstate[ind][k] = ind2;
} else {
for (int ind2 : lista[a[ind]]) {
if (ind2 == ind) continue;
int x = nextsame[ind];
int hinta = distleft(ind, ind2) + 2 * distright(x, ind2);
if (ans > min(ans, hinta + solve(ind2, 0))) {
ans = min(ans, hinta + solve(ind2, 0));
prevstate[ind][k] = ind2;
prevdir[ind][k] = 3;
}
x = prevsame[ind];
hinta = distright(ind, ind2) + 2 * distleft(x, ind2);
if (ans > min(ans, hinta + solve(ind2, 0))) {
ans = min(ans, hinta + solve(ind2, 0));
prevstate[ind][k] = ind2;
prevdir[ind][k] = 2;
}
x = nextsame[ind2];
hinta = distright(ind, ind2) + 2 * distleft(ind, x);
if (ans > min(ans, hinta + solve(ind2, 0))) {
ans = min(ans, hinta + solve(ind2, 0));
prevstate[ind][k] = ind2;
prevdir[ind][k] = 1;
}
x = prevsame[ind2];
hinta = distleft(ind, ind2) + 2 * distright(ind, x);
if (ans > min(ans, hinta + solve(ind2, 0))) {
ans = min(ans, hinta + solve(ind2, 0));
prevstate[ind][k] = ind2;
prevdir[ind][k] = 0;
}
}
}
}
done[ind][k] = true;
dp[ind][k] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> s;
s--;
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> v;
for (int i = 0; i < n; i++) v.push_back(a[i]);
sort(v.begin(), v.end());
int ind = 1;
for (int x : v) {
if (m[x] == 0) {
m[x] = ind;
ind++;
}
}
for (int i = 0; i < n; i++) a[i] = m[a[i]];
for (int i = 0; i < n; i++) howmany[a[i]]++;
for (int i = 0; i < n; i++) {
if (howmany[a[i]] == 1) {
nextsame[i] = -1;
nextsmall[i] = -1;
for (int j = 1; j < n; j++) {
if (a[(i + j) % n] == a[i] - 1) {
nextsmall[i] = (i + j) % n;
break;
}
}
for (int j = 1; j < n; j++) {
if (a[(i - j + n) % n] == a[i] - 1) {
prevsmall[i] = (i - j + n) % n;
break;
}
}
} else if (a[i] == 1) {
nextsmall[i] = -1;
prevsmall[i] = -1;
for (int j = 1; j < n; j++) {
if (a[(i + j) % n] == a[i]) {
nextsame[i] = (i + j) % n;
break;
}
}
for (int j = 1; j < n; j++) {
if (a[(i - j + n) % n] == a[i]) {
prevsame[i] = (i - j + n) % n;
break;
}
}
} else {
for (int j = 1; j < n; j++) {
if (a[(i + j) % n] == a[i]) {
nextsame[i] = (i + j) % n;
break;
}
}
for (int j = 1; j < n; j++) {
if (a[(i + j) % n] == a[i] - 1) {
nextsmall[i] = (i + j) % n;
break;
}
}
for (int j = 1; j < n; j++) {
if (a[(i - j + n) % n] == a[i]) {
prevsame[i] = (i - j + n) % n;
break;
}
}
for (int j = 1; j < n; j++) {
if (a[(i - j + n) % n] == a[i] - 1) {
prevsmall[i] = (i - j + n) % n;
break;
}
}
}
}
for (int i = 0; i < n; i++) lista[a[i]].push_back(i);
ind--;
int ans = 1e9;
int index = 0;
for (int i = 0; i < n; i++) {
if (a[i] == ind && solve(i, 1) < ans) {
index = i;
ans = solve(i, 1);
}
}
cout << ans << "\n";
vector<int> stack;
while (a[index] > 0) {
if (howmany[a[index]] == 2) {
int uusind = prevstate[index][1];
if (distright(index, uusind) < distleft(index, uusind)) {
stack.push_back(distright(index, uusind));
} else {
stack.push_back(-distleft(index, uusind));
}
index = uusind;
} else if (howmany[a[index]] > 2) {
int uusind = prevstate[index][1];
if (prevdir[index][1] == 1) {
int cur = index;
while (prevsame[cur] != uusind) {
stack.push_back(-distleft(cur, prevsame[cur]));
cur = prevsame[cur];
}
while (nextsame[cur] != uusind) {
stack.push_back(distright(cur, nextsame[cur]));
cur = nextsame[cur];
}
stack.push_back(distright(cur, nextsame[cur]));
} else if (prevdir[index][1] == 0) {
int cur = index;
while (nextsame[cur] != uusind) {
stack.push_back(distright(cur, nextsame[cur]));
cur = nextsame[cur];
}
while (prevsame[cur] != uusind) {
stack.push_back(-distleft(cur, prevsame[cur]));
cur = prevsame[cur];
}
stack.push_back(-distleft(cur, prevsame[cur]));
} else if (prevdir[index][1] == 2) {
int cur = index;
while (nextsame[cur] != index) {
stack.push_back(distright(cur, nextsame[cur]));
cur = nextsame[cur];
}
if (cur != uusind) {
while (prevsame[cur] != uusind) {
stack.push_back(-distleft(cur, prevsame[cur]));
cur = prevsame[cur];
}
stack.push_back(-distleft(cur, prevsame[cur]));
}
} else {
int cur = index;
while (prevsame[cur] != index) {
stack.push_back(-distleft(cur, prevsame[cur]));
cur = prevsame[cur];
}
if (cur != uusind) {
while (nextsame[cur] != uusind) {
stack.push_back(distright(cur, nextsame[cur]));
cur = nextsame[cur];
}
stack.push_back(distright(cur, nextsame[cur]));
}
}
index = uusind;
}
if (a[index] > 1) {
int uusind = prevstate[index][0];
if (prevdir[index][0] == 1) {
stack.push_back(distright(index, nextsmall[index]));
index = nextsmall[index];
} else {
stack.push_back(-distleft(index, prevsmall[index]));
index = prevsmall[index];
}
} else {
if (distright(index, s) <= distleft(index, s)) {
stack.push_back(distright(index, s));
} else {
stack.push_back(-distleft(index, s));
}
break;
}
}
int kohta = s;
int lisa = 0;
while (stack.size() > 0) {
if (stack.back() > 0) {
kohta -= stack.back();
kohta += n;
kohta %= n;
if (!visited[kohta]) {
cout << -(stack.back() + lisa) << "\n";
visited[kohta] = true;
lisa = 0;
} else {
lisa += stack.back();
}
} else {
kohta += -stack.back();
kohta += n;
kohta %= n;
if (!visited[kohta]) {
cout << "+" << -(stack.back() - lisa) << "\n";
visited[kohta] = true;
lisa = 0;
} else {
lisa += -stack.back();
}
}
stack.pop_back();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int N = 500031;
int n;
struct circ {
int x;
int y;
int r;
};
struct pt {
double x;
double y;
};
circ c[N];
int used[N];
vector<int> comp;
int COMPS;
int ans;
vector<pt> all_ip;
vector<pt> IP;
bool equal(pt a, pt b) {
return (fabs(a.x - b.x) < 1e-9 && fabs(a.y - b.y) < 1e-9);
}
double get_dist(circ a, circ b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
bool do_intersect(circ a, circ b) {
if (a.r < b.r) swap(a, b);
return get_dist(a, b) < a.r + b.r + 1e-9 &&
get_dist(a, b) >= a.r - b.r - 1e-9;
}
void dfs(int v) {
comp.push_back(v);
used[v] = 1;
for (int i = 1; i <= n; i++) {
if (do_intersect(c[v], c[i]) == 1 && used[i] == 0) {
dfs(i);
}
}
}
struct line {
double a;
double b;
double c;
};
vector<pt> intersect(circ a, line l) {
vector<pt> res;
double x0 = -l.a * l.c / (l.a * l.a + l.b * l.b);
double sdkfaslhagaklsldk = -l.b * l.c / (l.a * l.a + l.b * l.b);
if (l.c * l.c > a.r * a.r * (l.a * l.a + l.b * l.b) + 1e-9) return res;
if (fabs(l.c * l.c - a.r * a.r * (l.a * l.a + l.b * l.b)) < 1e-9) {
pt temp;
temp.x = x0;
temp.y = sdkfaslhagaklsldk;
res.push_back(temp);
return res;
}
double d = a.r * a.r - l.c * l.c / (l.a * l.a + l.b * l.b);
double mult = sqrt(d / (l.a * l.a + l.b * l.b));
double ax, ay, bx, by;
ax = x0 + l.b * mult;
bx = x0 - l.b * mult;
ay = sdkfaslhagaklsldk - l.a * mult;
by = sdkfaslhagaklsldk + l.a * mult;
pt temp;
temp.x = ax;
temp.y = ay;
res.push_back(temp);
temp.x = bx;
temp.y = by;
res.push_back(temp);
return res;
}
vector<pt> intersect(circ a, circ b) {
b.x -= a.x;
b.y -= a.y;
line L;
L.a = -2 * b.x;
L.b = -2 * b.y;
L.c = (b.x * b.x + b.y * b.y + a.r * a.r - b.r * b.r);
vector<pt> solutions = intersect(a, L);
for (int i = 0; i < solutions.size(); i++) {
solutions[i].x += a.x;
solutions[i].y += a.y;
}
return solutions;
}
bool cmp(pt a, pt b) {
if (fabs(a.x - b.x) > 1e-9) return (a.x < b.x);
return a.y < b.y;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c[i].x >> c[i].y >> c[i].r;
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (c[i].x == c[j].x && c[i].y == c[j].y && c[i].r == c[j].r) used[j] = 1;
}
}
for (int i = 1; i <= n; i++) {
if (used[i]) continue;
comp.clear();
dfs(i);
COMPS++;
all_ip.clear();
int vertices = 0;
int edges = 0;
for (int j = 0; j < comp.size(); j++) {
IP.clear();
for (int q = 0; q < comp.size(); q++) {
if (j == q) continue;
vector<pt> V = intersect(c[comp[j]], c[comp[q]]);
for (int t = 0; t < V.size(); t++) {
IP.push_back(V[t]);
}
}
int cnt = 0;
sort(IP.begin(), IP.end(), cmp);
for (int q = 0; q < IP.size(); q++) {
if (q == 0 || !equal(IP[q], IP[q - 1])) ++cnt;
}
if (cnt > 0) {
edges += cnt;
}
for (int q = 0; q < IP.size(); q++) {
all_ip.push_back(IP[q]);
}
}
sort(all_ip.begin(), all_ip.end(), cmp);
for (int j = 0; j < all_ip.size(); j++) {
if (j == 0 || !equal(all_ip[j], all_ip[j - 1])) vertices++;
}
ans += -vertices + 2 + edges;
}
ans -= COMPS - 1;
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string A, B;
int dp[5005][5005];
void reset(int n, int m) {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
dp[i][j] = 0;
}
}
}
void solve() {
cin >> n >> m;
reset(n, m);
cin >> A;
cin >> B;
A = "_" + A;
B = "," + B;
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) - 1;
if (A[i] == B[j]) {
dp[i][j] = max(dp[i - 1][j - 1] + 2, dp[i][j]);
}
dp[i][j] = max(dp[i][j], 0);
ans = max(ans, dp[i][j]);
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
int test = 1;
while (test--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int n, k;
int working[300];
char ch;
char question[200005];
void init() {
for (int i = 0; i < 300; i++) working[i] = 0;
}
int main() {
cin >> n >> k;
scanf("%s", question);
init();
for (int i = 0; i < k; i++) {
cin >> ch;
working[ch]++;
}
int i = 0;
long long int res = 0;
while (i < n) {
long long int count = 0;
if (i < n && working[question[i]] != 0) {
while (i < n && working[question[i]] != 0) {
i++;
count++;
}
} else {
i++;
}
res += ((count) * (count + 1)) / 2;
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int* a = new int[n];
for (int i = 0; i < n; i++) cin >> a[i];
std::sort(a, a + n);
map<int, int> dif;
for (int i = 0; i < n - 1; i++) {
int y = a[i + 1] - a[i];
if (dif.find(y) == dif.end())
dif[y] = 1;
else
dif[y]++;
}
set<int> b;
if (dif.size() == 0) {
cout << -1;
return 0;
} else if (dif.size() == 1) {
int d = dif.begin()->first;
if (n == 2 && d % 2 == 0) {
b.insert(a[0] + d / 2);
b.insert(a[0] - d);
b.insert(a[1] + d);
} else {
b.insert(a[0] - d);
b.insert(a[n - 1] + d);
}
} else if (dif.size() == 2) {
int d1 = dif.begin()->first, d1_ = dif[d1];
int d2 = (++dif.begin())->first, d2_ = dif[d2];
if (d1_ == n - 2 && d2_ == 1 && d2 == 2 * d1) {
for (int i = 0; i < n - 1; i++) {
int y = a[i + 1] - a[i];
if (y == d2) {
b.insert((a[i + 1] + a[i]) / 2);
break;
}
}
}
}
cout << b.size() << endl;
for (set<int>::iterator it = b.begin(); it != b.end(); it++)
cout << *it << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int l1, r1, l2, r2;
cin >> l1 >> r1 >> l2 >> r2;
if (l1 == l2 && r1 == r2)
cout << l1 << " " << r1 << endl;
else if (l1 == l2)
cout << r1 << " " << r2 << endl;
else if (r1 == r2)
cout << l1 << " " << l2 << endl;
else
cout << l1 << " " << l2 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 510;
int n;
double h, f;
vector<pair<double, double> > A, B;
double ans;
void init() {
cin >> n >> h >> f;
for (int i = 1; i <= n; ++i) {
double l, r;
cin >> l >> r;
if (l >= 0)
A.push_back(make_pair(l, r));
else if (r <= 0)
B.push_back(make_pair(-r, -l));
else {
A.push_back(make_pair(0, r));
B.push_back(make_pair(0, -l));
}
ans += (r - l) * 2 * f / (f - h) * h * 2;
}
}
double calc(double px1, double px2) {
if (px1 > px2) swap(px1, px2);
double tx1 = px1 * (f + h) / (f - h);
double tx2 = px2 * (f + h) / (f - h);
if (tx1 <= px2) return (px1 + tx1) * h;
double h0 = (tx1 - px2) * h * 2 / (tx1 + tx2 - px1 - px2);
return (px1 + tx1) * h - (tx1 - px2) * h0 / 2;
}
double solve(vector<pair<double, double> > &A) {
double get = 0;
for (int i = 0; i < A.size(); ++i)
for (int j = 0; j < A.size(); ++j)
get += calc(A[i].first, A[j].first) + calc(A[i].second, A[j].second) -
calc(A[i].first, A[j].second) - calc(A[i].second, A[j].first);
return get;
}
int main() {
init();
printf("%.10lf\n", ans - solve(A) - solve(B));
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000000")
using namespace std;
const int MOD = 1000000007;
const int INF = 1000000007LL;
const long long INF2 = 1000000007LL * 1000000007LL;
const long double EPS = 1e-9;
const int SIZE = 200100;
mt19937 rng(time(0));
uniform_int_distribution<int> uid(-1000000000, 1000000000);
long long n, a[SIZE];
long long sumOdd[SIZE], sumLeft[SIZE], sumRight[SIZE];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; ++i) {
cin >> a[i];
}
for (int i = 1; i < n; ++i) {
sumOdd[i] = sumOdd[i - 1] + (a[i - 1] - !(a[i - 1] % 2));
sumLeft[i] = sumLeft[i - 1] + (a[i - 1] - (a[i - 1] % 2));
if (a[i - 1] == 1) sumLeft[i] = 0;
}
for (int i = n - 2; i >= 0; --i) {
sumRight[i] = sumRight[i + 1] + (a[i] - (a[i] % 2));
if (a[i] == 1) sumRight[i] = 0;
}
long long best = 0, ans = 0;
int l = 0;
for (int r = 0; r < n; ++r) {
if (sumLeft[r] - sumOdd[r] > best) {
best = sumLeft[r] - sumOdd[r];
l = r;
}
long long sumR = sumRight[r] + sumOdd[r];
ans = max(ans, sumR + best);
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m, i, j, k, p, q, o, l, s, t, z;
string a, b;
cin >> a >> b;
while (a.size() > b.size()) {
b += 'A';
}
while (a.size() < b.size()) {
a += 'A';
}
if (a == b) {
cout << -1 << "\n";
} else {
cout << a.size() << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
cout << n * 3 + 4 << endl;
vector<pair<long long int, long long int> > v;
v.push_back(make_pair(0, 0));
v.push_back(make_pair(0, 1));
for (long long int i = 1; i <= n; i++) {
long long int j = i - 1;
long long int cnt = 3;
while (cnt--) {
v.push_back(make_pair(i, j));
j++;
}
}
v.push_back(make_pair(n + 1, n));
v.push_back(make_pair(n + 1, n + 1));
for (long long int i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int v[27][27];
int main() {
ios_base::sync_with_stdio(false);
int sz, ans = 0, m, k;
string s, n;
bool ok = 0;
cin >> sz >> s >> n;
for (int i = 0; i < sz; ++i)
if (s[i] != n[i]) {
v[s[i] - 'a'][n[i] - 'a'] = i + 1;
if (v[n[i] - 'a'][s[i] - 'a']) {
ok = true;
m = v[s[i] - 'a'][n[i] - 'a'];
k = v[n[i] - 'a'][s[i] - 'a'];
}
++ans;
}
if (ok) {
cout << ans - 2 << endl << m << " " << k;
return 0;
}
for (int i = 0; i < 27; ++i)
for (int j = 0; j < 27; ++j)
if (v[i][j])
for (int o = 0; o < 27; ++o)
if (v[j][o]) {
cout << ans - 1 << endl << v[i][j] << " " << v[j][o];
return 0;
}
cout << ans << endl << "-1 -1";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
priority_queue<pair<int, int> > q;
struct Edge {
int y, nex, z, w;
} g[N];
int n, m, sz = 1, a[N], b[N], c[N], d[N], ans[N], fl, pos[N];
bool ch[N], p[N];
void Init(int x, int y, int z, int w) {
g[++sz] = (Edge){y, pos[x], z, w}, pos[x] = sz, d[x]++;
}
int main() {
scanf("%d%d", &m, &n);
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i]);
int x;
for (int j = 1; j <= a[i]; j++) {
scanf("%d", &x);
if (x < 0) {
if (c[-x])
p[c[-x]] = p[i] = 1;
else
c[-x] = i;
} else {
if (b[x])
p[b[x]] = p[i] = 1, ans[x] = 1;
else
b[x] = i;
}
}
}
for (int i = 1; i <= n; i++) {
if (c[i] && b[i]) {
Init(c[i], b[i], i, 0), Init(b[i], c[i], i, 1);
} else {
p[b[i] + c[i]] = 1;
if (b[i]) ans[i] = 1;
}
}
for (int i = 1; i <= m; i++) q.push(make_pair(-d[i], i));
while (!q.empty()) {
int x = (q.top()).second;
q.pop();
if (p[x]) continue;
if (!d[x]) {
fl = 1;
break;
}
p[x] = 1;
for (int i = pos[x]; i; i = g[i].nex)
if (!ch[i]) {
ch[i ^ 1] = ch[i] = 1;
int y = g[i].y;
d[y]--, q.push(make_pair(-d[y], y));
ans[g[i].z] = g[i].w;
break;
}
}
if (fl) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 7010, M = 200010, MAX = 200000, TOT = 1000010;
struct data {
int t, l, r, x;
} dat[N];
int n, m, lg[M], rec[N], cnt, tot, l[N], r[N];
bool vis[TOT];
void prework() {
lg[1] = 1;
for (int i = 2, j = 1; i <= MAX; ++i) {
lg[i] = lg[i - 1];
if (i == (1 << j)) ++lg[i], ++j;
}
}
int solve(int t, int b) {
int ans = 0, s;
l[t] = b - 1, r[t] = b;
for (int i = t + 1; i <= n; ++i) {
l[i] = l[i - 1] + lg[l[i - 1]];
r[i] = r[i - 1] + lg[r[i - 1]];
}
for (int i = 1; i <= cnt; ++i)
if (dat[i].t >= t) {
s = dat[i].t;
if (((dat[i].l) > (l[s]) && (dat[i].l) <= (r[s])) ||
((dat[i].r) > (l[s]) && (dat[i].r) <= (r[s])) ||
(dat[i].l <= l[s] && dat[i].r > r[s])) {
if (!vis[dat[i].x]) ++ans, rec[++tot] = dat[i].x;
vis[dat[i].x] = 1;
}
}
while (tot) {
vis[rec[tot--]] = 0;
}
return ans;
}
int main() {
int tp, a, b, c, d;
scanf("%d%d", &n, &m);
prework();
for (int i = 1; i <= m; ++i) {
scanf("%d", &tp);
if (tp & 1) {
scanf("%d%d%d%d", &a, &b, &c, &d);
dat[++cnt] = (data){a, b, c, d};
} else {
scanf("%d%d", &a, &b);
printf("%d\n", solve(a, b));
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, totAll = 0, tot = 0;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
totAll += a[i];
}
tot = a[0];
vector<int> ans;
for (int i = 1; i < n; i++) {
if (a[0] >= 2 * a[i]) {
tot += a[i];
ans.push_back(i + 1);
}
}
if (2 * tot > totAll) {
cout << ans.size() + 1 << endl;
cout << 1;
for (auto it : ans) cout << " " << it;
cout << endl;
} else {
cout << 0 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, n, m, count = 1;
cin >> n >> x;
for (int i = 0; i < n - 1; i++) {
m = x;
cin >> x;
if (x != m) count += 1;
}
cout << count << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, l = 1;
cin >> n;
l = n;
m = n;
while (n > 0) {
if (m % n == 0 && l % n == 0) {
cout << n << " ";
l = n;
}
n--;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int seq[200], vis[200], perm[200];
vector<int> used;
vector<int> nused;
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> seq[i];
}
int dist;
for (int i = 2; i <= m; i++) {
if (seq[i] > seq[i - 1]) {
dist = seq[i] - seq[i - 1];
} else
dist = n - (seq[i - 1] - seq[i]);
if (vis[seq[i - 1]]) {
if (perm[seq[i - 1]] != dist) {
cout << -1 << endl;
return 0;
}
} else {
used.push_back(dist);
vis[seq[i - 1]] = 1;
perm[seq[i - 1]] = dist;
}
}
for (int i = 1; i <= n; i++) {
bool found = false;
for (int j = 0; j < used.size(); j++) {
if (used[j] == i) {
found = true;
break;
}
}
if (!found) nused.push_back(i);
}
int index = 0;
for (int i = 1; i <= n; i++) {
if (perm[i] == 0) {
perm[i] = nused[index];
index++;
}
}
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; i++) {
vis[perm[i]]++;
}
for (int i = 1; i <= n; i++) {
if (vis[i] > 1) {
cout << -1 << endl;
return 0;
}
}
for (int i = 1; i <= n; i++) cout << perm[i] << ' ';
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int ceilElement(int a[], int start, int end, int key) {
while (end - start > 1) {
int mid = start + (end - start) / 2;
if (a[mid] >= key) {
end = mid;
} else {
start = mid;
}
}
return end;
}
int longestIncreasingSubsequence(int input[], int size) {
if (!size) return 0;
int a[size];
int length = 1;
a[0] = input[0];
for (int i = 1; i < size; i++) {
if (input[i] < a[0]) {
a[0] = input[i];
} else if (input[i] > a[length - 1]) {
a[length++] = input[i];
} else
a[ceilElement(a, -1, length - 1, input[i])] = input[i];
}
return length;
}
int main() {
int n;
scanf("%d", &n);
int a[n];
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int size = sizeof(a) / sizeof(a[0]);
printf("%d", longestIncreasingSubsequence(a, size));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int maxx = 3e5;
const int inf = 0x3f3f3f3f;
const long long linf = 1e18;
const long long mod = 1e9 + 9;
map<long long, int> mp;
long long n, a[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (mp.find(a[i]) == mp.end()) mp.insert(make_pair(a[i], 1));
if (mp.find(a[i] - 1) != mp.end()) mp[a[i]] = mp[a[i] - 1] + 1;
}
long long l, r = 0;
for (auto i : mp) {
if (i.second > r) {
r = i.second;
l = i.first;
}
}
l = l - r + 1;
cout << r << endl;
for (int i = 1; i <= n; i++) {
if (a[i] == l) {
cout << i << " ";
l++;
}
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pil = pair<int, ll>;
using pll = pair<ll, ll>;
template <typename T>
using vec = vector<T>;
using vi = vec<int>;
using vl = vec<ll>;
template <typename T>
using que = queue<T>;
template <typename T>
using deq = deque<T>;
template <typename T>
T id(T b) {
return b;
};
template <typename T>
void chmax(T &x, T y) {
if (x < y) x = y;
}
template <typename T>
void chmin(T &x, T y) {
if (x > y) x = y;
}
template <typename S, typename K>
bool contains(S &s, K k) {
return s.find(k) != s.end();
}
void fastio() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
}
constexpr ll TEN(int n) {
if (n == 0)
return 1LL;
else
return 10LL * TEN(n - 1);
}
const int MAX_N = 5000;
int n;
int p0b[MAX_N];
int pb0[MAX_N];
int ask(int i, int j) {
cout << "? " << i << " " << j << endl;
int ans;
cin >> ans;
if (ans == -1) exit(0);
return ans;
}
int main() {
fastio();
cin >> n;
for (int i = 0; i < int(n); i++) {
pb0[i] = ask(i, 0);
}
for (int i = 0; i < int(n); i++) {
p0b[i] = ask(0, i);
}
int ans = 0;
vi example;
for (int i = 0; i < int(n); i++) {
vi b;
bool ok = true;
for (int j = 0; j < int(n); j++) {
int pb = p0b[j];
b.push_back(pb ^ i);
if (b.back() >= n) {
ok = false;
break;
}
}
vi x = b;
sort((x).begin(), (x).end());
auto end = unique((x).begin(), (x).end());
x.erase(end, x.end());
ok &= x.size() == n;
if (!ok) continue;
vi p(n, 0);
for (int j = 0; j < int(n); j++) {
p[b[j]] = j;
}
for (int j = 0; j < int(n); j++) {
ok &= (p[j] ^ b[0]) == pb0[j];
}
if (ok) {
ans++;
example = p;
}
}
cout << "!" << endl;
cout << ans << endl;
for (int x : example) {
cout << x << " " << flush;
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = ~0U >> 1;
const long long INF = ~0ULL >> 1;
int cnt;
int b[2000000], p[2000000];
map<long long, int> flag;
map<long long, long long> dp[20000];
long long N, fac[20000];
int M;
inline long long fastmul(long long a, long long b, long long p) {
if (p <= 1000000000)
return a * b % p;
else {
long long d = (long long)((long double)a * b / p + 0.5);
long long ret = (a * b - d * p) % p;
if (ret < 0) ret += p;
return ret;
}
}
long long Pow(long long base, long long n, long long mo) {
if (n == 0) return 1;
if (n == 1) return base;
long long tmp = Pow(base, n >> 1, mo);
tmp = fastmul(tmp, tmp, mo);
if (n & 1) tmp = fastmul(tmp, base, mo);
return tmp;
}
bool check_prime(long long p) {
int times = 20;
if (p < 2) return 0;
if (p != 2 && p % 2 == 0) return 0;
if (p == 2) return 1;
long long s = p - 1LL;
while (s % 2LL == 0) s >>= 1LL;
while (times--) {
long long a = rand() % (p - 1) + 1;
long long tmp = s;
long long mod = Pow(a, tmp, p);
if (mod == 1 || mod == p - 1) continue;
while (tmp != p - 1LL && mod != p - 1LL)
mod = fastmul(mod, mod, p), tmp <<= 1LL;
if (mod != p - 1) return 0;
}
return 1;
}
int main() {
memset(b, 1, sizeof(b));
for (int i = (2); i <= (1000000); ++i) {
if (b[i]) p[++cnt] = i;
for (int j = 1; j <= cnt && i * p[j] <= 1000000; ++j) {
b[i * p[j]] = 0;
if (i % p[j] == 0) break;
}
}
for (int i = (1); i <= (cnt); ++i) {
for (long long j = p[i]; j <= 1000000000000LL; j *= p[i])
flag[j + 1] = p[i];
}
scanf("%lld", &N);
for (long long j = 1; j * j <= N; ++j)
if (N % j == 0) {
fac[++M] = j;
if (j * j != N) fac[++M] = N / j;
}
sort(fac + 1, fac + M + 1);
dp[1][0] = 1;
for (int i = (2); i <= (M); ++i) {
for (int j = (1); j <= (i - 1); ++j)
if (fac[i] % fac[j] == 0)
if (flag[fac[i] / fac[j]] || check_prime(fac[i] / fac[j] - 1)) {
long long cur = flag[fac[i] / fac[j]];
if (!cur) cur = fac[i] / fac[j] - 1;
for (map<long long, long long>::iterator itr = dp[j].begin();
itr != dp[j].end(); ++itr)
if (itr->first < cur) dp[i][cur] += itr->second;
}
}
long long ans = 0;
for (map<long long, long long>::iterator itr = dp[M].begin();
itr != dp[M].end(); ++itr)
ans += itr->second;
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
string s;
cin >> s;
int ans = 0;
for (int i = 0; i < n; i++) {
int j = i;
while (j < n && s[j] == s[i]) {
j++;
}
string q = "RGB";
q.erase(q.find(s[i]), 1);
if (j < n) {
q.erase(q.find(s[j]), 1);
}
for (int k = i + 1; k < j; k += 2) {
ans++;
s[k] = q[0];
}
i = j - 1;
}
cout << ans << endl;
cout << s << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string a[100001];
int ai[100001];
bool replace(int n, int k, int pos) {
int cnt = 0, i = pos;
while (i < n and a[i] == "?") {
cnt++;
a[i] = "x";
i += k;
}
int l, u;
pos >= k ? l = ai[pos - k] + 1 : l = -2000000000;
i < n ? u = ai[i] - cnt : u = 2000000000;
if (u < l) return false;
int m;
if (l >= -cnt / 2) {
m = l;
} else {
if (u <= -cnt / 2) {
m = u;
} else {
m = -cnt / 2;
}
}
for (int i = 0; i < cnt; i++) ai[pos + i * k] = m + i;
return true;
}
bool solve(int n, int k) {
for (int i = 0; i < n; i++) {
if (a[i] == "x") continue;
if (a[i] == "?") {
if (!replace(n, k, i)) return false;
}
}
for (int i = 0; i < n - k; i++) {
if (ai[i] >= ai[i + k]) return false;
}
return true;
}
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] != "?") ai[i] = atoi(a[i].c_str());
}
if (solve(n, k)) {
for (int i = 0; i < n; i++) cout << ai[i] << " ";
} else {
cout << "Incorrect sequence";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
const int INF = 2000000000;
int x[maxn], w[maxn];
int N;
struct node {
int l, r;
bool operator<(const node &a) const {
if (l == a.l) return r < a.r;
return l < a.l;
}
} a[2 * maxn];
int main() {
while (scanf("%d", &N) != EOF) {
int cnt = 0;
for (int i = 1; i <= N; i++) {
scanf("%d%d", &x[i], &w[i]);
a[i].l = x[i] - w[i];
a[i].r = x[i] + w[i];
}
sort(a + 1, a + N + 1);
int ans = 0;
node tmp;
tmp.l = tmp.r = -INF;
for (int i = 1; i <= N; i++) {
if (a[i].l >= tmp.r) {
ans++;
tmp = a[i];
} else if (tmp.r > a[i].r)
tmp = a[i];
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Tt {
int time, pro, num;
};
Tt ts[1000 + 123];
int main() {
memset(ts, -1, sizeof(ts));
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int l, r, t, c;
scanf("%d%d%d%d", &l, &r, &t, &c);
for (int j = l; j <= r; ++j) {
if (ts[j].time == -1 || ts[j].time > t) {
ts[j].time = t;
ts[j].pro = c;
}
}
}
int summ = 0;
for (int i = 1; i <= n; ++i)
if (ts[i].time != -1) summ += ts[i].pro;
printf("%d\n", summ);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 101111, inf = 1011111111;
const int max_x = 55;
int n, A[max_x], B[max_x], q[max_x];
long long pw[max_x];
bool check(int cnt) {
int mn = cnt;
for (int i = 0; i < max_x; ++i) {
mn = min(mn, A[i]);
q[i] = mn;
}
int f = 0;
for (int i = max_x - 1; i >= 0; --i) {
int can = q[i] - f;
if (can < B[i]) {
return false;
}
f += B[i];
can = q[i] - f;
if (q[i] + can < A[i]) {
return false;
}
f += A[i] - q[i];
}
return true;
}
int main() {
scanf("%d", &n);
pw[0] = 1;
for (int i = 1; i < max_x; ++i) {
pw[i] = pw[i - 1] * 2;
}
for (int i = 0; i < n; ++i) {
long long x;
scanf("%I64d", &x);
int f = 0;
for (int j = 0; j < max_x; ++j) {
if (pw[j] == x) {
f = 1;
++A[j];
break;
}
}
if (f == 0) {
for (int j = 0; j + 1 < max_x; ++j) {
if (pw[j] < x && x < pw[j + 1]) {
++B[j];
break;
}
}
}
}
int f = 0;
for (int i = 1; i <= A[0]; ++i) {
if (check(i)) {
printf("%d ", i);
f = 1;
}
}
if (f == 0) {
printf("-1\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, size_t N>
int SIZE(const T (&t)[N]) {
return N;
}
template <typename T>
int SIZE(const T &t) {
return t.size();
}
string to_string(const string s, int x1 = 0, int x2 = 1e9) {
return '"' + ((x1 < s.size()) ? s.substr(x1, x2 - x1 + 1) : "") + '"';
}
string to_string(const char *s) { return to_string((string)s); }
string to_string(const bool b) { return (b ? "true" : "false"); }
string to_string(const char c) { return string({c}); }
template <size_t N>
string to_string(const bitset<N> &b, int x1 = 0, int x2 = 1e9) {
string t = "";
for (int __iii__ = min(x1, SIZE(b)), __jjj__ = min(x2, SIZE(b) - 1);
__iii__ <= __jjj__; ++__iii__) {
t += b[__iii__] + '0';
}
return '"' + t + '"';
}
template <typename A, typename... C>
string to_string(const A(&v), int x1 = 0, int x2 = 1e9, C... coords);
int l_v_l_v_l = 0, t_a_b_s = 0;
template <typename A, typename B>
string to_string(const pair<A, B> &p) {
l_v_l_v_l++;
string res = "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
l_v_l_v_l--;
return res;
}
template <typename A, typename... C>
string to_string(const A(&v), int x1, int x2, C... coords) {
int rnk = rank<A>::value;
string tab(t_a_b_s, ' ');
string res = "";
bool first = true;
if (l_v_l_v_l == 0) res += '\n';
res += tab + "[";
x1 = min(x1, SIZE(v)), x2 = min(x2, SIZE(v));
auto l = begin(v);
advance(l, x1);
auto r = l;
advance(r, (x2 - x1) + (x2 < SIZE(v)));
for (auto e = l; e != r; e = next(e)) {
if (!first) {
res += ", ";
}
first = false;
l_v_l_v_l++;
if (e != l) {
if (rnk > 1) {
res += '\n';
t_a_b_s = l_v_l_v_l;
};
} else {
t_a_b_s = 0;
}
res += to_string(*e, coords...);
l_v_l_v_l--;
}
res += "]";
if (l_v_l_v_l == 0) res += '\n';
return res;
}
void dbgm() { ; }
template <typename Heads, typename... Tails>
void dbgm(Heads H, Tails... T) {
cout << to_string(H) << " | ";
dbgm(T...);
}
const long long INFFLOW = 1e18;
const long long INFCOST = 1e18;
struct MCF {
int n;
vector<long long> prio, pot;
vector<long long> curflow;
vector<int> prevedge, prevnode;
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
q;
struct edge {
int to, rev;
long long f, cap;
long long cost;
};
vector<vector<edge>> g;
MCF(int n)
: n(n), prio(n), curflow(n), prevedge(n), prevnode(n), pot(n), g(n) {}
void add_edge(int s, int t, long long cap, long long cost) {
g[s].push_back((edge){t, ((int)g[t].size()), 0, cap, cost});
g[t].push_back((edge){s, ((int)g[s].size()) - 1, 0, 0, -cost});
}
pair<long long, long long> get_flow(int s, int t) {
long long flow = 0;
long long flowcost = 0;
while (1) {
q.push({0, s});
fill(prio.begin(), prio.end(), INFCOST);
prio[s] = 0;
curflow[s] = INFFLOW;
while (!q.empty()) {
auto cur = q.top();
long long d = cur.first;
int u = cur.second;
q.pop();
if (d != prio[u]) continue;
for (int i = 0; i < ((int)g[u].size()); ++i) {
edge &e = g[u][i];
int v = e.to;
if (e.cap <= e.f) continue;
long long nprio = prio[u] + e.cost + pot[u] - pot[v];
if (prio[v] > nprio) {
prio[v] = nprio;
q.push({nprio, v});
prevnode[v] = u;
prevedge[v] = i;
curflow[v] = min(curflow[u], e.cap - e.f);
}
}
}
if (prio[t] == INFCOST) break;
for (int i = 0; i < n; i++) pot[i] += prio[i];
long long df = min(curflow[t], INFFLOW - flow);
flow += df;
for (int v = t; v != s; v = prevnode[v]) {
edge &e = g[prevnode[v]][prevedge[v]];
e.f += df;
g[v][e.rev].f -= df;
flowcost += df * e.cost;
}
}
return {flow, flowcost};
}
};
int main() {
int n, m;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int N = 2 * n;
MCF mcf(N + 3);
mcf.add_edge(N, N + 1, m, 0);
mcf.add_edge(N + 1, N + 2, m, 0);
for (int i = 0; i < n; i++) {
int me = 2 * i;
int other = me + 1;
mcf.add_edge(N + 1, me, 1, __builtin_popcount(a[i]));
mcf.add_edge(me, other, 1, -1e9);
mcf.add_edge(other, N + 2, 1, 0);
for (int j = i + 1; j < n; j++) {
mcf.add_edge(other, 2 * j, 1,
a[i] == a[j] ? 0 : __builtin_popcount(a[j]));
}
}
mcf.get_flow(N, N + 2);
long long res = 0;
int x = 0;
bool done[n];
memset(done, 0, sizeof(done));
int printedBy[n];
memset(printedBy, -1, sizeof(printedBy));
for (auto &e : mcf.g[N + 1])
if (e.cap && e.f) {
done[e.to / 2] = 1;
printedBy[e.to / 2] = x++;
res += e.cost;
}
for (int i = 0; i < n; i++)
if (!done[i]) {
for (auto &e : mcf.g[2 * i])
if (!e.cap && e.f) {
int parent = e.to / 2;
assert(printedBy[parent] != -1);
printedBy[i] = printedBy[parent];
res -= e.cost;
}
}
int currentVal[m];
memset(currentVal, -1, sizeof(currentVal));
vector<string> program;
for (int i = 0; i < n; i++) {
string x = string(1, printedBy[i] + 'a');
if (currentVal[printedBy[i]] != a[i]) {
program.push_back(x + "=" + to_string(a[i]));
}
program.push_back("print(" + x + ")");
currentVal[printedBy[i]] = a[i];
}
cout << ((int)program.size()) << " " << res << '\n';
for (auto x : program) cout << x << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 9;
const int inf = (int)1e9;
bool cmp(int v1, int v2) { return v1 > v2; }
int main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> tmp;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end(), cmp);
a.push_back(-1);
vector<int> reb;
for (int i = 0; i < n; i++) {
if (a[i] == a[i + 1]) {
reb.push_back(a[i]);
i++;
} else {
a[i]--;
if (a[i] == a[i + 1]) {
reb.push_back(a[i]);
i++;
}
}
}
long long ans = 0;
sort(reb.begin(), reb.end(), cmp);
reb.push_back(0);
for (int i = 0; i < (int)reb.size() - 1; i += 2)
ans += (long long)reb[i] * reb[i + 1];
printf("%I64d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
auto clk = clock();
const int dx[] = {0, 0, -1, 1}, dy[] = {-1, 1, 0, 0};
const int dx8[] = {-1, -1, -1, 0, 1, 1, 1, 0},
dy8[] = {-1, 0, 1, 1, 1, 0, -1, -1};
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long MAXN = 100010;
long long Gcd(long long a, long long b) {
if (a % b == 0) return b;
return Gcd(b, a % b);
}
long long Max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long Min(long long a, long long b) {
if (a < b) return a;
return b;
}
void printvector(std::vector<long long> v) {
for (int i = 0; i < v.size(); ++i) {
cout << v[i] << " ";
}
cout << "" << endl;
}
void printarray(long long a[], long long n) {
for (long long i = 0; i < n; ++i) {
cout << a[i] << " ";
}
cout << "" << endl;
}
long long findlcm(vector<long long> arr, long long n) {
long long ans = arr[0];
for (int i = 1; i < n; i++) ans = (((arr[i] * ans)) / (Gcd(arr[i], ans)));
return ans;
}
long long power(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 lowerbound(long long k, vector<long long> v) {
long long l = 0;
long long size = v.size();
long long r = size - 1;
long long mid;
while (l <= r) {
mid = (l + r) / 2;
if (v[mid] < k)
l = mid + 1;
else {
r = mid - 1;
}
}
return l;
}
long long upperbound(long long k, vector<long long> v) {
long long l = 0;
long long size = v.size();
long long r = size - 1;
long long mid;
while (l <= r) {
mid = (l + r) / 2;
if (v[mid] > k)
r = mid - 1;
else {
l = mid + 1;
}
}
return l;
}
long long spf[MAXN];
void sieve() {
spf[1] = 1;
for (int i = 2; i < MAXN; i++) spf[i] = i;
for (int i = 4; i < MAXN; i += 2) spf[i] = 2;
for (int i = 3; i * i < MAXN; i++) {
if (spf[i] == i) {
for (int j = i * i; j < MAXN; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
long long n, m;
vector<long long> shortPath(vector<pair<long long, long long>> v[],
long long src, long long V = 0) {
set<pair<long long, long long>> setds;
long long sizee = V;
long long IN = LLONG_MAX;
vector<long long> dist(sizee, IN);
vector<bool> vis(sizee, false);
setds.insert(make_pair(0, src));
dist[src] = 0;
while (!setds.empty()) {
pair<long long, long long> tmp = *(setds.begin());
setds.erase(setds.begin());
long long u = tmp.second;
if (vis[u]) continue;
vis[u] = true;
vector<pair<long long, long long>>::iterator i;
for (auto i = v[u].begin(); i != v[u].end(); ++i) {
long long v = (*i).first;
long long weight = (*i).second;
if (dist[v] > dist[u] + weight) {
if (dist[v] != LLONG_MAX)
setds.erase(setds.find(make_pair(dist[v], v)));
dist[v] = dist[u] + weight;
setds.insert(make_pair(dist[v], v));
}
}
}
return dist;
}
long long root(long long a[], long long r) {
if (a[r] == r) {
return r;
} else {
long long x = root(a, a[r]);
a[r] = x;
return x;
}
}
void unio(long long a[], long long size[], long long x, long long y) {
x = root(a, x);
y = root(a, y);
if (x == y) {
return;
}
if (size[x] >= size[y]) {
a[y] = x;
size[x] += size[y];
} else {
a[x] = y;
size[y] += size[x];
}
}
void neuer(long long txt) {
cin >> m >> n;
long double nn = n;
long double mm = m;
long double pr = 0;
long double ps = 0;
for (long long i = 1; i <= m - 1; i++) {
long double ii = i;
long double po = ii / mm;
long double oi = pow(po, nn);
ps = (ps + oi);
}
long double x = (mm);
x = (x - ps);
cout << setprecision(10) << x << endl;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long x68 = 1;
for (long long vi = 1; vi <= x68; vi++) {
neuer(vi);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int64_t N, M;
vector<int64_t> Edge[300007];
bool Visit[300007];
bool InStk[300007];
int64_t Low[300007], I;
int64_t Ind[300007];
int costs[300007];
stack<int64_t> Stk;
int64_t mincost;
int64_t possib;
void SCC(int64_t u) {
Visit[u] = true;
InStk[u] = true;
Ind[u] = ++I;
Low[u] = I;
Stk.push(u);
int64_t i;
for (i = 0; i < Edge[u].size(); i++) {
int64_t v = Edge[u][i];
if (!Visit[v]) {
SCC(v);
Low[u] = min(Low[u], Low[v]);
} else if (InStk[v]) {
Low[u] = min(Low[u], Ind[v]);
}
}
if (Low[u] != Ind[u]) return;
int64_t minc = 1000000000;
int64_t mintime = 0;
while (Stk.top() != u) {
int64_t v = Stk.top();
Stk.pop();
InStk[v] = false;
if (costs[v] < minc) {
minc = costs[v];
mintime = 1;
} else if (costs[v] == minc) {
mintime++;
}
}
if (costs[u] < minc) {
minc = costs[u];
mintime = 1;
} else if (costs[u] == minc) {
mintime++;
}
mincost += minc;
possib = (possib * mintime) % 1000000007;
Stk.pop();
InStk[u] = false;
}
int main(void) {
int64_t i, j, u, v, Icase, k = 0;
mincost = 0;
possib = 1;
cin >> N;
for (i = 0; i < N; i++) {
cin >> costs[i + 1];
}
cin >> M;
for (i = 1; i <= M; i++) {
cin >> u >> v;
Edge[u].push_back(v);
}
for (i = 1; i <= N; i++) {
if (Visit[i]) continue;
SCC(i);
}
cout << mincost << " " << possib;
return 0;
}
| 4 |
#include <iostream>
#include <stdio.h>
#include<queue>
#include <set>
#include<map>
#include<cstring>
using namespace std;
#define ll long long
#define speed(x) ios::sync_with_stdio(false), cin.tie(x), cout.tie(x)
#define bug(x) cout << #x << " == " << x << '\n';
const ll int MAX_N = 1e6 + 5;
///#define ls p * 2
///#define rs p * 2 + 1
///#define md (l + r) / 2
typedef pair<int, int> p;
typedef pair<p, int> pp;
ll gcd(ll x,ll y)
{
if(x==0||y==0)return 1;
else if(x%y==0)return y;
else return gcd(y,x%y);
}
inline ll lcm(ll x, ll y)
{
return x*y/gcd(x,y);
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
ll n;
scanf("%lld",&n);
ll sum=(ll)2*n;
sum%=(ll)(1e9+7);
///bug(sum);
ll cs=(ll)1;
for(ll i=2;i<=n;i++)
{
cs=lcm(cs,i);
///bug(cs);
if(cs>n)break;
sum+=(n/cs);
sum%=(ll)(1e9+7);
///bug(sum);
}
printf("%lld\n",sum);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long int t, i, j, even1, even2, odd1, odd2, ans, m, n, p[100000],
q[100000];
cin >> t;
while (t--) {
even1 = even2 = odd1 = odd2 = 0;
cin >> n;
for (j = 0; j < n; j++) {
cin >> p[j];
if (p[j] % 2)
odd1++;
else
even1++;
}
cin >> m;
for (j = 0; j < m; j++) {
cin >> q[j];
if (q[j] % 2)
odd2++;
else
even2++;
}
ans = even1 * even2 + odd1 * odd2;
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using LL = long long;
const int N = 5000 + 5;
int dfn[N], low[N], belong[N], stack[N], instack[N], tim, top, tot, n, m;
std::vector<int> edges[N], redges[N];
void tarjan(int u) {
dfn[u] = low[u] = ++tim;
stack[top++] = u;
instack[u] = 1;
for (int v : edges[u]) {
if (!dfn[v]) {
tarjan(v);
low[u] = std::min(low[u], low[v]);
} else if (instack[v]) {
low[u] = std::min(low[u], dfn[v]);
}
}
if (low[u] == dfn[u]) {
while (true) {
int v = stack[--top];
instack[v] = 0;
belong[v] = tot;
if (v == u) break;
}
tot++;
}
}
void scc() {
top = tim = tot = 0;
memset(dfn, 0, sizeof(dfn));
memset(instack, 0, sizeof(instack));
for (int i = 0; i < n; i++)
if (!dfn[i]) tarjan(i);
}
int solve(int source) {
if (edges[source].empty()) return 0;
std::queue<int> que;
std::vector<int> dis(n, -1);
dis[source] = 0;
que.push(source);
while (!que.empty()) {
int u = que.front();
que.pop();
for (int v : redges[u]) {
if (dis[v] == -1) {
dis[v] = dis[u] + 1;
que.push(v);
}
}
}
int ret = n + 1;
for (int v : edges[source]) {
ret = std::min(ret, dis[v] + 1);
}
return ret;
}
int work() {
scc();
int cycle = 0, cnt = 0;
for (int i = 0; i < n; ++i) {
bool flag = true;
for (int j = 0; j < i; ++j) {
if (belong[i] == belong[j]) {
flag = false;
break;
}
}
if (flag) {
int best = n + 1;
for (int j = i; j < n; ++j) {
if (belong[j] == belong[i]) {
best = std::min(best, solve(j));
}
}
cycle += best;
if (best) {
cnt++;
}
}
}
return 999 * cycle + cnt + n - cycle;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
edges[a].push_back(b);
redges[b].push_back(a);
}
printf("%d\n", work());
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
pair<long long int, long long int> a[100001];
pair<long long int, long long int> ans[200001];
int main() {
long long int n, x;
long long int m0, m1;
cin >> n >> x >> m0 >> m1;
for (int j = 0; j < n; j++) cin >> a[j].first >> a[j].second;
ans[0].first = m0;
ans[0].second = m1;
for (int j = 1; j < 2 * n; j++) {
int ind = (j - 1) % n;
ans[j].first = 2 * a[ind].first - ans[j - 1].first;
ans[j].second = 2 * a[ind].second - ans[j - 1].second;
}
x = x % (2 * n);
cout << ans[x].first << " " << ans[x].second << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T &get(T &n) {
cin >> n;
return n;
}
const long long hell = 1000000007;
const long long INF = (long long)hell * hell;
const int MAXN = 502;
const int MAXG = 20;
const int MAXD = 11;
int dp[MAXN][MAXN];
int main() {
if (!0) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int N, K, i, j, ans;
long long res = 0;
cin >> N >> K;
vector<int> A;
for (i = 1; i < N * N + 1; i++) A.push_back(i);
ans = N * N;
for (i = 1; i <= N; i++) {
for (j = N; j >= K; --j) {
if (j == K) res += ans;
dp[i][j] = ans--;
}
}
for (i = 1; i <= N; ++i) {
for (j = K - 1; j >= 1; --j) {
dp[i][j] = ans--;
}
}
cout << res << "\n";
for (i = 1; i <= N; ++i) {
for (j = 1; j <= N; ++j) {
cout << dp[i][j] << " ";
}
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> gr[201010];
vector<int> trace;
vector<int> dis;
int bfs(int u) {
trace.assign(n + 1, -1);
dis.assign(n + 1, -1);
trace[u] = u;
dis[u] = 0;
queue<int> qu;
for (qu.push(u); qu.size(); qu.pop()) {
u = qu.front();
for (auto v : gr[u]) {
if (trace[v] != -1) continue;
trace[v] = u;
dis[v] = dis[u] + 1;
qu.push(v);
}
}
return u;
}
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = -1; ++i < n - 1;) {
int u, v;
cin >> u >> v;
gr[u].push_back(v);
gr[v].push_back(u);
}
int diameter_end1 = bfs(1);
int diameter_end2 = bfs(diameter_end1);
vector<int> dis1 = move(dis);
bfs(diameter_end2);
vector<int> dis2 = move(dis);
vector<pair<int, int>> ans;
vector<bool> vis(n + 1);
queue<int> qu;
long long total_cost = 0;
for (int u = diameter_end1; u != diameter_end2; u = trace[u]) {
ans.push_back({trace[u], diameter_end1});
total_cost += dis1[trace[u]];
vis[u] = true;
qu.push(u);
}
vis[diameter_end2] = true;
for (; qu.size(); qu.pop()) {
int u = qu.front();
for (auto v : gr[u]) {
if (vis[v]) continue;
vis[v] = true;
ans.emplace_back(v, dis2[v] < dis1[v] ? diameter_end1 : diameter_end2);
total_cost += max(dis2[v], dis1[v]);
qu.push(v);
}
}
cout << total_cost << '\n';
for (int i = ((int)ans.size()); i--;) {
cout << ans[i].first << ' ' << ans[i].second << ' ' << ans[i].first << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const int N = 1e5 + 5;
int n;
double x[N], y[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n;
if (n & 1) {
cout << "NO";
return 0;
}
for (int i = 0; i < n; ++i) cin >> x[i] >> y[i];
double mx = (x[0] + x[n / 2]) / 2.0, my = (y[0] + y[n / 2]) / 2.0;
for (int i = 1; i < n / 2; ++i) {
double tx = (x[i] + x[(i + n / 2) % n]) / 2.0;
double ty = (y[i] + y[(i + n / 2) % n]) / 2.0;
if (fabs(tx - mx) > eps || fabs(ty - my) > eps) {
cout << "NO";
return 0;
}
}
cout << "YES";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void testcase() {
long long int n, k;
cin >> n >> k;
long long int arr[n + 1];
for (long long int i = 1; i < n + 1; i++) cin >> arr[i];
long long int p[n + 1];
p[0] = p[1] = 0;
for (long long int i = 2; i < n; i++) {
int flg = (arr[i] > arr[i - 1] and arr[i] > arr[i + 1]);
p[i] = p[i - 1] + flg;
}
p[n] = p[n - 1];
long long int ans = 0;
long long int ansl = 1;
for (long long int i = 1; i < n - k + 1 + 1; i++) {
long long int strt = i;
long long int end = i + k - 1 - 1;
long long int peaks = p[end] - p[strt];
if (peaks > ans) {
ans = peaks;
ansl = i;
}
}
cout << ans + 1 << " " << ansl << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) testcase();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 2;
long long int c, n, l[1000];
string s, ss;
int main() {
cin >> s;
for (int i = 0; i < s.length(); ++i) {
l[s[i]]++;
}
for (int i = 0; i < 1000; ++i) c += l[i] * l[i];
cout << c;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int64_t f[111][10], ans, C[111][111];
int a[10], n;
const int64_t mod = 1000000007;
int main() {
**C = 1;
for (int i = 1; i <= 100; ++i) {
C[i][0] = 1;
for (int j = 1; j <= i; ++j)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
scanf("%d", &n);
for (int i = 0; i < 10; ++i) scanf("%d", a + i);
for (int i = 0; i <= n; ++i) {
f[i][9] = i >= a[9];
for (int j = 8; j >= 1; --j)
for (int k = a[j]; k <= i; ++k)
f[i][j] = (f[i][j] + f[i - k][j + 1] * C[i][k]) % mod;
for (int k = *a; k <= i; ++k)
f[i][0] = (f[i][0] + f[i - k][1] * C[i - 1][k]) % mod;
}
for (int i = 1; i <= n; ++i) ans += f[i][0];
ans %= mod;
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
if (n == 1 || m == 1)
cout << "YES\n";
else if (max(n, m) == 2) {
cout << "YES\n";
} else
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
struct event {
int x, l, r, v;
event() {}
event(int _x, int _l, int _r, int _v) : x(_x), l(_l), r(_r), v(_v) {}
bool operator<(const event &rhs) const { return x < rhs.x; }
};
int enlarge(int n) {
int res = 1;
while (res < n) {
res <<= 1;
}
return res;
}
class segment_tree {
struct node {
int mn, w;
node operator+(const node &rhs) const {
node res;
res.mn = std::min(mn, rhs.mn);
res.w = 0;
if (res.mn == mn) {
res.w ^= w;
}
if (res.mn == rhs.mn) {
res.w ^= rhs.w;
}
return res;
}
};
int n;
std::vector<int> p;
std::vector<node> a;
std::vector<int> tag;
void up(int u) {
a[u] = a[u << 1] + a[u << 1 | 1];
a[u].mn += tag[u];
}
void build(int u, int l, int r) {
tag[u] = 0;
if (l + 1 == r) {
a[u].mn = 0, a[u].w = p[l] ^ p[r];
return;
}
int mid = (l + r + 1) >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid, r);
up(u);
}
void modify(int u, int l, int r, int L, int R, int v) {
if (L <= l && r <= R) {
a[u].mn += v;
tag[u] += v;
return;
}
int mid = (l + r + 1) >> 1;
if (L < mid) {
modify(u << 1, l, mid, L, R, v);
}
if (mid < R) {
modify(u << 1 | 1, mid, r, L, R, v);
}
up(u);
}
public:
segment_tree(const std::vector<int> &_p)
: n((int)_p.size() - 1), p(_p), a(enlarge(n) << 1), tag(enlarge(n) << 1) {
build(1, 0, n);
}
void modify(int l, int r, int v) {
l = std::lower_bound(p.begin(), p.end(), l) - p.begin();
r = std::lower_bound(p.begin(), p.end(), r) - p.begin();
if (l < r) {
modify(1, 0, n, l, r, v);
}
}
int query() { return a[1].mn > 0 ? p[n] ^ p[0] : p[n] ^ p[0] ^ a[1].w; }
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int n, m, lim;
std::cin >> n >> m >> lim;
std::vector<event> Q;
std::vector<int> v;
for (int i = 0; i < m; ++i) {
int sx, sy, tx, ty;
std::cin >> sx >> sy >> tx >> ty;
--sx, --sy;
Q.emplace_back(sx, sy, ty, 1);
Q.emplace_back(tx, sy, ty, -1);
v.push_back(sy);
v.push_back(ty);
}
std::sort(Q.begin(), Q.end());
std::sort(v.begin(), v.end());
v.erase(std::unique(v.begin(), v.end()), v.end());
segment_tree T(v);
int lst = 0;
int ans = 0;
for (auto p : Q) {
ans ^= (p.x ^ lst) & (T.query());
lst = p.x;
T.modify(p.l, p.r, p.v);
}
int mask = 1;
while (mask < lim) {
mask = mask << 1 | 1;
}
std::cout << (ans & mask ? "Hamed" : "Malek") << "\n";
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
class segment_tree {
vector<long long> tmax, tmin;
long size;
public:
segment_tree(long n) {
tmax.assign(4 * n + 1, 0);
tmin.assign(4 * n + 1, 200000000);
size = n;
}
void initialize_array(vector<long long>& v) {
initialize_with_array(1, 0, size - 1, v);
}
void initialize_with_array(long startpos, long l, long r,
vector<long long>& v) {
if (l == r) {
tmax[startpos] = v[l];
tmin[startpos] = v[l];
} else {
long m = (l + r) / 2;
initialize_with_array(2 * startpos, l, m, v);
initialize_with_array(2 * startpos + 1, m + 1, r, v);
tmax[startpos] = max(tmax[startpos * 2], tmax[startpos * 2 + 1]);
tmin[startpos] = min(tmin[startpos * 2], tmin[startpos * 2 + 1]);
}
}
void update(long index, long long val) {
update_full(1, 0, size - 1, index, val);
}
void update_full(long startpos, long l, long r, long index, long long val) {
if (l == r) {
tmax[startpos] = val;
tmin[startpos] = val;
} else {
long m = (l + r) / 2;
if (index <= m)
update_full(2 * startpos, l, m, index, val);
else
update_full(2 * startpos + 1, m + 1, r, index, val);
tmax[startpos] = max(tmax[startpos * 2], tmax[startpos * 2 + 1]);
tmin[startpos] = min(tmin[startpos * 2], tmin[startpos * 2 + 1]);
}
}
long long query_min(long l, long r) {
if (l > r) {
return 200000000;
}
return query_full_min(1, 0, size - 1, l, r);
}
long long query_full_min(long startpos, long left, long right, long l,
long r) {
if ((left >= l) && (right <= r)) return tmin[startpos];
long m = (left + right) / 2;
long long ans;
ans = 200000000;
if (m >= l) {
ans = min(ans, query_full_min(startpos * 2, left, m, l, r));
}
if (m + 1 <= r) {
ans = min(ans, query_full_min(startpos * 2 + 1, m + 1, right, l, r));
}
return ans;
}
long long query_max(long l, long r) {
if (l > r) {
return 0;
}
return query_full_max(1, 0, size - 1, l, r);
}
long long query_full_max(long startpos, long left, long right, long l,
long r) {
if ((left >= l) && (right <= r)) return tmax[startpos];
long m = (left + right) / 2;
long long ans;
ans = -(1LL << 60);
if (m >= l) {
ans = max(ans, query_full_max(startpos * 2, left, m, l, r));
}
if (m + 1 <= r) {
ans = max(ans, query_full_max(startpos * 2 + 1, m + 1, right, l, r));
}
return ans;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, i, j, k, pos, ans, minn, maxx, ct = 0, a, b;
string s;
cin >> n >> s;
n = s.length();
stack<char> st[2];
vector<char> v(1000010, ' ');
vector<int> p = {1, 0}, vleft(1000010, 0), vright(1000010, 0);
segment_tree stleft(1000010), stright(1000010);
pos = 0;
for (auto ch : s) {
char chh = ch;
if (ch == 'L') {
if ((pos != 0) && (p[0] > 1)) {
p[0]--;
p[1]++;
ch = v[pos];
if (ch == '(') {
vright[p[1]] = vright[p[1] - 1] - 1;
} else if (ch == ')') {
vright[p[1]] = vright[p[1] - 1] + 1;
} else
vright[p[1]] = vright[p[1] - 1];
stright.update(p[1], vright[p[1]]);
pos--;
}
} else if (ch == 'R') {
pos++;
if (p[1] > 0) p[1]--;
p[0]++;
ch = v[pos];
if (ch == '(') {
vleft[p[0]] = vleft[p[0] - 1] + 1;
} else if (ch == ')') {
vleft[p[0]] = vleft[p[0] - 1] - 1;
} else
vleft[p[0]] = vleft[p[0] - 1];
stleft.update(p[0], vleft[p[0]]);
} else {
v[pos] = ch;
if (ch == '(') {
vleft[p[0]] = vleft[p[0] - 1] + 1;
} else if (ch == ')') {
vleft[p[0]] = vleft[p[0] - 1] - 1;
} else
vleft[p[0]] = vleft[p[0] - 1];
stleft.update(p[0], vleft[p[0]]);
}
if (vleft[p[0]] != vright[p[1]])
ans = -1;
else {
a = stleft.query_min(0, p[0]), b = stright.query_min(0, p[1]);
if ((a < 0) || (b < 0))
ans = -1;
else
ans = max(stleft.query_max(0, p[0]), stright.query_max(0, p[1]));
}
cout << ans << " ";
ct++;
if (ct == 83) {
i = 0;
}
}
cout << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
double a, b, c, d;
double t, l;
int gcd(int x, int y) {
if (y == 0)
return x;
else
return gcd(y, x % y);
}
int main() {
int z = 0;
scanf("%lf %lf %lf %lf", &a, &b, &c, &d);
if (a / b == c / d) {
printf("0/1\n");
exit(0);
}
if (a / c < b / d) {
t = b * c;
l = b * c - a * d;
} else {
t = a * d;
l = a * d - b * c;
}
int g = gcd(int(t), int(l));
printf("%.0lf/%.0lf\n", l / g, t / g);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, s = 0;
cin >> n >> m;
while (n < m) {
s++;
if (m % 2 == 0)
m = m / 2;
else
m++;
}
cout << s + (n - m) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
string s1, s2;
int n, m;
vector<int> v;
void solve(int idx, int pos) {
if (idx == n) {
v[pos + n]++;
return;
}
if (s2[idx] == '+') solve(idx + 1, pos + 1);
if (s2[idx] == '-') solve(idx + 1, pos - 1);
if (s2[idx] == '?') {
solve(idx + 1, pos + 1);
solve(idx + 1, pos - 1);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s1;
cin >> s2;
m = s1.size(), n = s2.size();
v = vector<int>(2 * n + 5);
solve(0, 0);
int cnt = 0;
int d = 0;
for (int i = 0; i < m; i++) {
if (s1[i] == '+')
++d;
else
--d;
}
for (int i = 0; i < v.size(); i++) {
cnt += v[i];
}
double ans = (v[d + n] + 0.0) / cnt;
cout << setprecision(15) << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
string s;
cin >> n >> s;
string s0, s1;
if (n == 1) {
cout << "NO" << endl;
} else if (n == 2) {
if (s[0] >= s[1]) {
cout << "NO" << endl;
} else {
cout << "YES\n2" << endl;
cout << s[0] << " " << s[1] << endl;
}
} else {
cout << "YES\n2" << endl;
cout << s[0] << " " << s.substr(1, n - 1) << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 7;
struct data {
int to, next, id;
} e[N << 1];
pair<long long, long long> A[N], B[N], C[N * 15];
int head[N], flag, size[N], sum, root, mn, na, nb, vis[N], tot, sz,
cnt = 1, n, m, a[N], b[N], u, v, i, j;
vector<pair<long long, long long> > g[N], gg[N];
pair<long long, long long> operator+(pair<long long, long long> a,
pair<long long, long long> b) {
return pair<long long, long long>(a.first + b.first, a.second + b.second);
}
pair<long long, long long> operator-(pair<long long, long long> a,
pair<long long, long long> b) {
return pair<long long, long long>(a.first - b.first, a.second - b.second);
}
long double operator*(pair<long long, long long> a,
pair<long long, long long> b) {
return (long double)a.first * b.second - (long double)a.second * b.first;
}
void ins(int u, int v, int id) {
e[++cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt;
e[cnt].id = id;
}
void insert(int u, int v, int id) {
ins(u, v, id);
ins(v, u, id);
}
void build(pair<long long, long long> a[N], int& n) {
for (sort(a + 1, a + n + 1), i = 2, j = 1; i <= n; a[++j] = a[i++])
while (j >= 2 && (a[j] - a[j - 1]) * (a[i] - a[j]) >= 0) j--;
n = j;
}
void merge() {
C[++tot] = A[1] + B[1];
for (i = j = 1; i < na || j < nb;)
j == nb || (i < na && (A[i + 1] - A[i]) * (B[j + 1] - B[j]) <= 0) ? i++
: j++,
C[++tot] = A[i] + B[j];
}
void dfs(int first, int fa) {
for (auto& second : g[first])
if (second.first != fa)
dfs(second.first, first), gg[first].push_back(second);
}
void rebuild() {
dfs(1, 0);
for (i = 1; i <= sz; ++i)
if (gg[i].size() <= 2)
for (auto& second : gg[i]) insert(i, second.first, second.second);
else {
int s1 = ++sz, s2 = ++sz;
insert(i, s1, 0);
insert(i, s2, 0);
for (int j = 0; j < gg[i].size(); ++j)
(j & 1 ? gg[s1] : gg[s2]).push_back(gg[i][j]);
}
}
void getrt(int first, int id) {
size[first] = 1;
for (int i = head[first]; i; i = e[i].next)
if (!vis[i >> 1] && i / 2 != id / 2)
getrt(e[i].to, i), size[first] += size[e[i].to];
if (max(sum - size[first], size[first]) < mn)
mn = max(sum - size[first], size[first]), root = id;
}
void getdis(int first, int fa, pair<long long, long long> p[], int& n,
long long suma, long long sumb) {
p[++n] = pair<long long, long long>(suma, sumb);
for (int i = head[first]; i; i = e[i].next)
if (i / 2 != fa / 2 && !vis[i >> 1])
getdis(e[i].to, i, p, n, suma + a[e[i].id], sumb + b[e[i].id]);
}
void work(int first) {
getrt(first, 0);
sum = size[first];
root = 0;
mn = N;
getrt(first, 0);
first = root;
vis[first >> 1] = 1;
if (first == 0) return;
na = nb = 0;
getdis(e[first].to, 0, A, na, a[e[first].id], b[e[first].id]);
getdis(e[first ^ 1].to, 0, B, nb, 0, 0);
build(A, na);
build(B, nb);
merge();
work(e[first].to);
work(e[first ^ 1].to);
}
int main() {
for (scanf("%d%d", &n, &m), sz = n, i = 1; i < n; ++i)
scanf("%d%d%d%d", &u, &v, a + i, b + i),
g[u].push_back(pair<long long, long long>(v, i)),
g[v].push_back(pair<long long, long long>(u, i));
rebuild();
work(1);
build(C, tot);
for (i = 0, j = 1; i < m; ++i) {
while (j < tot &&
C[j].first * i + C[j].second <= C[j + 1].first * i + C[j + 1].second)
++j;
printf("%I64d ", C[j].first * i + C[j].second);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int memo[2003][2003];
int main() {
int n;
string s, t;
while (cin >> s >> t) {
int n1 = s.size();
int n2 = t.size();
s = "*" + s;
t = "*" + t;
for (int i = 1; i <= n1; i++) memo[0][i] = i;
for (int i = 1; i <= n2; i++)
for (int j = 1; j <= n1; j++)
memo[i][j] = (t[i] != s[j]) + memo[i - 1][j - 1];
int ans = (1 << 30);
for (int i = 1; i <= n2; i++) {
for (int j = 1; j <= n1; j++) {
if (i >= j)
ans = min(ans, n2 - i + abs(i - j) + memo[i][j]);
else
ans = min(ans, n2 - i - abs(i - j) + memo[i][j]);
}
}
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int A[100005];
int L[100005], R[100005];
vector<pair<int, int> > vec[100005];
int n, d, b;
bool solve(int x) {
int s = x, t = n - x - 1;
if (s > t) return true;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
que;
for (int i = 0; i <= t; i++) {
for (int j = 0; j < vec[i].size(); j++) {
pair<int, int> p = vec[i][j];
que.push(p);
}
if (i >= s) {
int zan = b;
while (zan > 0 && !que.empty()) {
pair<int, int> p = que.top();
que.pop();
if (p.first >= i) {
if (p.second > zan) {
p.second -= zan;
que.push(p);
zan = 0;
break;
} else {
zan -= p.second;
}
}
}
if (zan != 0) return false;
}
}
return true;
}
int main() {
scanf("%d %d %d", &n, &d, &b);
for (int i = 0; i < n; i++) {
scanf("%lld", &A[i]);
int f = i / (d + 1);
L[i] = f;
int x = (n - i - 1) / (d + 1);
R[i] = n - x - 1;
vec[L[i]].push_back(pair<int, int>(R[i], A[i]));
}
int l = -1, r = n + 1;
while (r - l > 1) {
int m = (l + r) / 2;
if (solve(m))
r = m;
else
l = m;
}
printf("%d\n", r);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 16) + 10;
int n, d[MAXN], s[MAXN];
vector<pair<int, int> > r;
void dfs(int v) {
d[v] = -1;
r.push_back(pair<int, int>(v, s[v]));
if (d[s[v]]) {
s[s[v]] ^= v;
if (--d[s[v]] == 1) dfs(s[v]);
}
}
int main() {
while (cin >> n) {
r.clear();
for (int i = (0); i < (n); i++) cin >> d[i] >> s[i];
for (int i = (0); i < (n); i++)
if (d[i] == 1) dfs(i);
cout << ((int)r.size()) << endl;
for (typeof(r.begin()) it = r.begin(); it != r.end(); ++it)
cout << it->first << ' ' << it->second << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 305;
string str[maxn];
int n;
int len[maxn];
long long ha[maxn], ha2[maxn], power[100005], power2[100005];
long long base = 133, base2 = 1e9 + 7, mod = 1998585857;
bool check(int p1, int p2, int p3, int p4) {
long long h1 =
(ha[p4] - ha[p3 - 1] * power[len[p4] - len[p3 - 1]] % mod + mod) % mod;
long long h2 =
(ha[p2] - ha[p1 - 1] * power[len[p2] - len[p1 - 1]] % mod + mod) % mod;
if (h1 == h2) {
h1 = ha2[p4] - ha2[p3 - 1] * power2[p4 - p3 + 1];
h2 = ha2[p2] - ha2[p1 - 1] * power2[p2 - p1 + 1];
return h1 == h2;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
power[0] = 1;
power2[0] = 1;
for (int i = 1; i < 100005; i++) {
power[i] = power[i - 1] * base % mod;
power2[i] = power2[i - 1] * base2;
}
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> str[i];
ha[i] = ha[i - 1];
ha2[i] = ha2[i - 1] * base2 + str[i].length();
len[i] = len[i - 1] + str[i].length();
for (int j = 0; j < str[i].length(); j++) {
ha[i] = (ha[i] * base + 1LL * str[i][j]) % mod;
}
}
int ans = 0;
for (int l = 1; l <= n; l++) {
for (int i = 1; i + l - 1 <= n; i++) {
int temp = 0, pos = 1, cnt = 0;
while (pos + l - 1 <= n) {
if (pos + l - 1 >= i && pos <= i) {
pos = i + l;
continue;
}
if (check(i, i + l - 1, pos, pos + l - 1)) {
cnt++;
pos = pos + l;
} else {
pos++;
}
}
if (cnt) {
cnt++;
ans = max(ans, cnt * (len[i + l - 1] - len[i - 1] - 1));
}
}
}
ans = len[n] + n - 1 - ans;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
int num[100010];
set<int> s;
bool ok() {
for (int i = 2; i < n; i++) {
if (!((num[i] >= num[i - 1] && num[i] <= num[i + 1]) ||
(num[i] <= num[i - 1] && num[i] >= num[i + 1]))) {
return true;
}
}
return false;
}
int main() {
while (scanf("%d", &n) != EOF) {
s.clear();
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
s.insert(num[i]);
}
int size = s.size();
if (size == 1 || n <= 2)
printf("-1\n");
else if (size >= 3) {
int pos[3];
int cnt = 0;
pos[0] = 1;
for (int i = 2; i <= n; i++) {
if (num[i] != num[pos[cnt]]) pos[++cnt] = i;
if (cnt == 3) break;
}
int MAX = max(num[pos[0]], num[pos[1]]);
MAX = max(MAX, num[pos[2]]);
if (num[pos[0]] == MAX)
printf("%d %d\n", pos[0], pos[1]);
else if (num[pos[1]] == MAX)
printf("%d %d\n", pos[0], pos[2]);
else if (num[pos[2]] == MAX)
printf("%d %d\n", pos[1], pos[2]);
} else if (size == 2) {
bool mark = false;
for (int i = 2; i <= n; i++) {
if (num[i] != num[i - 1]) {
swap(num[i], num[i - 1]);
if (ok()) {
printf("%d %d\n", i, i - 1);
mark = !mark;
break;
}
swap(num[i], num[i - 1]);
}
}
if (!mark) printf("-1\n");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 100010;
struct StringProfile {
vector<int> bestCount;
char charL, charR;
int countL, countR;
int len;
StringProfile() {
bestCount.resize(26, 0);
countL = countR = len = 0;
charL = charR = 0;
}
StringProfile(const string& str) {
len = str.size();
charL = str.front();
charR = str.back();
countL = 1;
for (int i = 1; i < len && str[i] == charL; ++i) {
countL = i + 1;
}
countR = 1;
for (int i = len - 2; i >= 0 && str[i] == charR; --i) {
countR = len - i;
}
bestCount.resize(26, 0);
int prev = 0;
for (int i = 1; i <= len; ++i) {
if (i == len || str[i] != str[i - 1]) {
int code = charCode(str[i - 1]);
bestCount[code] = max(bestCount[code], i - prev);
prev = i;
}
}
}
inline int charCode(char ch) { return ch - 'a'; }
StringProfile multiply(StringProfile p) {
StringProfile product;
if (p.len == p.countL) {
int ch = charCode(p.charL);
product.bestCount[ch] = (bestCount[ch] + 1) * p.len + bestCount[ch];
product.charL = product.charR = p.charL;
for (int i = 0; i < 26; ++i) {
if (i != ch) {
product.bestCount[i] = (bestCount[i] > 0 ? 1 : 0);
}
}
if (charL == p.charL) {
product.countL = countL + p.len * (countL + 1);
} else {
product.countL = p.len;
}
if (charR == p.charR) {
product.countR = countR + p.len * (countR + 1);
} else {
product.countR = p.len;
}
if (len == countL && charL == p.charL) {
product.len = product.countL;
}
} else {
product.charL = p.charL;
product.charR = p.charR;
product.countL = p.countL;
product.countR = p.countR;
product.bestCount = p.bestCount;
int codeL = charCode(p.charL);
int codeR = charCode(p.charR);
if (codeL == codeR && bestCount[codeL] > 0) {
product.bestCount[codeL] =
max(product.bestCount[codeL], p.countL + p.countR + 1);
}
if (bestCount[codeL] > 0) {
product.bestCount[codeL] = max(product.bestCount[codeL], p.countL + 1);
}
if (bestCount[codeR] > 0) {
product.bestCount[codeR] = max(product.bestCount[codeR], p.countR + 1);
}
for (int i = 0; i < 26; ++i) {
if (product.bestCount[i] == 0 && bestCount[i] > 0) {
product.bestCount[i] = 1;
}
}
}
return product;
}
};
string P[N_MAX];
int n;
void outerInit() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
auto fi = new ifstream("test.inp");
if (*fi) {
cin.rdbuf(fi->rdbuf());
}
}
void readData() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> P[i];
}
}
void initData() {}
void solveData() {
StringProfile profile(P[1]);
for (int i = 2; i <= n; ++i) {
StringProfile nextProfile(P[i]);
profile = profile.multiply(nextProfile);
}
cout << *max_element(profile.bestCount.begin(), profile.bestCount.end());
}
int main() {
outerInit();
readData();
initData();
solveData();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, m, a[401], b[401], c, i, j, ans, k, d;
cin >> t;
while (t--) {
cin >> n, k = 4 * n, ans = 1;
if (n == 1) {
cout << 1 << "\n";
continue;
}
for (i = k; i >= 2 * n; i -= 2) {
ans++;
cout << i << " ";
if (ans == n) break;
}
cout << i - 2 << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
static inline int Rint() {
struct X {
int dig[256];
X() {
for (int i = '0'; i <= '9'; ++i) dig[i] = 1;
dig['-'] = 1;
}
};
static X fuck;
int s = 1, v = 0, c;
for (; !fuck.dig[c = getchar()];)
;
if (c == '-')
s = 0;
else if (fuck.dig[c])
v = c ^ 48;
for (; fuck.dig[c = getchar()]; v = v * 10 + (c ^ 48))
;
return s ? v : -v;
}
template <typename T>
static inline void cmax(T& a, const T& b) {
if (b > a) a = b;
}
template <typename T>
static inline void cmin(T& a, const T& b) {
if (b < a) a = b;
}
const int maxn = 100005;
char mat[3][10005];
const long long mod = 1000000007;
int n;
void dfs(int x, int y, int flag, long long* to, long long inc) {
if (x == 3) {
int f = 0;
for (int i = 0; i < 3; ++i) {
if (y + 1 == n)
f |= 1 << i;
else if (mat[i][y + 1] == '.')
;
else
f |= 1 << i;
}
to[f] += inc;
if (to[f] >= mod) to[f] -= mod;
} else if (flag & (1 << x)) {
dfs(x + 1, y, flag, to, inc);
} else {
if (y + 1 < n && mat[x][y + 1] == '.') {
mat[x][y + 1] = 'T';
dfs(x + 1, y, flag | 1 << x, to, inc);
mat[x][y + 1] = '.';
}
if (x + 1 < 3 && ((flag & (1 << x + 1)) == 0)) {
dfs(x + 2, y, flag | 1 << x | 1 << x + 1, to, inc);
}
}
}
long long cal(int n) {
long long data[2][8] = {0};
long long* from = data[0];
long long* to = data[1];
from[7] = 1;
for (int i = -1; i < n; ++i) {
fill(to, to + 8, 0);
for (int last = 0; last < 8; ++last)
if (from[last]) {
dfs(0, i, last, to, from[last]);
}
swap(from, to);
}
return from[7];
}
int main() {
const int n = Rint();
::n = n;
for (int i = 0; i < 3; ++i) scanf("%s", mat[i]);
vector<vector<int> > psb;
int countX = 0;
int x = -1, y = -1;
for (int i = 0; i < 3; ++i)
for (int j = 0; j < n; ++j) {
if (mat[i][j] == 'O') x = i, y = j;
if (mat[i][j] == 'X') ++countX;
}
{
if (y - 2 >= 0 && mat[x][y - 2] == '.' && mat[x][y - 1] == '.') {
psb.push_back({0, -2, 0, -1});
}
if (y + 2 < n && mat[x][y + 2] == '.' && mat[x][y + 1] == '.') {
psb.push_back({0, 2, 0, 1});
}
if (x - 2 >= 0 && mat[x - 2][y] == '.' && mat[x - 1][y] == '.') {
psb.push_back({-2, 0, -1, 0});
}
if (x + 2 < 3 && mat[x + 2][y] == '.' && mat[x + 1][y] == '.') {
psb.push_back({2, 0, 1, 0});
}
}
if (((int)(psb).size()) == 0) {
puts("0");
return 0;
}
if ((3 * n - countX - 1) % 2 != 0) {
puts("0");
return 0;
}
const int m = ((int)(psb).size());
long long ans = 0;
for (int mask = 1; mask < 1 << m; ++mask) {
for (int j = 0; j < m; ++j)
if (mask & (1 << j)) {
for (int i = 0; i < 4; i += 2) {
const int dx = psb[j][i];
const int dy = psb[j][i + 1];
mat[x + dx][y + dy] = 'X';
}
}
long long t = cal(n);
if (__builtin_popcount(mask) & 1) {
ans += t;
} else {
ans -= t;
}
for (int j = 0; j < m; ++j)
if (mask & (1 << j)) {
for (int i = 0; i < 4; i += 2) {
const int dx = psb[j][i];
const int dy = psb[j][i + 1];
mat[x + dx][y + dy] = '.';
}
}
}
ans = (ans % mod + mod) % mod;
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> dec_to_bin(long long n) {
vector<long long> bin;
long long k = 0;
while (n) {
long long rem = n % 2;
bin.push_back(rem);
n /= 2;
}
while (bin.size() < 31) bin.push_back(0);
return bin;
}
long long pawer(long long n) {
long long ans = 1;
long long base = 2;
while (n) {
if (n & 1) ans *= base;
base *= base;
n >>= 1;
}
return ans;
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> bin = dec_to_bin(n);
priority_queue<long long> pq;
long long p = 0;
for (long long i = 0; i < bin.size(); i++) {
if (bin[i]) {
pq.push(i);
}
}
if (pq.size() > k) {
cout << "NO\n";
} else {
while (pq.size() < k && pq.top()) {
long long ind = pq.top();
pq.pop();
pq.push(ind - 1);
pq.push(ind - 1);
}
if (pq.size() == k) {
cout << "YES\n";
while (!pq.empty()) {
cout << pawer(pq.top()) << ' ';
pq.pop();
}
} else {
cout << "NO\n";
}
}
}
int32_t main() {
long long t = 1;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int n, m;
bool bad[N];
vector<int> G[N];
int vis[N];
bool interesting;
int lvl[N];
int best[N];
int balance[N];
void clear() {
for (int i = 1; i <= n; ++i) {
lvl[i] = 0;
best[i] = 0;
balance[i] = 0;
G[i].clear();
bad[i] = false;
}
}
void no_answer() {
puts("-1");
clear();
}
int getInt(int a = INT_MIN, int b = INT_MAX) {
static mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<int>(a, b)(rng);
}
void dfs(int u) {
vis[u] = 1;
for (auto v : G[u])
if (vis[v] == 0)
dfs(v);
else if (vis[v] == 2)
interesting = false;
vis[u] = 2;
}
bool check(int r) {
for (int i = 1; i <= n; ++i) vis[i] = 0;
interesting = true;
dfs(r);
return interesting;
}
int find_any() {
int tests = 100;
while (tests--) {
int r = getInt(1, n);
if (check(r)) return r;
}
return -1;
}
int find_bad(int u) {
vis[u] = 1;
best[u] = u;
for (auto v : G[u])
if (vis[v] == 0) {
lvl[v] = lvl[u] + 1;
balance[u] += find_bad(v);
if (lvl[best[v]] < lvl[best[u]]) best[u] = best[v];
} else {
balance[u]++;
balance[v]--;
if (lvl[v] < lvl[best[u]]) best[u] = v;
}
if (balance[u] > 1) bad[u] = true;
return balance[u];
}
void propagate_bad(int u) {
vis[u] = 1;
if (!bad[u] && bad[best[u]]) bad[u] = true;
for (auto v : G[u])
if (vis[v] == 0) propagate_bad(v);
}
vector<int> find_all(int r) {
for (int i = 1; i <= n; ++i) vis[i] = 0;
vector<int> ans;
find_bad(r);
for (int i = 1; i <= n; ++i) vis[i] = 0;
propagate_bad(r);
for (int i = 1; i <= n; ++i)
if (!bad[i]) ans.push_back(i);
return ans;
}
void solve() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
G[u].push_back(v);
}
int id = find_any();
if (id == -1) {
no_answer();
return;
}
auto ans = find_all(id);
if (5 * ans.size() >= n) {
for (auto v : ans) printf("%d ", v);
puts("");
clear();
} else
no_answer();
}
int main() {
int cases;
scanf("%d", &cases);
while (cases--) solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
using namespace std;
const long long N = 10001;
vector<long long> g[N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < n - 1; ++i) {
long long a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
long long ans = 0;
for (long long i = 1; i <= n; ++i) {
long long num = (g[i].size() * (g[i].size() - 1)) / 2;
ans += num;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long fac[1001], inv[1001];
long long f[1001][1001][2][2], ans[1001];
long long C(int n, int m) {
if (n < m) return 0;
return fac[n] * inv[m] % 1000000007 * inv[n - m] % 1000000007;
}
int main() {
scanf("%d%d", &n, &m);
fac[0] = fac[1] = inv[0] = inv[1] = 1;
for (int i = 2; i <= n; i++)
inv[i] = inv[1000000007 % i] * (1000000007 - 1000000007 / i) % 1000000007;
for (int i = 2; i <= n; i++)
fac[i] = fac[i - 1] * i % 1000000007,
inv[i] = inv[i - 1] * inv[i] % 1000000007;
f[0][0][1][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= n; j++)
for (int k = 0; k < 2; k++)
for (int l = 0; l < 2; l++) {
(f[i][j][l][0] += f[i - 1][j][k][l]) %= 1000000007;
if (!j) break;
if (!k) (f[i][j][l][0] += f[i - 1][j - 1][k][l]) %= 1000000007;
(f[i][j][l][1] += f[i - 1][j - 1][k][l]) %= 1000000007;
}
for (int i = 0; i <= n; i++)
ans[i] =
(f[n][i][0][0] + f[n][i][1][0]) % 1000000007 * fac[n - i] % 1000000007;
for (int i = m, x = 1; i <= n; i++, x = -x)
(ans[n + 1] += ans[i] * C(i, m) % 1000000007 * x + 1000000007) %=
1000000007;
printf("%lld\n", ans[n + 1]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20);
const long long Mod = (long long)1e9 + 7;
const long long Inv2 = (long long)5e8 + 4;
void dwt(long long x[], int l, int r) {
if (l + 1 == r) return;
int mid = (l + r) >> 1;
dwt(x, l, mid);
dwt(x, mid, r);
for (int i = l; i < mid; i++) {
long long x1 = x[i] - x[i - l + mid];
long long x2 = x[i] + x[i - l + mid];
x[i] = (x1 + Mod) % Mod;
x[i - l + mid] = (x2 + Mod) % Mod;
}
}
void rdwt(long long x[], int l, int r) {
if (l + 1 == r) return;
int mid = (l + r) >> 1;
for (int i = l; i < mid; i++) {
long long x1 = x[i];
long long x2 = x[i - l + mid];
x[i] = (x1 + x2) * Inv2 % Mod;
x[i - l + mid] = (x2 - x1) * Inv2 % Mod;
}
rdwt(x, l, mid);
rdwt(x, mid, r);
}
long long a[N], b[N], c[N];
void multi(long long a[], long long b[], long long c[], int n) {
dwt(a, 0, n);
dwt(b, 0, n);
for (int i = 0; i < n; i++) c[i] = a[i] * b[i] % Mod;
rdwt(c, 0, n);
for (int i = 0; i < n; i++) {
c[i] = (c[i] + Mod) % Mod;
}
}
int x[N];
int main() {
ios ::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < (1 << n); i++) {
int t = __builtin_popcount(i);
b[i] = min(t, n - t);
}
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < m; j++)
if (s[j] == '1') x[j] |= (1 << i);
}
for (int i = 0; i < m; i++) a[x[i]]++;
multi(a, b, c, (1 << n));
int ans = ~0U >> 1;
for (int i = 0; i < (1 << n); i++) ans = min((long long)ans, c[i]);
cout << ans << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k = 0;
cin >> n;
string a;
for (int i = 0; i < n; i++) {
cin >> a;
if (a == "Tetrahedron") {
k = k + 4;
} else if (a == "Cube") {
k = k + 6;
} else if (a == "Octahedron") {
k = k + 8;
} else if (a == "Dodecahedron") {
k = k + 12;
} else if (a == "Icosahedron") {
k = k + 20;
}
}
cout << k;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1LL << 31) - 1;
char S[100005];
int main() {
int n, k;
while (cin >> n >> k) {
scanf("%s", S);
int cnt = 0, len = strlen(S);
for (int i = 0; i < len; ++i) {
if (k == cnt) break;
if (S[i] == '4' && i % 2 == 0 && i + 2 < len && S[i + 1] == '4' &&
S[i + 2] == '7') {
long long remains = k - cnt;
if (remains % 2) S[i + 1] = '7';
break;
} else if (S[i] == '4' && i + 1 < len && S[i + 1] == '7') {
++cnt;
if (i % 2) {
S[i] = '7';
S[i + 1] = '7';
} else {
S[i] = '4';
S[i + 1] = '4';
--i;
}
}
}
printf("%s\n", S);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double r = 0, d = 0, n = 0, c = 0, i;
scanf("%lf%lf", &r, &d);
cin >> n;
for (i = 1; i <= n; i++) {
double x, y, r1, v;
cin >> x >> y >> r1;
v = sqrt((x * x) + (y * y));
if (v - r1 >= r - d && v + r1 <= r) {
c++;
}
}
cout << c << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define ll long long
#define cmax(a,b) a=max(a,b)
#define pii pair<int,int>
#define fi first
#define se second
#define pii pair<int,int>
#define mkp make_pair
#define pk push_back
using namespace std;
const int maxn=4e5+10;
int ans[maxn];
string s;
int main() {
int T;
cin>>T;
while (T--) {
int n;
cin>>n;
cin>>s;
s=" "+s;
int a=0,b=0;
for (int l=1;l<=n;l++) {
if (s[l]=='0') a++;
if (s[l]=='1') b++;
}
if (s[1]!='1'||s[n]!='1'||a%2==1) {
cout<<"NO"<<endl;
continue;
}
a=0,b=0;
bool bx=1;
for (int l=1;l<=n;l++) {
if (s[l]=='0') {
if (a==0&&b==0) {
bx=0;
break;
}
if (a>b) {
ans[l]=1;
a--;b++;
} else {
ans[l]=0;
a++;b--;
}
}
if (s[l]=='1') {
if (a==1&&b==1&&s[l+1]=='0') {
ans[l]=1;
a++,b++;
} else if (a==0||b==0) {
ans[l]=1;
a++,b++;
} else {
ans[l]=0;
a--;b--;
}
}
}
if (bx==0||a!=0||b!=0) {
cout<<"NO"<<endl;
continue;
}
cout<<"YES"<<endl;
for (int l=1;l<=n;l++) {
if (ans[l]==1) cout<<'(';
else cout<<')';
}
cout<<endl;
for (int l=1;l<=n;l++) {
if (ans[l]==1&&s[l]=='1') cout<<'(';
if (ans[l]==1&&s[l]=='0') cout<<')';
if (ans[l]==0&&s[l]=='1') cout<<')';
if (ans[l]==0&&s[l]=='0') cout<<'(';
}
cout<<endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[200],
a[11][10] = {"ABSINTH", "BEER", "BRANDY", "CHAMPAGNE", "GIN", "RUM",
"SAKE", "TEQUILA", "VODKA", "WHISKEY", "WINE"};
int ans, n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("\n");
gets(s);
int l = strlen(s);
if (isdigit(s[0])) {
if (l < 2 || (l == 2 && s[0] == '1' && s[1] < '8')) ans++;
} else
for (int j = 0; j <= 10; j++)
if (!strcmp(s, a[j])) {
ans++;
break;
};
}
printf("%d", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 3;
const int INF = 1e9;
const int MOD = 1e9 + 7;
int n;
int a[MAXN];
long long seg[12][4 * MAXN];
void add(int j, int l, int r, long long val, int b = 0, int e = n, int k = 0) {
if (l <= b && e <= r) {
seg[j][k] += val;
return;
}
if (r <= b || e <= l) return;
int mid = (b + e) / 2;
add(j, l, r, val, b, mid, k * 2 + 1);
add(j, l, r, val, mid, e, k * 2 + 2);
}
long long get(int j, int i, int b = 0, int e = n, int k = 0) {
if (i < b || i >= e) return 0;
if (b + 1 == e) return seg[j][k];
int mid = (b + e) / 2;
return seg[j][k] + get(j, i, b, mid, k * 2 + 1) +
get(j, i, mid, e, k * 2 + 2);
}
int main() {
cin >> n;
int k;
cin >> k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x--;
a[x] = i;
}
for (int i = 0; i < n; i++) {
if (a[i] == 0) {
add(1, a[i], n, 1);
} else {
for (int j = 2; j <= k + 1; j++) {
long long x = get(j - 1, a[i] - 1);
add(j, a[i], n, x);
}
add(1, a[i], n, 1);
}
}
cout << get(k + 1, n - 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[1201][1201];
char c[1201][1201];
int que[1200001][2], n, m, i, j, k, queB, queE;
bool pole[1201][1201];
void add(int x, int y) {
if ((x < 1) || (x > n) || (y < 1) || (y > m) || (pole[x][y])) return;
que[queE][1] = x;
que[queE][2] = y;
queE++;
pole[x][y] = true;
}
void bfs(int x, int y) {
int i;
queB = 0;
queE = 1;
add(x, y);
while (queB < queE - 1) {
queB++;
x = que[queB][1];
y = que[queB][2];
add(x + 1, y);
add(x, y + 1);
add(x - 1, y);
add(x, y - 1);
}
for (i = 1; i <= queE - 1; i++)
a[que[i][1]][que[i][2]] = make_pair(queE - 1, k);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
cin >> c[i][j];
if (c[i][j] == '*') pole[i][j] = true;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (!pole[i][j]) {
k++;
bfs(i, j);
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (c[i][j] == '*') {
k = 1;
if ((a[i + 1][j].second != a[i][j + 1].second) &&
(a[i + 1][j].second != a[i - 1][j].second) &&
(a[i + 1][j].second != a[i][j - 1].second))
k += a[i + 1][j].first;
if ((a[i][j + 1].second != a[i - 1][j].second) &&
(a[i][j + 1].second != a[i][j - 1].second))
k += a[i][j + 1].first;
if (a[i - 1][j].second != a[i][j - 1].second) k += a[i - 1][j].first;
k += a[i][j - 1].first;
c[i][j] = char(k % 10 + 48);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) cout << c[i][j];
cout << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 205;
int n, l, s;
int b[maxn];
double f[maxn][maxn][maxn * 2], p[maxn], q[maxn];
inline int read() {
int s = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') {
f = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
s = s * 10 + c - 48;
c = getchar();
}
return s * f;
}
int main() {
n = read(), l = read(), s = read();
for (int i = 1; i <= n; i++) {
scanf("%lf", &p[i]);
p[i] /= 100;
q[i] = 1.0 - p[i];
}
for (int i = 1; i <= n; i++) {
b[i] = read();
}
f[0][0][s + 200] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
for (int k = 0; k <= 400; k++) {
int t = min(k + b[i + 1], 400);
f[i + 1][j][k] += f[i][j][k] * q[i + 1];
if (t >= 0) {
f[i + 1][j + 1][t] += f[i][j][k] * p[i + 1];
}
}
}
}
double ans = 0.0;
for (int i = 200; i <= 400; i++) {
for (int j = l; j <= n; j++) {
ans += f[n][j][i];
}
}
printf("%.12lf", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
if (k % 3 == 0) {
int t = n % (k + 1);
if (t % 3 == 0 && t != k) {
cout << "Bob";
} else {
cout << "Alice";
}
} else {
if (n % 3 == 0) {
cout << "Bob";
} else {
cout << "Alice";
}
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("avx")
using namespace std;
const int INF = (int)1E9;
const long long INFLL = (long long)1E15;
const long long MOD = (long long)1E9 + 7;
const double PI = acos(-1);
const double EPS = 1E-9;
bool between(int x, int l, int r) { return (l <= x && x <= r); }
string tostring(int x) {
char dum[20];
sprintf(dum, "%d", x);
string ret(dum);
return ret;
}
void in(int &number) {
bool negative = false;
register int c;
number = 0;
c = getchar();
if (c == '-') negative = true, c = getchar();
for (; c > 47 && c < 58; c = getchar()) number = number * 10 + c - 48;
if (negative) number *= -1;
}
map<char, int> c;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string S;
getline(cin, S);
for (int i = 0; i < S.size(); i += 1)
if (S[i] != ' ') c[S[i]]++;
getline(cin, S);
for (int i = 0; i < S.size(); i += 1)
if (S[i] != ' ') c[S[i]]--;
for (auto data : c)
if (data.second < 0) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
long long a[100005] = {0}, b[100005];
long long i, n, t, n1;
scanf("%lld", &n);
for (i = 0; i < n; i++) {
scanf("%lld", &t);
a[t]++;
}
b[0] = 0;
b[1] = a[1];
for (i = 2; i < 100001; i++) {
n1 = b[i - 2] + i * a[i];
b[i] = (b[i - 1] > n1) ? b[i - 1] : n1;
}
printf("%lld\n", b[100001 - 1]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200005];
vector<pair<int, int> > edges;
int top[200005], seen[200005], k = 0;
long long pot[200005], cont = 0;
long long mod = 1000000007;
void dfs(int x) {
seen[x] = 1;
for (auto a : v[x]) {
if (!seen[a]) dfs(a);
}
top[k++] = x;
}
void dfs2(int x) {
seen[x] = 1;
cont++;
for (auto a : v[x]) {
if (!seen[a]) dfs2(a);
}
}
int main() {
int n, x;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
edges.push_back(make_pair(i, x));
v[i].push_back(x);
}
pot[1] = 2ll;
for (int i = 2; i <= 200002; i++) {
pot[i] = (pot[i - 1] * 2ll) % mod;
}
for (int i = 1; i <= n; i++) {
if (!seen[i]) dfs(i);
}
for (int i = 1; i <= n; i++) v[i].clear();
for (auto a : edges) {
int x = a.first;
int y = a.second;
v[y].push_back(x);
}
memset(seen, 0, sizeof(seen));
long long ans = 1ll;
for (int i = k - 1; i >= 0; i--) {
cont = 0;
if (!seen[top[i]]) {
dfs2(top[i]);
if (cont == 1)
ans = (ans * 2ll) % mod;
else
ans = (ans * (pot[cont] - 2ll)) % mod;
}
}
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-14;
const int dx[4] = {0, 0, -1, 1};
const int dy[4] = {-1, 1, 0, 0};
const int maxn = 100500;
const int mod = 1e9 + 7;
long long dp[maxn][3], a[maxn][3];
int xf, yf, off;
long long solve(int i, int j, vector<vector<bool> > vis) {
if (i == xf && j == yf) return a[j][i];
vis[j][i - off] = true;
long long ans = -1e18;
for (int k = 0; k < 4; ++k) {
int x = i + dx[k], y = j + dy[k];
if (x > xf || x < off || y < 0 || y > 2 || vis[y][x - off]) continue;
ans = max(ans, a[j][i] + solve(x, y, vis));
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int j = 0; j < 3; ++j)
for (int i = 1; i <= n; ++i) cin >> a[i][j];
for (int j = 0; j < 3; ++j) dp[1][j] = (j ? dp[1][j - 1] : 0) + a[1][j];
for (int i = 2; i <= n; ++i) {
dp[i][0] = max(dp[i - 1][0] + a[i][0], dp[i - 1][1] + a[i][1] + a[i][0]);
dp[i][0] = max(dp[i][0], dp[i - 1][2] + a[i][2] + a[i][1] + a[i][0]);
dp[i][0] = max(dp[i][0], dp[i - 2][2] + a[i - 1][2] + a[i][2] + a[i][1] +
a[i - 1][1] + a[i - 1][0] + a[i][0]);
dp[i][1] = max(dp[i - 1][0] + a[i][0] + a[i][1], dp[i - 1][1] + a[i][1]);
dp[i][1] = max(dp[i][1], dp[i - 1][2] + a[i][2] + a[i][1]);
dp[i][2] = max(dp[i - 1][0] + a[i][0] + a[i][1] + a[i][2],
dp[i - 1][1] + a[i][1] + a[i][2]);
dp[i][2] = max(dp[i][2], dp[i - 1][2] + a[i][2]);
dp[i][2] = max(dp[i][2], dp[i - 2][0] + a[i - 1][0] + a[i][0] + a[i][1] +
a[i - 1][1] + a[i - 1][2] + a[i][2]);
}
cout << dp[n][2] << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int failure[100005], good[100005], n, m;
string text, pattern;
long long q1[100005], q2[100005], a[100005], ans;
const int mod = 1000000007;
void ff() {
failure[0] = failure[1] = 0;
int j;
for (int i = 2; i <= m; i++) {
j = failure[i - 1];
while (1) {
if (pattern[j] == pattern[i - 1]) {
failure[i] = j + 1;
break;
}
if (j == 0) {
failure[i] = 0;
break;
}
j = failure[j];
}
}
}
void KMP() {
ff();
int i = 0, j = 0;
while (1) {
if (j == n) {
break;
}
if (text[j] == pattern[i]) {
i++;
j++;
if (i == m) {
good[j - 1] = 1;
i = failure[i];
}
} else if (i > 0) {
i = failure[i];
} else
j++;
}
}
int main() {
cin >> text >> pattern;
text = '#' + text;
m = pattern.size();
n = text.size();
KMP();
for (int i = 0; i < n; i++) {
if (good[i] == 1) {
a[i] = q2[i - m] + i - m + 1;
} else {
a[i] = a[i - 1];
}
a[i] = (a[i] % mod);
if (i > 0) {
q1[i] = (q1[i - 1] + a[i]) % mod;
q2[i] = (q2[i - 1] + q1[i]) % mod;
} else {
q1[i] = a[i];
q2[i] = q1[i];
}
ans = (ans + a[i]) % mod;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string str, str1;
int main() {
int k, n, i, cnt, len, j;
cin >> str >> k;
len = str.size();
cnt = 0;
for (i = 0; i < len; i++)
if (str[i] != '?' && str[i] != '*') cnt++;
for (i = 1, str += '~'; i < str.size(); i++) {
if (str[i] == '?') {
if (cnt > k)
cnt--;
else
str1 += str[i - 1];
} else {
if (str[i] == '*') {
if (cnt > k)
cnt--;
else {
if (cnt < k) {
for (j = 0; j < k - cnt + 1; j++) str1 += str[i - 1];
cnt = k;
} else
str1 += str[i - 1];
}
} else if (str[i - 1] != '?' && str[i - 1] != '*')
str1 += str[i - 1];
}
}
if (str1.size() != k) {
cout << "Impossible\n";
return 0;
}
cout << str1 << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d;
char A[15], B[15], C[15], D[15];
int n;
long long zzz(char q[]) {
long long tam = 0;
for (int i = strlen(q) - 1; i >= 0; i--) tam = tam * 30 + q[i] - 'a' + 1;
return tam;
}
void xxx(long long w) {
while (w > 0) {
int tam = w % 30;
w /= 30;
cout << char(tam + 'a' - 1);
}
}
int main() {
cin >> A >> B;
a = zzz(A);
b = zzz(B);
xxx(a);
cout << ' ';
xxx(b);
cout << endl;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> C >> D;
c = zzz(C);
d = zzz(D);
if (a == c)
a = d;
else if (b == c)
b = d;
else if (a == d)
a = c;
else if (b == d)
b = c;
xxx(a);
cout << ' ';
xxx(b);
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 7;
const long long maxn = (long long)2e5 + 5;
const int nnn = 1048590;
const int inf = numeric_limits<int>::max() - 1;
const long long INF = 1e18;
long long dx[] = {0, 1, 0, -1};
long long dy[] = {1, 0, -1, 0};
long long dxx[] = {0, 1, 0, -1, 1, 1, -1, -1};
long long dyy[] = {1, 0, -1, 0, 1, -1, 1, -1};
long long n[5], t[5];
long long ans[10000];
long long k;
void solve() {
cin >> k;
for (int i = 1; i <= (3); i++) cin >> n[i];
for (int i = 1; i <= (3); i++) cin >> t[i];
for (int i = 1; i <= (k); i++) ans[i] = 0;
for (long long j = 1; j < 4; j++) {
for (long long i = 1; i <= k; i++) {
if (i <= n[j])
ans[i] += t[j];
else
ans[i] = max(ans[i], ans[i - n[j]]) + t[j];
}
}
cout << ans[k];
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long T;
T = 1;
while (T--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vll = vector<ll, ll>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
string s;
int cnt[27];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s;
int n = s.size();
int mx = -1;
for (int i = 0; i < n; i++) {
cnt[s[i] - 'a']++;
mx = max(mx, (int)(s[i] - 'a'));
}
for (int i = 0; i < n; i++) {
while (!cnt[mx] && mx > 0) mx--;
if (s[i] - 'a' == mx) {
cout << s[i];
}
cnt[s[i] - 'a']--;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
const double eps = 1e-8;
struct Point {
long long x, y;
Point(long long xx = 0, long long yy = 0) : x(xx), y(yy){};
} pnt[N];
Point operator-(const Point &A, const Point &B) {
return Point(A.x - B.x, A.y - B.y);
}
long long operator%(const Point &A, const Point &B) {
return A.x * B.y - A.y * B.x;
}
long long operator*(const Point &A, const Point &B) {
return A.x * B.x + A.y * B.y;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
pair<long long, long long> intersection(Point u1, Point u2, Point v1,
Point v2) {
pair<long long, long long> pp;
pp.first = (u1 - v1) % (v1 - v2);
pp.second = (u1 - u2) % (v1 - v2);
if (pp.second < 0) pp.first *= -1, pp.second *= -1;
long long d = gcd(abs(pp.first), abs(pp.second));
pp.first /= d;
pp.second /= d;
return pp;
}
long long floor(long long, long long);
long long ceil(long long, long long);
long long floor(long long a, long long b) {
return a >= 0 ? a / b : -ceil(-a, b);
}
long long ceil(long long a, long long b) {
return a >= 0 ? (a + b - 1) / b : -floor(-a, b);
}
int main() {
int n;
scanf("%d", &n);
int i, j;
for (i = 0; i < n; i++) scanf("%I64d%I64d", &pnt[i].x, &pnt[i].y);
Point pa, pb;
pa = pnt[0];
pb = pnt[1];
if (pb.x < pa.x) swap(pa, pb);
long long rig = pb.x;
long long lef = pa.x;
for (i = 2; i < n - 1; i++) {
long long cc = (pnt[i + 1] - pnt[i]) % (pb - pa);
if (cc != 0) {
pair<long long, long long> pp;
pp = intersection(pa, pb, pnt[i], pnt[i + 1]);
if (cc > 0)
rig = min(rig, pa.x + floor((pb.x - pa.x) * pp.first, pp.second));
else
lef = max(lef, pa.x + ceil((pb.x - pa.x) * pp.first, pp.second));
} else if ((pnt[i + 1] - pnt[i]) * (pnt[1] - pnt[0]) > 0) {
cout << 0 << endl;
return 0;
}
}
cout << max(0LL, rig - lef + 1) << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int x, n, a, l;
char s[10];
int main() {
scanf("%lld", &l);
long long int lim = pow(2, 32);
stack<long long int> st;
while (l--) {
scanf("%s", s);
if (s[0] == 'f') {
scanf("%lld", &a);
if (st.size() == 0)
n = 1;
else
n = st.top();
n = min(n * a, lim);
st.push(n);
} else if (s[0] == 'a') {
if (st.size() == 0)
x++;
else
x += st.top();
} else
st.pop();
if (x >= lim) return printf("OVERFLOW!!!\n"), 0;
}
printf("%lld\n", x);
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.