solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k, r, x, y, i, j, anc[20][N], dep[N], g[N], a[N], bel[N], q;
bool bb[N];
int gfa(int x) { return g[x] == x ? x : g[x] = gfa(g[x]); }
vector<int> e[N];
void dfs(int x, int fa) {
anc[0][x] = fa;
dep[x] = dep[fa] + 1;
for (int y : e[x])
if (y != fa) dfs(y, x);
}
inline int lca(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
int dt = dep[y] - dep[x], i;
for (i = 0; (1 << i) <= dt; ++i)
if (dt >> i & 1) y = anc[i][y];
if (x == y) return x;
for (i = 19; i >= 0; --i)
if (anc[i][x] != anc[i][y]) x = anc[i][x], y = anc[i][y];
return anc[0][x];
}
inline int dis(int x, int y) { return dep[x] + dep[y] - dep[lca(x, y)] * 2; }
struct node {
int ch[2], fa;
pair<int, int> v, s;
} t[N];
inline void upd(const int& x) {
t[x].s = min(min(t[t[x].ch[0]].s, t[t[x].ch[1]].s), t[x].v);
}
inline int dir(const int& x, const int& y) { return t[x].ch[1] == y; }
inline void setc(const int& x, const int& y, const int& o) {
t[x].ch[o] = y;
t[y].fa = x;
}
inline bool nrt(const int& x) {
return t[t[x].fa].ch[0] == x || t[t[x].fa].ch[1] == x;
}
inline void rotate(int x) {
int y = t[x].fa, z = t[y].fa, o;
if (nrt(y)) setc(z, x, dir(z, y));
t[x].fa = z;
o = dir(y, x);
setc(y, t[x].ch[!o], o);
setc(x, y, !o);
upd(y);
}
inline void splay(int x) {
for (; nrt(x); rotate(x)) {
int y = t[x].fa, z = t[y].fa;
if (nrt(y)) rotate(dir(z, y) == dir(y, x) ? y : x);
}
upd(x);
}
inline void access(int x) {
int y = 0, ox = x;
for (; x; x = t[x].fa) splay(x), setc(x, y, 1), upd(x), y = x;
splay(ox);
}
bool cov[N];
inline void mdy(int x) {
access(x);
for (int y = x; y && !cov[y]; y = anc[0][y])
cov[y] = 1, splay(y), t[y].v = {dep[x] - dep[y] * 2, x}, upd(y);
}
inline int ask(int x) {
access(x);
return t[x].s.first + dep[x] <= k ? t[x].s.second : 0;
}
int main() {
for (i = 0; i < N; ++i) t[i].v = t[i].s = {1 << 25, 0};
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> r;
for (i = 1; i < n; ++i) cin >> x >> y, e[x].push_back(y), e[y].push_back(x);
dfs(1, 0);
for (i = 1; i < 20; ++i)
for (j = 1; j <= n; ++j) anc[i][j] = anc[i - 1][anc[i - 1][j]];
for (i = 1; i <= n; ++i) a[i] = i;
sort(a + 1, a + n + 1, [&](int x, int y) { return dep[x] < dep[y]; });
for (; r--;) cin >> x, bb[x] = 1;
for (i = 1; i <= n; ++i) t[i].fa = anc[0][i];
for (i = 1; i <= n; ++i) {
x = a[i];
y = ask(x);
if (bb[x])
g[x] = y ? y : x, bel[x] = gfa(x), mdy(x);
else
bel[x] = y ? gfa(y) : 0;
}
for (cin >> q; q--;) {
cin >> x >> y;
int xx = bel[x], yy = bel[y];
cout << (dis(x, y) <= k || (xx && yy && xx == yy) ||
(xx && dis(xx, y) <= k) || (yy && dis(yy, x) <= k)
? "YES"
: "NO")
<< '\n';
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int i, j, n, m, mas[105], ab[105], rez;
int main() {
cin >> n >> m;
i = 0;
while (i < n) {
cin >> mas[i];
if (m % mas[i] == 0) {
ab[i] = m / mas[i];
}
i = i + 1;
}
i = 0;
rez = 1000000000;
while (i < n) {
if (ab[i] > 0) {
rez = min(rez, ab[i]);
}
i = i + 1;
}
cout << rez;
return (0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[1000];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int ans = (n - a[0]) % n;
for (int i = 1; i < n; i++) {
switch (i % 2) {
case 1:
if (ans != (a[i] - i + n) % n) {
cout << "No" << endl;
return 0;
}
break;
case 0:
if (ans != (i - a[i] + n) % n) {
cout << "No" << endl;
return 0;
}
break;
}
}
cout << "Yes" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
int a[n + 5], b[n + 5];
b[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[i] = b[i - 1] + a[i];
}
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
int x, y;
cin >> x >> y;
cout << (b[y] - b[x - 1]) / 10 << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int que1[100005], que2[100005];
long long a[100005], b[100005];
int main() {
long long n, k, i;
while (cin >> n >> k) {
long long sum = 0;
if (n == 0) cout << "End of line";
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
sum += a[i];
}
if (k > sum) {
cout << "-1" << endl;
continue;
}
if (k == sum) {
cout << endl;
continue;
}
sort(b, b + n);
long long num = 0;
int kk = 0;
while (k >= 0) {
long long minn = 0x7fffffff;
long long cnt = 0;
minn = b[kk++] - num;
cnt = n - kk + 1;
while (b[kk] == b[kk - 1] && k < n) {
kk++;
}
if (cnt == 0) {
if (n != 0 && k != 0) cout << -1;
break;
}
if (minn * cnt > k) {
long long t = k / cnt;
for (i = 0; i < n; i++) {
if (a[i] - num > 0) {
a[i] -= t;
}
}
k -= (cnt * t);
int l = 0, ll = 0;
for (i = 0; i < n; i++) {
if (k > 0 && a[i] - num > 0) {
a[i]--;
k--;
if (a[i] - num > 0) {
que2[ll++] = i;
}
} else if (a[i] - num > 0) {
que1[l++] = i;
}
}
for (i = 0; i < l; i++) cout << que1[i] + 1 << " ";
for (i = 0; i < ll; i++) cout << que2[i] + 1 << " ";
break;
} else {
k -= (minn * cnt);
num += minn;
}
}
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
const int maxn = 1E+6 + 5;
const int maxk = 20;
const int INF = 0x3f3f3f3f;
int n, m, k, S1, S2;
int tim1[1 << maxk], tim2[1 << maxk];
int a[maxn], b[maxn], p[maxn][maxk];
inline void SWAP(int &S, int a, int b) {
int x = S >> a & 1, y = S >> b & 1;
if (x == y) return;
S ^= (1 << a) | (1 << b);
}
inline void FMT(int *a, int N, const int &f(const int &, const int &)) {
for (int i = 1; i < N; i <<= 1)
for (int j = 0; j < N; ++j)
if (j & i) a[j - i] = f(a[j - i], a[j]);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
int A = 0, B = 0;
for (int i = 0, x; i < k; ++i) scanf("%1d", &x), S1 ^= x << i, A += x;
for (int i = 0, x; i < k; ++i) scanf("%1d", &x), S2 ^= x << i, B += x;
std::fill(tim1, tim1 + (1 << k), INF);
std::fill(tim2, tim2 + (1 << k), -INF);
tim1[S1] = n + 1, tim2[S2] = n + 1;
for (int i = 1; i <= n; ++i) scanf("%d%d", &a[i], &b[i]), --a[i], --b[i];
for (int i = 0; i < k; ++i) p[n + 1][i] = i;
for (int i = n; i >= 1; --i) {
for (int j = 0; j < k; ++j) {
if (a[i] == j || b[i] == j)
p[i][j] = p[i + 1][j ^ a[i] ^ b[i]];
else
p[i][j] = p[i + 1][j];
}
int cur = 0;
for (int j = 0; j < k; ++j) cur ^= (S1 >> j & 1) << p[i][j];
tim1[cur] = std::min(tim1[cur], i);
cur = 0;
for (int j = 0; j < k; ++j) cur ^= (S2 >> j & 1) << p[i][j];
tim2[cur] = std::max(tim2[cur], i);
}
FMT(tim1, 1 << k, std::min<int>);
FMT(tim2, 1 << k, std::max<int>);
auto cnt = [](const int &x) -> int { return __builtin_popcount(x); };
int ans = 0, ans1 = 1, ans2 = 1;
for (int S = 0; S < (1 << k); ++S) {
if (tim2[S] - tim1[S] >= m) {
int res = 2 * cnt(S) - A - B + k;
if (res > ans) ans = res, ans1 = tim1[S], ans2 = tim2[S] - 1;
}
}
printf("%d\n%d %d\n", ans, ans1, ans2);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000];
int main() {
long long i, j, t, f, s, n;
scanf("%lld %lld %lld", &f, &s, &n);
unsigned long long ml = 1, c = 0;
if (f < 2) {
a[++c] = 1;
}
while (1) {
if (ml <= s / n) {
ml *= n;
if (ml >= f) a[++c] = ml;
} else
break;
}
if (!c) {
cout << "-1" << endl;
} else {
for (i = 1; i <= c; i++) {
cout << a[i];
if (i < c) printf(" ");
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1e5 + 10;
long long a[N], b[N], pre[N];
long long ta[N], tb[N];
int main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i], ta[i] = a[i];
for (int i = 1; i <= n; i++) cin >> b[i], tb[i] = b[i];
long long ans = 0;
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + a[i];
if (!k) {
for (int i = 1; i <= n; i++) ans = max(ans, pre[n] - pre[i - 1] - b[i]);
return cout << ans << '\n', 0;
}
if (k == 1) {
for (int i = 1; i < n; i++) ans = max(ans, pre[n - 1] - b[i]);
if (b[n] < a[n]) ans += a[n] - b[n];
sort(ta + 2, ta + 1 + n - 1), sort(tb + 2, tb + 1 + n - 1);
ans = max(ans, pre[n] - b[1] - ta[2]);
ans = max(ans, pre[n] - b[1] - tb[2]);
ans = max(ans, pre[n] - tb[2] - tb[3]);
for (int i = 2; i <= n; i++) ans = max(ans, pre[n] - pre[i - 1] - b[i]);
cout << ans << '\n';
} else {
for (int i = 1; i < n; i++) ans = max(ans, pre[n] - b[i]);
ans = max(ans, a[n] - b[n]);
return cout << ans << '\n', 0;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using namespace placeholders;
template <class T>
void mini(T &l, T r) {
l = min(l, r);
}
template <class T>
void maxi(T &l, T r) {
l = max(l, r);
}
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << "=" << h << ",";
_dbg(sdbg + 1, a...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> v) {
os << "[";
for (auto vv : v) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> p) {
return os << "(" << p.first << "," << p.second << ")";
}
const int N = 110, L = 2010;
int n;
int f[N][L];
int fl[N][L];
struct Item {
int t, d, p, i;
} items[N];
void upd(int &x, int y, int &fl, int v) {
if (x < y) x = y, fl = v;
}
void go(int x, int y, vector<int> &v) {
if (x == 0) return;
if (fl[x][y]) v.push_back(items[x].i);
go(x - 1, y - fl[x][y] * items[x].t, v);
}
void run() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d", &items[i].t, &items[i].d, &items[i].p);
items[i].i = i;
}
sort(items + 1, items + n + 1, [](Item a, Item b) { return a.d < b.d; });
f[0][0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < L; ++j) {
if (j + items[i + 1].t < items[i + 1].d) {
upd(f[i + 1][j + items[i + 1].t], f[i][j] + items[i + 1].p,
fl[i + 1][j + items[i + 1].t], 1);
}
upd(f[i + 1][j], f[i][j], fl[i + 1][j], 0);
}
}
int who = max_element(f[n], f[n] + L) - f[n];
printf("%d\n", f[n][who]);
vector<int> v;
go(n, who, v);
reverse(v.begin(), v.end());
printf("%d\n", (int)v.size());
for (int i = 0; i < (int)v.size(); ++i)
printf("%d%c", v[i], " \n"[i == (int)v.size() - 1]);
}
int main() {
run();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
class chip_info {
public:
int lef, rig;
};
vector<vector<char> > game;
vector<vector<chip_info> > strng, stolb, cpstrng, cpstolb;
int N, M;
void copy() {
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) {
strng[i][j] = cpstrng[i][j];
stolb[j][i] = cpstolb[j][i];
}
}
int modeling(int x, int y) {
int moves = 0;
while (x >= 0 && y >= 0) {
moves++;
if (strng[x][y].lef != -1) strng[x][strng[x][y].lef].rig = strng[x][y].rig;
if (strng[x][y].rig != -1) strng[x][strng[x][y].rig].lef = strng[x][y].lef;
if (stolb[y][x].lef != -1) stolb[y][stolb[y][x].lef].rig = stolb[y][x].rig;
if (stolb[y][x].rig != -1) stolb[y][stolb[y][x].rig].lef = stolb[y][x].lef;
if (game[x][y] == 'L')
y = strng[x][y].lef;
else if (game[x][y] == 'R')
y = strng[x][y].rig;
else if (game[x][y] == 'U')
x = stolb[y][x].lef;
else
x = stolb[y][x].rig;
}
copy();
return moves;
}
int main() {
cin >> N >> M;
game.resize(N + 1);
strng.resize(N + 1);
stolb.resize(M + 1);
cpstrng.resize(N + 1);
cpstolb.resize(M + 1);
for (int i = 0; i < N; i++) game[i].resize(M + 1);
for (int i = 0; i < N; i++) {
strng[i].resize(M + 1);
cpstrng[i].resize(M + 1);
}
for (int j = 0; j < M; j++) {
stolb[j].resize(N + 1);
cpstolb[j].resize(N + 1);
}
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) cin >> game[i][j];
int numchip = -1;
for (int i = 0; i < N; i++) {
numchip = -1;
for (int j = 0; j < M; j++)
if (game[i][j] != '.') {
strng[i][j].lef = numchip;
if (numchip != -1) strng[i][numchip].rig = j;
numchip = j;
}
if (numchip != -1) strng[i][numchip].rig = -1;
}
for (int j = 0; j < M; j++) {
numchip = -1;
for (int i = 0; i < N; i++)
if (game[i][j] != '.') {
stolb[j][i].lef = numchip;
if (numchip != -1) stolb[j][numchip].rig = i;
numchip = i;
}
if (numchip != -1) stolb[j][numchip].rig = -1;
}
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) {
cpstrng[i][j] = strng[i][j];
cpstolb[j][i] = stolb[j][i];
}
int t = 0, maxi = 0, kol = 0;
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) {
t = 0;
if (game[i][j] != '.') t = modeling(i, j);
if (t > maxi) {
maxi = t;
kol = 1;
} else if (t == maxi)
kol++;
}
cout << maxi << " " << kol;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n = -1;
cin >> n;
long long int a = min((long long int)2, n);
vector<array<long long int, 3>> t;
int x, h;
for (int i = 0; i < n; i++) {
cin >> x >> h;
t.push_back({x, h, 1});
}
sort(t.begin(), t.end());
for (int i = 1; i < n - 1; i++) {
if (t.at(i).at(2) && t.at(i).at(0) - t.at(i).at(1) > t.at(i - 1).at(0)) {
a++;
} else if (t.at(i).at(0) + t.at(i).at(1) < t.at(i + 1).at(0)) {
a++;
if (t.at(i).at(0) + t.at(i).at(1) >=
t.at(i + 1).at(0) - t.at(i + 1).at(1)) {
t.at(i + 1).at(2) = 0;
}
}
}
cout << a << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
int main() {
ll n;
cin >> n;
ll fmax = 0;
for (ll f = 0; f < sqrt(n); f += 1) {
if ((3 * f * (f + 1) / 2 - f) <= n && ((n + f) % 3) == 0)
fmax = max(fmax, f);
}
cout << (fmax + 3 - 1) / 3 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0, 1, 1, -1, -1};
int dy[] = {0, 0, 1, -1, 1, -1, 1, -1};
const int MAX = 1e9 + 7;
const double pi =
3.14159265358979323846264338327950288419716939937510582097494459;
const double EPS = 1e-10;
const int oo = 1e9 + 7;
const long long OO = 5e18;
const int MOD = 1e9 + 7;
const int N = 2e5 + 50;
vector<int> adj[N];
vector<vector<int> > bit;
int vis[N], comp[N], bi_dir[N], dep[N];
pair<int, int> edge[N];
map<pair<int, int>, int> ID;
vector<pair<int, int> > edges;
void dfs(int u, int p = 0, int c = 0, int l = 0) {
if (vis[u]) return;
vis[u] = 1;
comp[u] = c;
dep[u] = l - 1;
for (auto v : adj[u]) {
if (v != p) {
bit[c].push_back(0);
int idx = 0;
if (ID.count({u, v}))
idx = ID[{u, v}];
else
idx = ID[{v, u}];
edge[idx] = {c, l};
dfs(v, u, c, l + 1);
}
}
}
void update(int c, int idx, int val) {
idx++;
while (idx < int((bit[c]).size())) {
bit[c][idx] += val;
idx += idx & -idx;
}
}
int get(int c, int idx) {
int res = 0;
idx++;
while (idx > 0) {
res += bit[c][idx];
idx -= idx & -idx;
}
return res;
}
void solve() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
ID[{u, v}] = i;
edges.push_back({u, v});
adj[u].push_back(v);
adj[v].push_back(u);
}
int idx = 0;
for (int i = 1; i < n + 1; i++) {
if (adj[i].size() > 2) {
idx = i;
break;
}
}
if (!idx) {
for (int i = 1; i < n + 1; i++) {
if (adj[i].size() == 1) {
idx = i;
break;
}
}
}
bit.resize(adj[idx].size());
for (int i = 0; i < adj[idx].size(); i++) bit[i].push_back(0);
vis[idx] = 1;
int i = 0;
for (auto v : adj[idx]) {
if (!vis[v]) {
bit[i].push_back(0);
int ind = 0;
if (ID.count({idx, v}))
ind = ID[{idx, v}];
else
ind = ID[{v, idx}];
edge[ind] = {i, 0};
dfs(v, idx, i++, 1);
} else {
bi_dir[comp[v]] = 1;
}
}
for (int i = 0; i < bit.size(); i++) {
for (int j = 0; j < bit[i].size() - 1; j++) update(i, j, 1);
}
int m;
cin >> m;
while (m--) {
int typ;
cin >> typ;
if (typ != 3) {
int ind;
cin >> ind;
pair<int, int> e = edge[ID[edges[ind - 1]]];
update(e.first, e.second, typ == 2 ? -1 : 1);
} else {
int a, b;
cin >> a >> b;
if (a == b) {
cout << "0" << endl;
continue;
}
if (a == idx || b == idx) {
if (a == idx) {
int dstb = min(
get(comp[b], dep[b]) == dep[b] + 1 ? dep[b] + 1 : oo,
bi_dir[comp[b]] && get(comp[b], int((bit[comp[b]]).size()) - 1) -
get(comp[b], dep[b]) ==
int((bit[comp[b]]).size()) - dep[b] - 1
? int((bit[comp[b]]).size()) - dep[b] - 1
: oo);
if (dstb < oo)
cout << dstb << endl;
else
cout << -1 << endl;
continue;
}
int dsta = min(
get(comp[a], dep[a]) == dep[a] + 1 ? dep[a] + 1 : oo,
bi_dir[comp[a]] && get(comp[a], int((bit[comp[a]]).size()) - 1) -
get(comp[a], dep[a]) ==
int((bit[comp[a]]).size()) - dep[a] - 1
? int((bit[comp[a]]).size()) - dep[a] - 1
: oo);
if (dsta < oo)
cout << dsta << endl;
else
cout << -1 << endl;
continue;
}
if (comp[a] == comp[b]) {
vector<pair<int, int> > nodes(2);
nodes[0] = {dep[a], a}, nodes[1] = {dep[b], b};
sort(nodes.begin(), nodes.end());
int ans = get(comp[a], nodes[1].first) - get(comp[a], nodes[0].first);
if (ans == nodes[1].first - nodes[0].first) {
cout << ans << endl;
} else if (bi_dir[comp[a]]) {
int tmp = get(comp[a], bit[comp[a]].size() - 1) +
get(comp[a], nodes[0].first) - ans;
if (tmp == bit[comp[a]].size() - ans) {
cout << tmp << endl;
}
} else {
cout << -1 << endl;
}
continue;
}
int dsta =
min(get(comp[a], dep[a]) == dep[a] + 1 ? dep[a] + 1 : oo,
bi_dir[comp[a]] && get(comp[a], int((bit[comp[a]]).size()) - 1) -
get(comp[a], dep[a]) ==
int((bit[comp[a]]).size()) - dep[a] - 1
? int((bit[comp[a]]).size()) - dep[a] - 1
: oo);
int dstb =
min(get(comp[b], dep[b]) == dep[b] + 1 ? dep[b] + 1 : oo,
bi_dir[comp[b]] && get(comp[b], int((bit[comp[b]]).size()) - 1) -
get(comp[b], dep[b]) ==
int((bit[comp[b]]).size()) - dep[b] - 1
? int((bit[comp[b]]).size()) - dep[b] - 1
: oo);
if (dsta + dstb < oo)
cout << dsta + dstb << endl;
else
cout << -1 << endl;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
string s, s1;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> s;
int n = s.size();
long long ans = 1;
for (int i = 0; i < n; i++) {
long long cnt = 0;
int x = i;
while (x < n) {
if (s[x] == 'a')
cnt++, x++;
else if (s[x] == 'b')
break;
else
x++;
}
i = x;
ans = ans * (cnt + 1) % mod;
}
ans--;
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MOD = 1000000007;
long long dp[MAXN], arr[MAXN], pr[MAXN];
set<int> s;
map<long long, long long> mp;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long fun(long long a) {
if (a < MAXN) return dp[a];
if (mp.count(a)) return mp[a];
for (long long i = 2; i * i <= a; i++) {
if (a % i == 0) {
long long ans = fun(a / i) + (s.count(i) == 1 ? -1 : 1);
mp[a] = ans;
return ans;
}
}
long long ans = (s.count(a) == 1 ? -1 : 1);
mp[a] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 0; i < m; i++) {
int a;
cin >> a;
s.insert(a);
}
dp[1] = 0;
for (int i = 2; i < MAXN; i++) {
if (pr[i] == 0) {
dp[i] = (s.count(i) == 1 ? -1 : 1);
for (int j = i + i; j < MAXN; j += i)
if (pr[j] == 0) pr[j] = i;
} else {
dp[i] = dp[i / pr[i]] + (s.count(pr[i]) == 1 ? -1 : 1);
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) pr[i] = gcd(arr[i], pr[i - 1]);
for (int i = n; i; i--) {
if (fun(pr[i]) < 0) {
for (int j = 1; j <= i; j++) {
arr[j] /= pr[i];
pr[j] /= pr[i];
}
}
ans += fun(arr[i]);
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
void palindrome(string s) {
int i = 0;
int j = s.size() - 1;
while (i < j) {
if (s[i] != s[j]) return;
i++;
j--;
}
cout << s;
exit(0);
}
int recursive(int n, int a[]) {
int x = 1;
if (a[n] != 0) return a[n];
if (n < 10) return n;
while (n != 0) {
if (n % 10 != 0) x = x * (n % 10);
n = n / 10;
}
return recursive(x, a);
}
int main() {
long long n, m, d;
cin >> n >> m >> d;
map<long long, long long> m1;
long long x;
set<long long> s;
for (int i = 0; i < n; i++) {
cin >> x;
m1[x] = i + 1;
s.insert(x);
}
int b[n + 1];
long long day = 1;
long long curr;
while (true) {
if (s.empty()) break;
curr = *s.begin();
b[m1[curr]] = day;
s.erase(curr);
while (s.lower_bound(curr + d + 1) != s.end()) {
curr = *s.lower_bound(curr + d + 1);
s.erase(curr);
b[m1[curr]] = day;
}
day++;
}
cout << day - 1 << endl;
for (int i = 1; i <= n; i++) cout << b[i] << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
while (t--) {
int n;
cin >> n;
int arr[n], visi[n];
for (int i = 0; i < n; ++i) {
cin >> arr[i];
visi[i] = 0;
}
int q;
cin >> q;
int i = 0, j, mx;
vector<pair<int, pair<int, int>>> fir;
vector<pair<int, int>> sec;
while (q--) {
int x, y;
cin >> x >> y;
if (x == 1) {
--y;
int z;
cin >> z;
fir.push_back({++i, {y, z}});
} else {
sec.push_back({++i, y});
}
}
i = fir.size() - 1, j = sec.size() - 1, mx = 0;
while (i >= 0 && j >= 0) {
int idxf = fir[i].first, idxs = sec[j].first;
if (idxf > idxs) {
if (visi[fir[i].second.first] == 0) {
visi[fir[i].second.first] = 1;
arr[fir[i].second.first] = max(fir[i].second.second, mx);
}
--i;
} else {
mx = max(mx, sec[j].second);
--j;
}
}
while (i >= 0) {
if (visi[fir[i].second.first] == 0) {
visi[fir[i].second.first] = 1;
arr[fir[i].second.first] = max(mx, fir[i].second.second);
}
--i;
}
while (j >= 0) {
mx = max(mx, sec[j].second);
--j;
}
for (int i = 0; i < n; ++i) {
if (visi[i] == 0) arr[i] = max(arr[i], mx);
cout << arr[i] << " \n"[i == n];
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5000;
int n;
int a[MAXN + 1];
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
}
bool check(int x) {
int to = a[a[a[x]]];
return to == x;
}
void solve() {
for (int i = 1; i <= n; ++i)
if (check(i)) {
puts("YES");
return;
}
puts("NO");
}
int main() {
init();
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
register int data = 0, w = 1;
register char ch = 0;
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (isdigit(ch)) data = 10 * data + ch - '0', ch = getchar();
return w * data;
}
const int MAX_N = 1e5 + 5;
struct Graph {
int to, next;
} e[MAX_N << 1];
int fir1[MAX_N], fir2[MAX_N], e_cnt;
void clearGraph() {
memset(fir1, -1, sizeof(fir1));
memset(fir2, -1, sizeof(fir2));
}
void Add_Edge(int *fir, int u, int v) {
e[e_cnt] = (Graph){v, fir[u]};
fir[u] = e_cnt++;
}
namespace Tree {
int fa[MAX_N], dep[MAX_N], size[MAX_N], top[MAX_N], son[MAX_N], dfn[MAX_N], tim;
void dfs1(int x) {
dfn[x] = ++tim;
size[x] = 1, dep[x] = dep[fa[x]] + 1;
for (int i = fir1[x]; ~i; i = e[i].next) {
int v = e[i].to;
if (v == fa[x]) continue;
fa[v] = x;
dfs1(v);
size[x] += size[v];
if (size[v] > size[son[x]]) son[x] = v;
}
}
void dfs2(int x, int tp) {
top[x] = tp;
if (son[x]) dfs2(son[x], tp);
for (int i = fir1[x]; ~i; i = e[i].next) {
int v = e[i].to;
if (v == fa[x] || v == son[x]) continue;
dfs2(v, v);
}
}
int LCA(int x, int y) {
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
x = fa[top[x]];
}
return dep[x] < dep[y] ? x : y;
}
} // namespace Tree
using Tree::dfn;
using Tree::LCA;
int N, M, K, a[MAX_N], f[MAX_N];
bool g[MAX_N], key[MAX_N];
bool cmp(const int &i, const int &j) { return dfn[i] < dfn[j]; }
void build() {
static int stk[MAX_N], top;
e_cnt = 0;
top = 0;
sort(&a[1], &a[K + 1], cmp);
for (int i = 1; i <= K; i++)
if (a[i] != a[i - 1]) stk[++top] = a[i];
K = top;
for (int i = 1; i <= K; i++) a[i] = stk[i];
stk[top = 1] = 1, fir2[1] = -1;
for (int i = 1; i <= K; i++) {
if (a[i] == 1) continue;
int lca = LCA(a[i], stk[top]);
if (lca != stk[top]) {
while (dfn[lca] < dfn[stk[top - 1]]) {
int u = stk[top], v = stk[top - 1];
Add_Edge(fir2, u, v), Add_Edge(fir2, v, u);
--top;
}
if (dfn[lca] > dfn[stk[top - 1]]) {
fir2[lca] = -1;
int u = lca, v = stk[top];
Add_Edge(fir2, u, v), Add_Edge(fir2, v, u);
stk[top] = lca;
} else {
int u = lca, v = stk[top--];
Add_Edge(fir2, u, v), Add_Edge(fir2, v, u);
}
}
fir2[a[i]] = -1, stk[++top] = a[i];
}
for (int i = 1; i < top; i++) {
int u = stk[i], v = stk[i + 1];
Add_Edge(fir2, u, v), Add_Edge(fir2, v, u);
}
}
void Dp(int x, int fa) {
f[x] = g[x] = 0;
int c = 0;
for (int i = fir2[x]; ~i; i = e[i].next) {
int v = e[i].to;
if (v == fa) continue;
Dp(v, x);
f[x] += f[v], c += g[v];
}
if (key[x])
g[x] = 1, f[x] += c;
else if (c > 1)
g[x] = 0, ++f[x];
else
g[x] = c;
}
int main() {
clearGraph();
N = gi();
for (int i = 1; i < N; i++) {
int u = gi(), v = gi();
Add_Edge(fir1, u, v), Add_Edge(fir1, v, u);
}
Tree::dfs1(1), Tree::dfs2(1, 1);
M = gi();
while (M--) {
K = gi();
for (int i = 1; i <= K; i++) key[a[i] = gi()] = 1;
bool flg = 1;
for (int i = 1; i <= K && flg; i++)
if (key[Tree::fa[a[i]]]) flg = 0;
if (!flg) {
puts("-1");
goto NXT;
}
build();
Dp(1, 0);
printf("%d\n", f[1]);
NXT:
for (int i = 1; i <= K; i++) key[a[i]] = 0;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, ans, x, y;
string s;
int check() {
vector<int> a(n);
int temp = INT_MAX;
for (int i = 0; i < n; ++i) {
a[i] = (s[i] == '(' ? 1 : -1);
if (i > 0) a[i] += a[i - 1];
temp = min(temp, a[i]);
}
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (a[i] == temp) ++cnt;
}
return cnt;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
cin >> s;
int cnt = 0;
for (auto ch : s) {
if (ch == '(') ++cnt;
}
if (cnt * 2 != n) {
cout << 0 << '\n';
cout << 1 << " " << 1 << '\n';
return 0;
}
ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
swap(s[i], s[j]);
int res = check();
if (res > ans) {
ans = res;
x = i + 1;
y = j + 1;
}
swap(s[i], s[j]);
}
}
cout << ans << '\n';
cout << x << " " << y << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long const N = 1e5 + 1;
void solve() {
long long n, k;
cin >> n >> k;
if (n % 2 == 0) {
cout << n + (2LL * k) << "\n";
return;
} else {
long long sml = n;
for (long long i = 3; i * i <= n; i++) {
if (n % i == 0) {
sml = i;
break;
}
}
long long ans = n + sml;
k--;
if (k > 0) {
ans = ans + (2LL * k);
}
cout << ans << "\n";
return;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m, s[N][3], d[N], a[N];
pair<int, int> ans[N];
int l = 0;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i]--;
for (int j = 0; j <= 1; j++)
for (int i = 1; i <= n; i++) s[i][j] = (s[i - 1][j] + (a[i] == j));
for (int s0 = 1; s0 <= n; s0++) {
int cur = 0, c[2] = {0, 0};
bool flag = true;
while (cur < n) {
int x = cur, S[2] = {0, 0};
for (int j = 18; j >= 0; j--)
if (x + (1 << j) <= n) {
int t0 = S[0] + s[x + (1 << j)][0] - s[x][0],
t1 = S[1] + s[x + (1 << j)][1] - s[x][1];
if (t0 < s0 && t1 < s0) S[0] = t0, S[1] = t1, x += (1 << j);
}
S[0] = s[x + 1][0] - s[cur][0];
S[1] = s[x + 1][1] - s[cur][1];
cur = x + 1;
if (S[0] < s0 && S[1] < s0) {
flag = false;
break;
}
if (S[0] == s0) c[0]++;
if (S[1] == s0) c[1]++;
}
if (c[a[n]] <= c[a[n] ^ 1]) flag = false;
if (flag) ans[++l] = make_pair(c[a[n]], s0);
}
sort(ans + 1, ans + l + 1);
printf("%d\n", l);
for (int i = 1; i <= l; i++) printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, c = 0, s = 0, a, d = 0, s1 = 0;
cin >> n;
vector<int> v;
for (i = 0; i < 2 * n; i++) {
cin >> a;
if (d == a) c++;
d = a;
v.push_back(a);
}
sort(v.begin(), v.end());
for (i = 0; i < n; i++) {
s = +v[i];
s1 += v[i + n];
}
if (s1 != s && c != 2 * n - 1) {
for (i = 0; i < 2 * n; i++) cout << v[i] << " ";
cout << endl;
} else
cout << "-1" << endl;
}
| 1 |
#include <bits/stdc++.h>
#define PI 3.14159265
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
#define f first
#define s second
// #define mp make_pair
#define ll long long
#define mod 1000000007
#define mem(v,x) memset(v,x,sizeof(v))
const ll inf = 0x3f3f3f3f3f3f3f3fll;
using namespace std;
ll gcd(ll a, ll b){ if (a == 0) return b; return gcd(b % a, a);}
ll lcm(ll a, ll b){ return (a*b)/gcd(a, b);}
bool isPrime(ll x) {
for (ll d = 2; d * d <= x; d++) {
if (x % d == 0)
return false;
}
return true;
}
void solve(){
ll n,k,ans=0,j,m,i;
cin >> n >> k;
ll dp[n],a[n];
for(i=0;i<n;i++) cin >> a[i];
memset(dp,0,sizeof(dp));
dp[0] = a[0];
for(i=1;i<n;i++) dp[i] = dp[i-1] + a[i];
for(i=1;i<n;i++){
j = a[i]*100;
m = k*(ans + dp[i-1]);
j = j - m;
if(j<=0) continue;
if(j%k) j = j/k + 1;
else j = j/k;
ans += max(0,j);
}
cout << ans << endl;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
ll t;
cin >> t;
// t = 1;
while(t--){
solve();
}
} | 2 |
#include <bits/stdc++.h>
using namespace std;
struct triple {
long long ff, ss, tt;
bool operator<(triple t) { return tt < t.tt; }
triple(long long a, long long b, long long c) : ff(a), ss(b), tt(c){};
};
vector<triple> q1, q2;
long long busca(long long el) {
long long l = 0, r = (long long)q2.size() - 1, ans = -1;
while (l <= r) {
long long mid = (l + r) / 2;
if (q2[mid].tt > el) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
return ans;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<long long> v(n);
for (auto& it : v) cin >> it;
long long q;
cin >> q;
long long maior = 0;
vector<bool> mexi(n, true);
for (long long i = 0; i < q; i++) {
long long choice;
cin >> choice;
if (choice == 1) {
long long p, x;
cin >> p >> x;
q1.push_back(triple(p - 1, x, i));
} else {
long long x;
cin >> x;
q2.push_back(triple(x, i, i));
maior = max(maior, x);
}
}
vector<long long> maxEl((long long)q2.size());
for (long long i = (long long)maxEl.size() - 1; i >= 0; i--) {
if (i == (long long)maxEl.size() - 1) {
maxEl[i] = q2[i].ff;
} else
maxEl[i] = max(q2[i].ff, maxEl[i + 1]);
}
for (long long i = 0; i < q1.size(); i++) {
auto proc = busca(q1[i].tt);
mexi[q1[i].ff] = false;
if (proc == -1) {
v[q1[i].ff] = q1[i].ss;
} else {
v[q1[i].ff] = max(q1[i].ss, maxEl[proc]);
}
}
for (long long i = 0; i < n; i++) {
if (mexi[i]) {
cout << max(maior, v[i]) << ' ';
} else {
cout << v[i] << ' ';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int points[10] = {25, 18, 15, 12, 10, 8, 6, 4, 2, 1};
struct node {
int num[51];
};
map<string, node> rk;
int race, peo;
int main() {
int i, j, k;
string str;
rk.clear();
cin >> race;
for (i = 0; i < race; i++) {
cin >> peo;
for (j = 0; j < peo; j++) {
cin >> str;
if (rk.find(str) == rk.end()) {
node tt;
for (k = 0; k < 51; k++) {
tt.num[k] = 0;
}
tt.num[j] = 1;
rk.insert(map<string, node>::value_type(str, tt));
} else {
rk[str].num[j]++;
}
if (j < 10) {
rk[str].num[50] += points[j];
}
}
}
map<string, node>::iterator it;
string res;
map<string, node>::iterator it1;
it = rk.begin();
res = it->first;
for (it1 = rk.begin(); it1 != rk.end(); it1++) {
if (it->second.num[50] != it1->second.num[50]) {
if (it->second.num[50] < it1->second.num[50]) {
res = it1->first;
it = it1;
}
continue;
}
for (i = 0; i < 50; i++) {
if (it->second.num[i] != it1->second.num[i]) {
if (it->second.num[i] < it1->second.num[i]) {
res = it1->first;
it = it1;
}
break;
}
}
}
cout << res << endl;
it = rk.begin();
res = it->first;
for (it1 = rk.begin(); it1 != rk.end(); it1++) {
if (it->second.num[0] != it1->second.num[0]) {
if (it->second.num[0] < it1->second.num[0]) {
res = it1->first;
it = it1;
}
continue;
}
if (it->second.num[50] != it1->second.num[50]) {
if (it->second.num[50] < it1->second.num[50]) {
res = it1->first;
it = it1;
}
continue;
}
for (i = 1; i < 50; i++) {
if (it->second.num[i] != it1->second.num[i]) {
if (it->second.num[i] < it1->second.num[i]) {
res = it1->first;
it = it1;
}
break;
}
}
}
cout << res << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string mirror = "AHIMOTUVWXY";
int main() {
long long n, m, i, j, k, x, y, q, t;
cin >> n;
vector<long long> v(n);
for (i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
if (n & 1)
cout << v[n / 2] << endl;
else
cout << v[n / 2 - 1] << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int kN = 75 + 5;
const int kInf = 1e9;
int dp[kN][kN][kN][2];
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
string s;
cin >> n >> s;
vector<int> V, K, X;
for (int i = 0; i < n; ++i) {
if (s[i] == 'V')
V.push_back(i);
else if (s[i] == 'K')
K.push_back(i);
else
X.push_back(i);
}
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= n; ++j) {
for (int k = 0; k <= n; ++k) {
dp[i][j][k][0] = dp[i][j][k][1] = kInf;
}
}
}
dp[0][0][0][0] = dp[0][0][0][1] = 0;
for (int v = 0; v <= V.size(); ++v) {
for (int k = 0; k <= K.size(); ++k) {
for (int x = 0; x <= X.size(); ++x) {
for (int is_v = 0; is_v <= 1; ++is_v) {
int cur_cost = dp[v][k][x][is_v];
auto CountLeft = [](vector<int>& A, int from, int last) {
int cnt = 0;
for (int i = from; i < A.size() && A[i] < last; ++i) {
++cnt;
}
return cnt;
};
auto ComputeCost = [&](int& ind) {
return CountLeft(V, v, ind) + CountLeft(K, k, ind) +
CountLeft(X, x, ind);
};
if (v < V.size()) {
dp[v + 1][k][x][1] =
min(dp[v + 1][k][x][1], cur_cost + ComputeCost(V[v]));
}
if (k < K.size() && !is_v) {
dp[v][k + 1][x][0] =
min(dp[v][k + 1][x][0], cur_cost + ComputeCost(K[k]));
}
if (x < X.size()) {
dp[v][k][x + 1][0] =
min(dp[v][k][x + 1][0], cur_cost + ComputeCost(X[x]));
}
}
}
}
}
cout << min(dp[V.size()][K.size()][X.size()][0],
dp[V.size()][K.size()][X.size()][1])
<< endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int bigmod(long long int a, long long int b, long long int c) {
if (b == 0) {
return 1;
}
if (b % 2 == 0) {
long long int value = bigmod(a, b / 2, c);
return (value * value) % c;
} else if (b % 2 == 1) {
long long int u, v;
u = a % c;
v = bigmod(a, b - 1, c);
return (u * v) % c;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tc, m;
cin >> tc;
while (tc--) {
int h, m, c = 0, ans = 0;
cin >> h >> m;
if (h == 23 && m != 0) {
cout << 60 - m << endl;
continue;
} else if (h == 23 && m == 0) {
cout << 60 << endl;
continue;
} else if (m == 0) {
cout << (24 - h) * 60 << endl;
continue;
}
if (m != 0) h++;
c = (24 - h) * 60;
ans = (60 - m) + c;
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long a, b, c;
cin >> a >> b >> c;
string s[a];
for (long long i = 0; i < a; i++) {
cin >> s[i];
}
long long ct = 0;
for (long long i = 0; i < a; i++)
for (long long j = 0; j < b; j++)
if (s[i][j] == 'R') ct++;
long long val = ct % c;
long long v = 1;
char g[62];
for (long long i = 0; i < 26; i++) g[i] = 'a' + i;
for (long long i = 26; i < 52; i++) g[i] = 'A' + (i - 26);
for (long long i = 52; i < 62; i++) g[i] = '0' + (i - 52);
long long cpo = 0;
long long counter = 0;
char mat[a][b];
for (long long i = 0; i < a; i++) {
if (i % 2 == 0) {
for (long long j = 0; j < b; j++) {
if (s[i][j] == 'R') cpo++;
if (counter + 1 <= val && cpo == (ct / c) + 2) {
cpo = 1;
counter++;
} else if (counter + 1 > val && cpo == (ct / c) + 1) {
counter++;
cpo = 1;
}
mat[i][j] = g[counter];
}
} else {
for (long long j = b - 1; j >= 0; j--) {
if (s[i][j] == 'R') cpo++;
if (counter + 1 <= val && cpo == (ct / c) + 2) {
cpo = 1;
counter++;
} else if (counter + 1 > val && cpo == (ct / c) + 1) {
counter++;
cpo = 1;
}
mat[i][j] = g[counter];
}
}
}
for (long long i = 0; i < a; i++) {
for (long long j = 0; j < b; j++) {
cout << mat[i][j];
}
cout << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int n, x, y, t;
cin >> t;
while (t--) {
cin >> n >> x >> y;
if (x > y) swap(x, y);
int num2 = min(x + y - 1, n);
int num1 = max(1, min(n, x + y + 1 - n));
cout << num1 << ' ' << num2 << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[110];
int main() {
int n, i;
while (scanf("%d", &n) != EOF) {
for (i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
printf("%d", a[n - 1]);
for (i = 1; i < n - 1; i++) printf(" %d", a[i]);
printf(" %d\n", a[0]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long int;
struct Edge {
int v;
int w;
};
class Tree {
public:
Tree(const vector<int>& a)
: a_(a),
edges_(a_.size()),
enter_time_(a_.size()),
leave_time_(a_.size()),
f1_(a_.size()),
f2_(a_.size()),
path_sum_(a_.size()),
outside_(a_.size()) {}
void AddEdge(int u, int v, int w) {
edges_[u].push_back({v, w});
edges_[v].push_back({u, w});
}
void Build() {
Dfs(0, -1);
BuildLcaTree();
outside_[0] = 0;
DfsOutside(0, -1, 0);
}
int64 Query(int u, int v) {
const int l = lca(u, v);
return path_sum_[u] + path_sum_[v] - 2 * path_sum_[l] + f1_[l] +
outside_[l];
}
int lca(int u, int v) {
if (enter_time_[u] > enter_time_[v]) {
swap(u, v);
}
u = lca_offset_ + enter_time_[u];
v = lca_offset_ + enter_time_[v];
int r = lca_tree_[u];
while (u <= v) {
if (u % 2 == 0) {
if (enter_time_[r] > enter_time_[lca_tree_[u]]) {
r = lca_tree_[u];
}
++u;
}
if (v % 2 == 1) {
if (enter_time_[r] > enter_time_[lca_tree_[v]]) {
r = lca_tree_[v];
}
--v;
}
u = (u - 1) >> 1;
v = (v - 1) >> 1;
}
return r;
}
private:
void Dfs(int u, int p) {
enter_time_[u] = lca_sequence_.size();
lca_sequence_.push_back(u);
f1_[u] = a_[u];
for (const Edge& e : edges_[u]) {
if (e.v != p) {
Dfs(e.v, u);
lca_sequence_.push_back(u);
f2_[e.v] = max(0LL, f1_[e.v] - 2 * e.w);
f1_[u] += f2_[e.v];
}
}
leave_time_[u] = lca_sequence_.size();
}
void BuildLcaTree() {
lca_offset_ = 1;
while (lca_offset_ < lca_sequence_.size()) {
lca_offset_ <<= 1;
}
while (lca_sequence_.size() < lca_offset_) {
lca_sequence_.push_back(lca_sequence_.back());
}
--lca_offset_;
lca_tree_.assign(2 * lca_offset_ + 1, -1);
for (size_t i = 0; i <= lca_offset_; ++i) {
lca_tree_[lca_offset_ + i] = lca_sequence_[i];
}
for (int i = lca_offset_ - 1; i >= 0; --i) {
int left = (i << 1) + 1;
int right = left + 1;
if (enter_time_[lca_tree_[left]] < enter_time_[lca_tree_[right]]) {
lca_tree_[i] = lca_tree_[left];
} else {
lca_tree_[i] = lca_tree_[right];
}
}
}
void DfsOutside(int u, int p, int64 sum) {
path_sum_[u] = f1_[u] - f2_[u] + sum;
for (const Edge& e : edges_[u]) {
if (e.v != p) {
outside_[e.v] = max(0LL, -2 * e.w + f1_[u] - f2_[e.v] + outside_[u]);
DfsOutside(e.v, u, path_sum_[u] - e.w);
}
}
}
const vector<int> a_;
vector<vector<Edge>> edges_;
vector<int> enter_time_;
vector<int> leave_time_;
vector<int> lca_sequence_;
vector<int> lca_tree_;
size_t lca_offset_;
vector<int64> f1_;
vector<int64> f2_;
vector<int64> path_sum_;
vector<int64> outside_;
};
void solve() {
int n, q;
scanf("%d %d", &n, &q);
vector<int> a(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
Tree t(a);
for (int i = 0; i < n - 1; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
t.AddEdge(u - 1, v - 1, w);
}
t.Build();
for (int i = 0; i < q; ++i) {
int u, v;
scanf("%d %d", &u, &v);
cout << t.Query(u - 1, v - 1) << "\n";
}
}
int main() {
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int N = 1000005;
int T, n, m;
char e, c[256], s[256], _c[256], _s[256], p[N], a[N], b[N];
inline bool add(char x, char y) {
if (c[x] != ' ' || s[y] != ' ') {
return c[x] == y;
}
c[x] = y;
s[y] = x;
return true;
}
bool solve1(int u) {
if (c[p[u]] != ' ') {
return a[u] < c[p[u]] && c[p[u]] < b[u];
}
for (char i = a[u] + 1; i < b[u]; i++) {
if (s[i] == ' ') {
add(p[u], i);
return true;
}
}
return false;
}
bool solve2(int u) {
if (!add(p[u], a[u])) {
return false;
}
for (int i = u + 1; i < n; i++) {
bool flag = true;
for (char j = e; j >= a[i]; j--) {
if (add(p[i], j)) {
if (j == a[i]) {
flag = false;
} else {
return true;
}
}
}
if (flag) {
return false;
}
}
return true;
}
bool solve3(int u) {
if (!add(p[u], b[u])) {
return false;
}
for (int i = u + 1; i < n; i++) {
bool flag = true;
for (char j = 'a'; j <= b[i]; j++) {
if (add(p[i], j)) {
if (j == b[i]) {
flag = false;
} else {
return true;
}
}
}
if (flag) {
return false;
}
}
return true;
}
bool check() {
for (char i = 'a'; i <= e; i++) {
c[i] = ' ';
s[i] = ' ';
}
for (int i = 0; i < n; i++) {
if (a[i] == b[i]) {
if (!add(p[i], a[i])) {
return false;
}
} else {
if (solve1(i)) {
break;
}
for (int j = 'a'; j <= e; j++) {
_c[j] = c[j];
_s[j] = s[j];
}
if (solve2(i)) {
break;
}
for (int j = 'a'; j <= e; j++) {
c[j] = _c[j];
s[j] = _s[j];
}
if (solve3(i)) {
break;
}
return false;
}
}
for (char i = 'a', j = 'a'; i <= e; i++) {
if (c[i] == ' ') {
while (s[j] != ' ') {
j++;
}
c[i] = j;
s[j] = i;
}
}
return true;
}
int main() {
for (scanf("%d", &T); T; T--) {
scanf("%d%s%s%s", &m, p, a, b);
n = strlen(p);
e = 'a' + m - 1;
if (check()) {
printf("YES\n");
for (int i = 'a'; i <= e; i++) {
putchar(c[i]);
}
putchar('\n');
} else {
printf("NO\n");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a1, a2, a3, b1, b2, b3;
cin >> a1 >> a2 >> a3;
cin >> b1 >> b2 >> b3;
cin >> n;
int totalcups = a1 + a2 + a3;
int totalmedals = b1 + b2 + b3;
if (((ceil((float)totalcups / 5) + ceil((float)totalmedals / 10))) <= n) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O0")
#pragma GCC optimize("O1")
long long pw(int a, int b) {
long long ret = 1;
long long mul = a;
while (b > 0) {
if (b & 1) ret *= mul;
mul *= mul;
b /= 2;
}
return ret;
}
long long to_int(string s) {
long long ret = 0;
for (int(i) = (0); (i) < (s.size()); (i)++) {
ret += pw(10, s.size() - i - 1) * (long long)(s[i] - '0');
}
return ret;
}
struct ed {
long long e, l, r, sel;
};
int main() {
int n, m, k, s1, s2, f;
cin >> n >> m >> k >> s1 >> s2 >> f;
s1--, s2--, f--;
vector<ed> edges(m + k);
vector<vector<int> > adj(n);
for (int(i) = (0); (i) < (m); (i)++) {
int s, e, l;
cin >> s >> e >> l;
s--, e--;
adj[s].push_back(i);
edges[i] = {e, l, l};
}
for (int(i) = (0); (i) < (k); (i)++) {
int s, e, l, r;
cin >> s >> e >> l >> r;
s--, e--;
adj[s].push_back(m + i);
edges[m + i] = {e, l, r, l};
}
if (s1 == s2) {
cout << "DRAW\n";
for (int(i) = (m); (i) < (m + k); (i)++) cout << edges[i].sel << " ";
cout << "\n";
return 0;
}
vector<int> mark(n);
vector<long long> dis(n, 1e17);
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
Q;
Q.push({0ll, s1}), Q.push({0ll, s2}), mark[s2] = 2, mark[s1] = 1,
dis[s1] = 0ll, dis[s2] = 0ll;
while (Q.size()) {
int v = Q.top().second, dv = Q.top().first;
Q.pop();
if (dis[v] != dv) continue;
for (int(i) = (0); (i) < (adj[v].size()); (i)++) {
int to = edges[adj[v][i]].e;
long long l = edges[adj[v][i]].l, r = edges[adj[v][i]].r;
if (mark[v] == 1) {
edges[adj[v][i]].sel = l;
if (dis[to] > dis[v] + l) {
mark[to] = 1, dis[to] = dis[v] + l;
Q.push({dis[to], to});
}
} else {
edges[adj[v][i]].sel = r;
if (dis[to] >= dis[v] + r) {
mark[to] = 2, dis[to] = dis[v] + r;
Q.push({dis[to], to});
}
}
}
}
if (mark[f] == 1) {
cout << "WIN\n";
for (int(i) = (m); (i) < (m + k); (i)++) cout << edges[i].sel << " ";
cout << "\n";
return 0;
}
dis.assign(n, 1e9);
Q.push({0, s1}), Q.push({0, s2}), mark[s1] = 1, mark[s2] = 2, dis[s1] = 0,
dis[s2] = 0;
while (Q.size()) {
int v = Q.top().second, dv = Q.top().first;
Q.pop();
if (dis[v] != dv) continue;
for (int(i) = (0); (i) < (adj[v].size()); (i)++) {
int to = edges[adj[v][i]].e;
int l = edges[adj[v][i]].l, r = edges[adj[v][i]].r;
if (mark[v] == 1) {
edges[adj[v][i]].sel = l;
if (dis[to] >= dis[v] + l) {
mark[to] = 1, dis[to] = dis[v] + l;
Q.push({dis[to], to});
}
} else {
edges[adj[v][i]].sel = r;
if (dis[to] > dis[v] + r) {
mark[to] = 2, dis[to] = dis[v] + r;
Q.push({dis[to], to});
}
}
}
}
if (mark[f] == 1) {
cout << "DRAW\n";
for (int(i) = (m); (i) < (m + k); (i)++) cout << edges[i].sel << " ";
cout << "\n";
} else
cout << "LOSE\n";
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 100;
const int mod = 998244353;
int n;
long long a;
long long x[MAX];
int main() {
scanf("%d", &n);
x[0] = 1;
for (int i = 1; i <= n; i++) {
x[i] = (x[i - 1] * 2) % mod;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
long long t = (x[n - i] + (x[n - i - 1] * (n - i)) % mod) % mod;
ans = (ans + (a * t) % mod) % mod;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read_char() {
static char buf[1 << 16], *ptr = buf, *end_ptr = buf;
if (ptr == end_ptr) {
int len = fread(buf, 1, sizeof(buf), stdin);
if (len <= 0) return EOF;
ptr = buf;
end_ptr = buf + len;
}
return *ptr++;
}
inline int readint() {
int t = 0;
char c;
bool negative = false;
c = read_char();
while (c < '0' && c > '9') {
if (c == '-') negative = true;
c = read_char();
}
while (c >= '0' && c <= '9') {
t = (t << 3) + (t << 1) + c - '0';
c = read_char();
}
if (negative) t = ~(t - 1);
return t;
}
inline void printint(int a) {
if (a == 0) {
putchar('0');
return;
}
char buf[10], x = 0;
while (a) {
buf[x++] = a % 10;
a /= 10;
}
while (x) {
putchar(buf[--x] + 48);
}
}
long long modpow(long long x, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * x % 1000000007;
x = x * x % 1000000007;
n >>= 1;
}
return res;
}
int n, a, b;
int __attribute__((aligned(64))) xa[100005], ya[100005];
int __attribute__((aligned(64))) xb[100005], yb[100005];
vector<pair<int, int> > A, B;
vector<pair<int, int> > c, d;
vector<int> za;
long long __attribute__((aligned(64))) dp[400005][2];
long long __attribute__((aligned(64))) dp2[100005][2];
long long __attribute__((aligned(64))) dp3[100005][2];
struct RMQ {
long long seg[(1 << 20)];
void update(int k, long long a) {
k += (1 << 20) / 2 - 1;
seg[k] = (seg[k] + a) % 1000000007;
while (k > 0) {
k = (k - 1) / 2;
seg[k] = (seg[k * 2 + 1] + seg[k * 2 + 2]) % 1000000007;
}
}
long long query(int a, int b, int k, int l, int r) {
if (r < a || b < l || a > b) return 0;
if (a <= l && r <= b)
return seg[k];
else {
long long vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
long long vr = query(a, b, k * 2 + 2, (l + r) / 2 + 1, r);
return (vl + vr) % 1000000007;
}
}
long long query(int a, int b) { return query(a, b, 0, 0, (1 << 20) / 2 - 1); }
} kaede[2], kaede2[2], kaede3[2];
int main() {
n = readint();
a = readint();
b = readint();
for (int i = 1; i <= a; i++) {
xa[i] = readint();
ya[i] = readint();
za.push_back(xa[i]);
za.push_back(ya[i]);
A.push_back(make_pair(xa[i], -ya[i]));
}
sort(A.begin(), A.end());
for (int i = 0; i < A.size(); i++) {
while (c.size() && c[c.size() - 1].second <= A[i].second) {
c.pop_back();
}
{ c.push_back(A[i]); }
}
for (int i = 0; i < c.size(); i++) c[i].second *= -1;
for (int i = 1; i <= b; i++) {
xb[i] = readint();
yb[i] = readint();
za.push_back(xb[i]);
za.push_back(yb[i]);
B.push_back(make_pair(xb[i], -yb[i]));
}
sort(B.begin(), B.end());
for (int i = 0; i < B.size(); i++) {
while (d.size() && d[d.size() - 1].second <= B[i].second) {
d.pop_back();
}
{ d.push_back(B[i]); }
}
for (int i = 0; i < d.size(); i++) d[i].second *= -1;
za.push_back(0);
sort(za.begin(), za.end());
za.erase(unique(za.begin(), za.end()), za.end());
dp[0][0] = 1;
kaede[0].update(0, 1);
int nxtc = 0, nxtd = 0;
for (int i = 1; i < za.size(); i++) {
if (nxtc != c.size() && za[i] == c[nxtc].second) {
int lb = -1, ub = nxtc;
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (c[mid].second < c[nxtc].first)
lb = mid;
else
ub = mid;
}
dp2[nxtc][0] = kaede2[1].query(ub, nxtc - 1);
dp2[nxtc][1] = kaede2[0].query(ub, nxtc - 1);
int k = (lower_bound(za.begin(), za.end(), c[nxtc].first) - za.begin());
dp2[nxtc][0] += modpow(2LL, c[nxtc].first - 1) *
kaede[1].query(0, k - 1) % 1000000007;
dp2[nxtc][1] += modpow(2LL, c[nxtc].first - 1) *
kaede[0].query(0, k - 1) % 1000000007;
dp2[nxtc][0] %= 1000000007;
dp2[nxtc][1] %= 1000000007;
kaede2[0].update(nxtc, dp2[nxtc][0]);
kaede2[1].update(nxtc, dp2[nxtc][1]);
kaede[0].update(i,
dp2[nxtc][0] *
modpow(modpow(2LL, c[nxtc].second), 1000000007 - 2) %
1000000007);
kaede[1].update(i,
dp2[nxtc][1] *
modpow(modpow(2LL, c[nxtc].second), 1000000007 - 2) %
1000000007);
nxtc++;
}
if (nxtd != d.size() && za[i] == d[nxtd].second) {
int lb = -1, ub = nxtd;
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (d[mid].second < d[nxtd].first)
lb = mid;
else
ub = mid;
}
dp3[nxtd][0] = kaede3[1].query(ub, nxtd - 1);
dp3[nxtd][1] = kaede3[0].query(ub, nxtd - 1);
int k = (lower_bound(za.begin(), za.end(), d[nxtd].first) - za.begin());
dp3[nxtd][0] += modpow(2LL, d[nxtd].first - 1) *
kaede[1].query(0, k - 1) % 1000000007;
dp3[nxtd][1] += modpow(2LL, d[nxtd].first - 1) *
kaede[0].query(0, k - 1) % 1000000007;
dp3[nxtd][0] %= 1000000007;
dp3[nxtd][1] %= 1000000007;
kaede3[0].update(nxtd, dp3[nxtd][0]);
kaede3[1].update(nxtd, dp3[nxtd][1]);
kaede[0].update(i,
dp3[nxtd][0] *
modpow(modpow(2LL, d[nxtd].second), 1000000007 - 2) %
1000000007);
kaede[1].update(i,
dp3[nxtd][1] *
modpow(modpow(2LL, d[nxtd].second), 1000000007 - 2) %
1000000007);
nxtd++;
}
}
long long pl = kaede[0].query(0, za.size() - 1);
pl = pl * modpow(2LL, n) % 1000000007;
long long ge = kaede[1].query(0, za.size() - 1);
ge = ge * modpow(2LL, n) % 1000000007;
long long all = modpow(2LL, n);
printint((pl - ge + 1000000007) % 1000000007);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long dp[20][20];
int p[20][20];
long long e10[19];
const int H = 1, M = 2;
int main() {
{
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int n;
cin >> n;
string s;
cin >> s;
vector<int> a(s.size());
for (int i = 0; i != 2 * n; ++i) a[i] = s[i] - '0';
e10[0] = 1;
for (int i = 1; i <= 18; ++i) e10[i] = 10 * e10[i - 1];
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
dp[i][0] = dp[i - 1][0] + e10[n - i] * a[i - 1];
p[i][0] = H;
}
for (int j = 1; j <= n; ++j) {
dp[0][j] = dp[0][j - 1] + e10[n - j] * a[j - 1];
p[0][j] = M;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
long long h = dp[i - 1][j] + e10[n - i] * a[i + j - 1];
long long m = dp[i][j - 1] + e10[n - j] * a[i + j - 1];
if (h >= m) {
dp[i][j] = h;
p[i][j] = H;
} else if (m > h) {
dp[i][j] = m;
p[i][j] = M;
}
}
int i = n, j = n;
string ans;
while (i != 0 || j != 0) {
if (p[i][j] == H) {
ans.push_back('H');
--i;
} else if (p[i][j] == M) {
ans.push_back('M');
--j;
}
}
for (int i = ans.size() - 1; i >= 0; --i) cout << ans[i];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline string tostr(const T &x) {
stringstream ss;
ss << x;
return ss.str();
}
inline long long parse(const string &s) {
stringstream ss(s);
long long x;
ss >> x;
return x;
}
const double EPS = 1e-12;
const int INF = 1000 * 1000 * 1000;
const long long LINF = INF * 1ll * INF;
const double DINF = 1e200;
const double PI = 3.1415926535897932384626433832795l;
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long gcdex(long long a, long long b, long long &x, long long &y) {
if (!a) {
x = 0, y = 1;
return b;
}
long long k = b / a;
long long g = gcdex(b - k * a, a, y, x);
x -= k * y;
return g;
}
long long inv(long long a, long long m) {
long long x, y, g;
g = gcdex(a, m, x, y);
return (x % (m / g) + m / g) % m / g;
}
long long crt(long long a1, long long m1, long long a2, long long m2) {
long long a = (a2 - a1 % m2 + m2) % m2;
long long x, y, g;
g = gcdex(m1, m2, x, y);
if (a % g) return -1;
long long m = m1 / g * m2;
x *= a / g;
x = (x % m2 + m2) % m2;
long long r = (a1 + x * m1) % m;
assert(r % m1 == a1 && r % m2 == a2);
return r;
}
long long powmod(long long a, long long p, long long m) {
long long r = 1;
while (p) {
if (p & 1) r = r * a % m;
p >>= 1;
a = a * a % m;
}
return r;
}
bool isprime(long long a) {
if (a <= 1) return false;
for (long long i = 2; i * i <= a; ++i) {
if (a % i == 0) return false;
}
return true;
}
long long sqrtup(long long a) {
if (!a) return 0;
long long x = max(0ll, (long long)sqrt((double)a));
while (x * x >= a) --x;
while ((x + 1) * (x + 1) < a) ++x;
return x + 1;
}
long long isqrt(long long a) {
long long x = max(0ll, (long long)sqrt((double)a));
while (x * x > a) --x;
while ((x + 1) * (x + 1) <= a) ++x;
return x;
}
long long sgn(long long x) { return x < 0 ? -1 : x > 0 ? 1 : 0; }
template <class T>
ostream &operator<<(ostream &s, const vector<T> &v);
template <class A, class B>
ostream &operator<<(ostream &s, const pair<A, B> &p);
template <class K, class V>
ostream &operator<<(ostream &s, const map<K, V> &m);
template <class T, size_t N>
ostream &operator<<(ostream &s, const array<T, N> &a);
template <class... T>
ostream &operator<<(ostream &s, const tuple<T...> &t);
template <class T>
ostream &operator<<(ostream &s, const vector<T> &v) {
s << '[';
for (int i = 0; i < (((int)(v).size())); ++i) {
if (i) s << ',';
s << v[i];
}
s << ']';
return s;
}
template <class A, class B>
ostream &operator<<(ostream &s, const pair<A, B> &p) {
s << "(" << p.first << "," << p.second << ")";
return s;
}
template <class K, class V>
ostream &operator<<(ostream &s, const map<K, V> &m) {
s << "{";
bool f = false;
for (const auto &it : m) {
if (f) s << ",";
f = true;
s << it.first << ": " << it.second;
}
s << "}";
return s;
}
template <class T>
ostream &operator<<(ostream &s, const set<T> &m) {
s << "{";
bool f = false;
for (const auto &it : m) {
if (f) s << ",";
f = true;
s << it;
}
s << "}";
return s;
}
template <class T>
ostream &operator<<(ostream &s, const multiset<T> &m) {
s << "{";
bool f = false;
for (const auto &it : m) {
if (f) s << ",";
f = true;
s << it;
}
s << "}";
return s;
}
template <class T, size_t N>
ostream &operator<<(ostream &s, const array<T, N> &a) {
s << '[';
for (int i = 0; i < (((int)(a).size())); ++i) {
if (i) s << ',';
s << a[i];
}
s << ']';
return s;
}
template <size_t n, class... T>
struct put1 {
static ostream &put(ostream &s, const tuple<T...> &t) {
s << get<sizeof...(T) - n>(t);
if (n > 1) s << ',';
return put1<n - 1, T...>::put(s, t);
}
};
template <class... T>
struct put1<0, T...> {
static ostream &put(ostream &s, const tuple<T...> &t) { return s; }
};
template <class... T>
ostream &operator<<(ostream &s, const tuple<T...> &t) {
s << "(";
put1<sizeof...(T), T...>::put(s, t);
s << ")";
return s;
}
ostream &put2(ostream &s, const tuple<> &t) { return s; }
template <class U>
ostream &put2(ostream &s, const tuple<U> &t) {
return s << get<0>(t);
}
template <class U, class V, class... T>
ostream &put2(ostream &s, const tuple<U, V, T...> &t) {
return s << t;
}
int main(int argc, char **argv) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(20);
int n, m;
cin >> n >> m;
vector<vector<unsigned long long>> A(
n, vector<unsigned long long>((n * 2 + 63) / 64));
vector<pair<int, int>> E;
for (int i = 0; i < (m); ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
E.push_back(make_pair(a, b));
A[a][b >> 6] |= 1ull << (b & 63);
}
for (int i = 0; i < (n); ++i) {
A[i][(i + n) >> 6] |= 1ull << ((i + n) & 63);
}
for (int i = 0; i < (n); ++i) {
int k = i;
while (k < n && !(A[k][i >> 6] & (1ull << (i & 63)))) ++k;
assert(k < n);
swap(A[i], A[k]);
for (int k = 0; k < (n); ++k) {
if (k == i) continue;
if (!(A[k][i >> 6] & (1ull << (i & 63)))) continue;
for (int j = i >> 6; j < ((int)(A[k]).size()); ++j) A[k][j] ^= A[i][j];
}
}
do {
} while (false);
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (n); ++j) {
assert((!!(A[i][j >> 6] & (1ull << (j & 63)))) == (i == j));
}
}
for (pair<int, int> e : E) {
e.first += n;
if (A[e.second][e.first >> 6] & (1ull << (e.first & 63)))
cout << "NO\n";
else
cout << "YES\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
const long long SZ = 1e5 + 7;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
const long long MOD = 998244353;
const long double PI = 3.1415926535897932384;
long long tc_cnt = 1;
auto clk = clock();
mt19937_64 rang(high_resolution_clock::now().time_since_epoch().count());
void run_time() {
cerr << endl;
cerr << "Time elapsed: " << (double)(clock() - clk) / CLOCKS_PER_SEC << endl;
return;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a / gcd(a, b)) * b;
}
void solve() {
long long int n;
cin >> n;
char c;
cin >> c;
string s;
cin >> s;
bool flag = true;
for (int i = 0; i < n; i++) {
if (s[i] != c) {
flag = false;
}
}
if (flag) {
cout << 0 << "\n";
return;
}
for (int i = n / 2; i < n; i++) {
if (s[i] == c) {
cout << 1 << "\n";
cout << i + 1 << "\n";
return;
}
}
cout << 2 << "\n";
cout << n - 1 << " " << n << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr << endl;
long long ___tc;
cin >> ___tc;
while (___tc-- > 0) {
solve();
}
run_time();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void pause() {}
int main() {
ios::sync_with_stdio(false);
int64_t i, n, f;
cin >> n >> f;
int64_t ans = 0;
vector<int64_t> a;
for (i = 0; i < n; i++) {
int l, k;
cin >> k >> l;
ans += min(k, l);
a.push_back(min(2 * k, l) - min(k, l));
}
sort(a.rbegin(), a.rend());
if (a.size() != 0) {
for (i = 0; i < f; i++) {
ans += a[i];
}
}
cout << ans;
pause();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 55;
int n, m, cnt;
long long v;
int p[MAXN];
void calc(int v) {
if (!v)
cnt += 4;
else if (v == 1 || v == 3)
cnt += 3;
else if (v == 2 || v == 4)
cnt += 2;
else
cnt += 1;
return;
}
void slv(int tmp, int v) {
if (v == 0) {
printf("%d %d %d %d\n", tmp - 1, tmp + 1, tmp, tmp + 1);
printf("%d %d %d %d\n", tmp - 1, tmp + 2, tmp, tmp + 2);
printf("%d %d %d %d\n", tmp + 1, tmp - 1, tmp + 1, tmp);
printf("%d %d %d %d\n", tmp + 2, tmp - 1, tmp + 2, tmp);
return;
}
if (v == 1) {
printf("%d %d %d %d\n", tmp - 1, tmp + 1, tmp, tmp + 1);
printf("%d %d %d %d\n", tmp - 1, tmp + 2, tmp, tmp + 2);
printf("%d %d %d %d\n", tmp + 1, tmp - 1, tmp + 1, tmp);
return;
}
if (v == 2) {
printf("%d %d %d %d\n", tmp - 1, tmp + 1, tmp, tmp + 1);
printf("%d %d %d %d\n", tmp + 1, tmp - 1, tmp + 1, tmp);
return;
}
if (v == 3) {
printf("%d %d %d %d\n", tmp - 1, tmp + 2, tmp, tmp + 2);
printf("%d %d %d %d\n", tmp + 1, tmp - 1, tmp + 1, tmp);
printf("%d %d %d %d\n", tmp + 2, tmp - 1, tmp + 2, tmp);
return;
}
if (v == 4) {
printf("%d %d %d %d\n", tmp + 1, tmp - 1, tmp + 1, tmp);
printf("%d %d %d %d\n", tmp + 2, tmp - 1, tmp + 2, tmp);
return;
}
printf("%d %d %d %d\n", tmp - 1, tmp + 1, tmp, tmp + 1);
return;
}
int main() {
scanf("%I64d", &v);
while (v) p[++p[0]] = v % 6, v /= 6;
n = m = p[0] + 1 << 1;
cnt = 2;
printf("%d %d\n", n, m);
for (int i = 1; i <= p[0]; ++i) {
int tmp = n - (i << 1);
if (i != 1) cnt += 8;
calc(p[i]);
}
printf("%d\n", cnt);
for (int i = 1; i <= p[0]; ++i) {
int tmp = n - (i << 1);
if (i != 1) {
printf("%d %d %d %d\n", tmp, tmp + 3, tmp, tmp + 4);
printf("%d %d %d %d\n", tmp - 1, tmp + 3, tmp - 1, tmp + 4);
printf("%d %d %d %d\n", tmp + 3, tmp, tmp + 4, tmp);
printf("%d %d %d %d\n", tmp + 3, tmp - 1, tmp + 4, tmp - 1);
printf("%d %d %d %d\n", tmp + 2, tmp, tmp + 3, tmp);
printf("%d %d %d %d\n", tmp + 2, tmp + 1, tmp + 3, tmp + 1);
printf("%d %d %d %d\n", tmp, tmp + 2, tmp, tmp + 3);
printf("%d %d %d %d\n", tmp + 1, tmp + 2, tmp + 1, tmp + 3);
}
slv(tmp, p[i]);
}
puts("1 2 2 2");
puts("2 1 2 2");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int an[210000];
int n;
int main() {
int T;
for (scanf("%d", &T); T; T--) {
scanf("%d", &n);
n = 2 * n;
for (int i = 0; i < n; i++) {
scanf("%d", &an[i]);
}
sort(an, an + n);
printf("%d\n", abs(an[n / 2 - 1] - an[n / 2]));
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[1000000], f[1000000];
int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
int m = 2 * n;
long long b;
while (q--) {
scanf("%I64d", &b);
int s = 0;
for (int i = 0, e = 0; i < n; ++i) {
while (e < m && ((e < n && b >= a[e]) || (e >= n && b >= a[e - n]))) {
if (e < n)
b -= a[e];
else
b -= a[e - n];
++e;
}
f[i] = e;
b += a[i];
if (e - i < f[s] - s) s = i;
}
int ans = n, T = f[s] - s;
for (int i = 0, j = s; i < T + 1; ++i) {
int cont = 0, pos = j;
while (pos - j < n && cont < ans) {
if (pos < n)
pos = f[pos];
else
pos = f[pos - n] + n;
++cont;
}
ans = min(ans, cont);
++j;
if (j == n) j = 0;
}
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int kN = 1000000 + 5;
int n, m[2], t;
int x[2][kN];
struct Event {
enum OperationType { TURN, SHOOT };
int pos, row;
OperationType op;
Event *prev;
};
int main() {
scanf("%d%d%d%d", &n, m + 0, m + 1, &t);
for (int c = 0; c < 2; ++c) {
for (int i = 0; i < m[c]; ++i) {
scanf("%d", &x[c][i]);
}
}
std::vector<std::pair<int, int>> vec;
vec.emplace_back(0, 0);
for (int p[2] = {}; p[0] < m[0] || p[1] < m[1];) {
int c = p[0] == m[0] || (p[1] < m[1] && x[0][p[0]] > x[1][p[1]]);
int v = x[c][p[c]++];
for (int i = -1; i <= 1; ++i)
if (vec.back().first < v + i) vec.emplace_back(v + i, 0);
}
for (int c = 0; c < 2; ++c) {
for (int i = 0, j = 0; i < m[c]; ++i) {
while (j < vec.size() && vec[j].first < x[c][i]) ++j;
vec[j].second |= 1 << c;
}
}
int dp[2][2] = {};
Event *path[2][2] = {};
path[0][1] = path[1][1] = new Event{0, 1, Event::TURN, NULL};
for (int i = 1; i < vec.size(); ++i) {
for (int c = 0; c < 2; ++c) {
if (vec[i].second >> c & 1) {
if (dp[0][c] >= t) {
path[0][c] = new Event{vec[i].first - 1 - (dp[0][c] - t), c,
Event::SHOOT, path[0][c]};
dp[0][c] += -t + 1;
} else {
path[0][c] = NULL;
dp[0][c] = -1;
}
path[1][c] = NULL;
dp[1][c] = -1;
} else {
int delta = vec[i].first - vec[i - 1].first;
if (dp[0][c] >= 0) dp[0][c] += delta;
if (dp[1][c] >= 0) dp[1][c] = std::min(dp[1][c] + delta, t);
}
}
for (int c = 0; c < 2; ++c) {
for (int h = 0; h < 2; ++h) {
int tmp = h ? std::min(dp[h ^ 1][c], t) : dp[h ^ 1][c];
if (dp[h][c] < tmp) {
path[h][c] = path[h ^ 1][c];
dp[h][c] = tmp;
}
}
}
for (int c = 0; c < 2; ++c)
if (~vec[i].second >> c & 1) {
for (int h = 0; h < 2; ++h)
if (dp[h][c ^ 1] >= 0) {
int tmp = h ? dp[h][c ^ 1] : 0;
if (tmp > dp[h][c]) {
path[h][c] =
new Event{vec[i].first, c, Event::TURN, path[h][c ^ 1]};
dp[h][c] = tmp;
}
}
}
for (int c = 0; c < 2; ++c) {
for (int h = 0; h < 2; ++h) {
int tmp = h ? std::min(dp[h ^ 1][c], t) : dp[h ^ 1][c];
if (dp[h][c] < tmp) {
path[h][c] = path[h ^ 1][c];
dp[h][c] = tmp;
}
}
}
}
bool result = false;
Event *p = NULL;
for (int h = 0; h < 2; ++h) {
for (int c = 0; c < 2; ++c) {
if (dp[h][c] >= 0) {
result = true;
p = path[h][c];
}
}
}
if (result) {
puts("Yes");
std::vector<int> turn;
std::vector<std::pair<int, int>> shoot;
while (p) {
if (p->op == Event::TURN)
turn.emplace_back(p->pos);
else
shoot.emplace_back(p->pos, p->row);
p = p->prev;
}
printf("%d\n", turn.size());
for (int i = (int)turn.size() - 1; i >= 0; --i)
printf("%d%c", turn[i], " \n"[i == 0]);
printf("%d\n", shoot.size());
for (int i = (int)shoot.size() - 1; i >= 0; --i)
printf("%d %d\n", shoot[i].first, shoot[i].second + 1);
} else {
puts("No");
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int cnt[10];
int match[1000056];
int main() {
int n;
scanf("%d", &n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
cnt[i % 9]++;
for (int j = 1; i * j <= n; j++) ans--;
}
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
int k = (i * j) % 9;
ans += (long long)cnt[i] * cnt[j] * cnt[k];
}
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int calc(int n) {
int ret = 0;
while (true) {
if (n == 1) return ret;
if (n & 1) return ret + (n * (n - 1)) / 2;
ret += n / 2;
n /= 2;
}
}
long long eval(long long x, long long res) {
long long p2 = (res + (x - 1) / 2);
if (p2 == 0) return 0;
if (x > (1LL << 62) / p2) return (1LL << 62);
return x * p2;
}
int main() {
long long n;
cin >> n;
int f = 0;
for (long long i = 1; i < (1LL << 60); i <<= 1) {
long long res = i - 1;
long long lo = 0, hi = 1000000000000000000LL;
while (hi > lo) {
long long mid = (lo + hi) / 2;
long long e = eval(2 * mid + 1, res);
if (e >= n)
hi = mid;
else
lo = mid + 1;
}
if ((2 * lo + 1) * (res + lo) == n) {
cout << (2 * lo + 1) * i << endl;
f = 1;
}
}
if (!f) cout << -1 << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, MaxAns, MinAns, t;
long long a, b, c;
int main() {
scanf("%I64d", &n);
MaxAns = (n + 1) * 3 * 3 - n;
MinAns = (n + 1) * 3 * 3 - n;
for (int i = 1; i * i <= n; i++) {
if (n % i) continue;
a = i;
t = n / i;
for (int j = 1; j * j <= t; j++) {
if (t % j) continue;
b = j;
c = t / j;
MaxAns = max((a + 1) * (b + 2) * (c + 2) - n, MaxAns);
MinAns = min((a + 1) * (b + 2) * (c + 2) - n, MinAns);
}
}
printf("%I64d %I64d\n", MinAns, MaxAns);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j = 0, sum = 0;
cin >> n;
int e[n], o[n], a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
sum = sum + a[i];
if (a[i] % 2 != 0) {
o[j] = a[i];
j++;
}
}
if (sum % 2 == 0) {
cout << sum;
} else {
sort(o, o + j);
sum = sum - o[0];
cout << sum;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int num[400];
for (int i = 0; i < 400; i++) num[i] = 0;
scanf("%d%d", &n, &k);
char v[n];
char c[n];
scanf("%s", &v);
for (int i = 0; i < n; i++) c[i] = v[i];
sort(v, v + n);
for (int i = 0; i < k; i++) num[v[i]] += 1;
for (int i = 0; i < n; i++)
if (num[c[i]] == 0)
printf("%c", c[i]);
else
num[c[i]] -= 1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double PI = acos(-1.0);
const long long int mod = 1e9 + 7;
const int MAXN = 1e6 + 5;
long long int fpow(long long int x, int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = res * x;
x = x * x;
y = y / 2;
}
return res;
}
void cp() {
long long int k, b, n, t;
cin >> k >> b >> n >> t;
if (k > 1) {
long long int p = k * t + b - t;
long long int q = k + b - 1;
int ans = 0;
for (int y = n; y >= 0; y--) {
if (fpow(k, n - y) * q <= p)
ans = y;
else
break;
}
cout << ans;
} else {
long long int res = 1 + (n - 1) * b;
long long int ans = 0;
while (t + (ans - 1) * b < res) ans++;
cout << ans;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
while (t--) {
cp();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int MAXN = 2e6, Mod = 1e9 + 7;
int prn, prime[MAXN + 5], mu[MAXN + 5];
bool vis[MAXN + 5];
void sieve() {
mu[1] = 1;
for (int i = 2; i <= MAXN; i++) {
if (!vis[i]) prime[++prn] = i, mu[i] = -1;
for (int j = 1; j <= prn && 1ll * i * prime[j] <= MAXN; j++) {
vis[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
mu[i * prime[j]] = -mu[i];
}
}
}
int Quick_pow(int x, int po) {
int Ans = 1;
for (; po; po >>= 1, x = 1ll * x * x % Mod)
if (po & 1) Ans = 1ll * Ans * x % Mod;
return Ans;
}
int n, k, pw[MAXN + 5], delta[MAXN + 5];
int main() {
sieve();
scanf("%d %d", &n, &k);
for (int i = 1; i <= k; i++) pw[i] = Quick_pow(i, n);
for (int p = 1; p <= k; p++)
for (int i = 1; i * p <= k; i++)
delta[i * p] =
(delta[i * p] + 1ll * mu[p] * (pw[i] - pw[i - 1] + Mod) % Mod + Mod) %
Mod;
int Ans = 0;
for (int i = 1; i <= k; i++) {
delta[i] = (delta[i] + delta[i - 1]) % Mod;
Ans = (Ans + (delta[i] ^ i)) % Mod;
}
printf("%d\n", Ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long MOD = 1e9 + 7;
long double EPS = 1e-12;
const long long INF32 = 0x3F3F3F3F;
const long long INF = 0x3F3F3F3F3F3F3F3F;
const long long crng = rng();
set<long long> prime;
vector<long long> comp;
bool isp[(long long)1e7 + 6];
void sieve(long long n = 1e7 + 5) {
memset(isp, true, sizeof(isp));
isp[0] = isp[1] = false;
for (long long j = 4; j <= n; j += 2) isp[j] = false;
for (long long i = 3; i * i <= n; i += 2) {
if (!isp[i]) continue;
for (long long j = i * i; j <= n; j += i) isp[j] = false;
}
prime.insert(2);
for (long long i = 3; i <= n; i += 2) {
if (isp[i])
prime.insert(i);
else
comp.push_back(i);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ifstream fin("input.txt");
ofstream fout("output.txt");
{
sieve(1e6);
vector<long long> ans;
for (auto i : prime) {
string s = to_string(i);
reverse((s).begin(), (s).end());
long long n = stoll(s);
if (n != i && prime.find(n) != prime.end()) ans.push_back(i);
}
long long w;
cin >> w;
cout << ans[w - 1] << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e6 + 10;
long long bit[maxn];
void update(long long idx, long long v) {
while (idx <= maxn) {
bit[idx] += v;
idx += idx & -idx;
}
}
long long query(long long idx) {
long long ans = 0;
while (idx > 0) {
ans += bit[idx];
idx -= idx & -idx;
}
return ans;
}
long long inter(long long l, long long r) { return query(r) - query(l - 1); }
void solve() {
long long n, m;
cin >> n >> m;
memset(bit, 0, sizeof bit);
vector<pair<long long, pair<long long, long long> > > hor(n), vert(m);
vector<pair<long long, pair<long long, long long> > > ord;
long long ans = 1;
for (long long i = 0; i < n; i++) {
cin >> hor[i].first >> hor[i].second.first >> hor[i].second.second;
if ((hor[i].second.first + hor[i].second.second) == 1e6) ans++;
}
for (long long i = 0; i < m; i++) {
cin >> vert[i].first >> vert[i].second.first >> vert[i].second.second;
if ((vert[i].second.first + vert[i].second.second) == 1e6) ans++;
}
for (long long i = 0; i < m; i++) {
vert[i].first++;
vert[i].second.first++;
vert[i].second.second++;
}
for (long long i = 0; i < n; i++) {
hor[i].first++;
hor[i].second.first++;
hor[i].second.second++;
}
for (long long i = 0; i < (long long)vert.size(); i++) {
ord.push_back({vert[i].first, {1, i}});
}
for (long long i = 0; i < (long long)hor.size(); i++) {
ord.push_back({hor[i].second.first, {0, i}});
ord.push_back({hor[i].second.second, {2, i}});
}
sort(ord.begin(), ord.end());
for (long long i = 0; i < (long long)ord.size(); i++) {
long long x = ord[i].first;
long long tipo = ord[i].second.first;
long long ind = ord[i].second.second;
if (tipo == 1) {
long long y1 = vert[ind].second.first;
long long y2 = vert[ind].second.second;
ans += inter(y1, y2);
} else {
long long y = hor[ind].first;
if (tipo == 2)
update(y, -1);
else
update(y, 1);
}
}
cout << ans << endl;
}
int32_t main() {
cin.tie(0);
ios::sync_with_stdio(0);
long long tc = 1;
while (tc--) solve();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T id(T b) {
return b;
};
template <class It>
bool all(It f, It l) {
return std::all_of(f, l, id<bool>);
}
template <class It>
bool any(It f, It l) {
return std::any_of(f, l, id<bool>);
}
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;
}
int n;
string s;
int diff(char c1, char c2) {
if (c1 > c2) swap(c1, c2);
return min(c2 - c1, c1 - 'A' + 'Z' - c2 + 1);
}
int main() {
cin >> n >> s;
int res = INT_MAX;
for (int i = 0; i < n - 3; i++) {
chmin(res, diff(s[i], 'A') + diff(s[i + 1], 'C') + diff(s[i + 2], 'T') +
diff(s[i + 3], 'G'));
}
cout << res << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class Reader {
char buf[262144], b;
int bi, bz;
void read() {
if (bi == bz) {
bi = 0;
bz = fread(buf, 1, 262144, stdin);
}
b = bz ? buf[bi++] : 0;
}
void skip() {
while (b > 0 && b <= 32) read();
}
public:
Reader() {
bi = bz = 0;
read();
}
unsigned int nextInt() {
unsigned int v = 0;
for (skip(); b > 32; read()) v = v * 10 + b - 48;
return v;
}
};
class SignedReader {
char arr[262144];
char *p, *e;
int s, val;
bool neg;
void getTok() {
p = arr;
s = fread(arr, 1, 262144, stdin);
e = arr + s;
}
void skip() {
while (true) {
if (p == e) getTok();
if (*p == '-' || ((*p) >= '0' && (*p) <= '9')) return;
p++;
}
}
public:
SignedReader() { getTok(); }
int nextInt() {
neg = false;
skip();
if (*p == '-') neg = true, p++;
val = 0;
while (true) {
if (p == e) getTok();
if (p == e) break;
if (((*p) >= '0' && (*p) <= '9'))
val = 10 * val + *p - 48, p++;
else
break;
}
if (neg) val = -val;
return val;
}
};
class StringIntegerParser {
char s[10005];
char *p;
public:
void readLine() {
p = s;
if (!gets(p)) p = NULL;
}
int nextInt() {
for (; !((*p) >= '0' && (*p) <= '9') && *p != '-'; p++)
;
int n = 0;
bool neg = *p == '-';
if (neg) p++;
for (; ((*p) >= '0' && (*p) <= '9'); p++) n = 10 * n + *p - 48;
if (neg) return -n;
return n;
}
bool empty() {
if (!p || !*p) return true;
for (; !((*p) >= '0' && (*p) <= '9') && *p != '-' && *p; p++)
;
return !(*p);
}
};
class StringTokenizer {
char s[10005];
char *p;
public:
void readLine() {
p = s;
if (!gets(p)) p = NULL;
}
void nextToken(char *out) {
for (; *p == ' '; p++)
;
for (; *p != ' ' && *p != 0; p++, out++) *out = *p;
*out = 0;
}
bool empty() {
if (!p || !*p) return true;
for (; *p && *p == ' '; p++)
;
return !(*p);
}
bool encounteredEOF() { return p == NULL; }
};
class CustomStringBuffer {
char arr[2000000], *p;
int len(int a) {
int i = 0;
for (; a; i++, a /= 10)
;
return i;
}
public:
CustomStringBuffer() { p = arr; }
void addNumber(int n) {
if (!n) {
*p = 48;
p++;
return;
}
if (n < 0) {
n = -n;
*p = '-';
p++;
}
int ln = len(n);
char *end = p + ln;
for (p = end - 1; n; p--, n /= 10) *p = (n % 10) | 0x30;
p = end;
}
void addLetter(char c) {
*p = c;
p++;
}
char *getStr() {
*p = 0;
return arr;
}
void addNewLine() {
*p = '\n';
p++;
}
void addSpace() {
*p = ' ';
p++;
}
};
void makeDelay(long long miliSecond) {
long long lim = miliSecond * 400000;
for (long long __w = 0; __w < lim; __w++)
;
}
int seg[1 << 21];
int qS, qE, winner;
void updateSegment(int s, int e, int i) {
if (s > qE || qS > e || seg[i]) return;
if (s >= qS && e <= qE && (winner - 1 < s || winner - 1 > e)) {
seg[i] = winner;
return;
}
if (s == e) return;
int mid = (s + e) >> 1;
updateSegment(s, mid, 2 * i);
updateSegment(mid + 1, e, 2 * i + 1);
}
void printWinners(int s, int e, int i) {
if (s == e)
printf("%d ", seg[i]);
else {
if (!seg[2 * i]) seg[2 * i] = seg[i];
if (!seg[2 * i + 1]) seg[2 * i + 1] = seg[i];
int mid = (s + e) >> 1;
printWinners(s, mid, 2 * i);
printWinners(mid + 1, e, 2 * i + 1);
}
}
int main() {
Reader in;
int n, m, i;
n = in.nextInt();
m = in.nextInt();
while (m--) {
qS = in.nextInt() - 1;
qE = in.nextInt() - 1;
winner = in.nextInt();
updateSegment(0, n - 1, 1);
}
printWinners(0, n - 1, 1);
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, c, d = 0, m;
cin >> n;
vector<int> a(n);
for (auto &x : a) cin >> x;
cin >> m;
vector<int> b(m);
for (auto &y : b) cin >> y;
sort(a.begin(), a.end());
sort(b.begin(), b.end());
cout << a[n - 1] << " " << b[m - 1] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1000;
int score1 = 0, score2 = 0;
int a[MaxN], b[MaxN];
int x;
int main() {
cin >> x;
if (x == 1) cout << 1;
if (x == 2) cout << 0;
if (x == 3) cout << 0;
if (x == 4) cout << 1;
if (x == 5) cout << 0;
if (x == 6) cout << 1;
if (x == 7) cout << 0;
if (x == 8) cout << 1;
if (x == 9) cout << 1;
if (x == 10) cout << 1;
if (x == 11) cout << 0;
if (x == 12) cout << 0;
if (x == 13) cout << 1;
if (x == 14) cout << 0;
if (x == 15) cout << 1;
if (x == 16) cout << 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n], c = 0;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = n - 1; i >= 0; i = i - k) {
c += 2 * (a[i] - 1);
}
cout << c;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long nTests;
cin >> nTests;
for (long long iTest = 0; iTest < nTests; ++iTest) {
long long nElem;
cin >> nElem;
vector<long long> tab(nElem), alt(nElem);
for (long long& elem : tab) cin >> elem;
for (long long& elem : alt) cin >> elem;
bool estInter = true, estFaux = false;
long long lastDiff = -1, iDiff = -1;
for (long long iElem = 0; iElem < nElem; ++iElem) {
if (tab[iElem] != alt[iElem]) {
if (tab[iElem] > alt[iElem]) estFaux = true;
if (iDiff != iElem - 1 && iDiff != -1) {
estInter = false;
}
if (lastDiff != alt[iElem] - tab[iElem] && lastDiff != -1)
estFaux = true;
iDiff = iElem;
lastDiff = alt[iElem] - tab[iElem];
}
}
if (!estInter || estFaux)
cout << "NO\n";
else
cout << "YES\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int MAXN = 1e5 + 1;
const int MAXK = 11;
const int MOD = 1e9 + 7;
vector<int> g[MAXN];
long long dp[MAXN][3][MAXK];
long long sdp[3][MAXK];
int m, k, x;
void fast_io() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void dfs(int u, int p) {
dp[u][0][0] = k - 1;
dp[u][1][1] = 1;
dp[u][2][0] = m - k;
for (auto v : g[u]) {
if (v == p) continue;
dfs(v, u);
memset(sdp, 0, sizeof(sdp));
for (int i = 0; i <= x; i++) {
for (int j = 0; j <= i; j++) {
sdp[0][i] +=
dp[u][0][i - j] * (dp[v][0][j] + dp[v][1][j] + dp[v][2][j]) % MOD,
sdp[0][i] %= MOD;
sdp[1][i] += dp[u][1][i - j] * (dp[v][0][j]) % MOD, sdp[1][i] %= MOD;
sdp[2][i] += dp[u][2][i - j] * (dp[v][0][j] + dp[v][2][j]) % MOD,
sdp[2][i] %= MOD;
}
}
memcpy(dp[u], sdp, sizeof(sdp));
}
}
int main() {
fast_io();
int n, u, v;
cin >> n >> m;
for (int i = 1; i < n; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
cin >> k >> x;
dfs(1, 1);
int ans = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j <= x; j++) {
ans += dp[1][i][j];
if (ans >= MOD) ans -= MOD;
}
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class BidirIt>
BidirIt prev(BidirIt it,
typename iterator_traits<BidirIt>::difference_type n = 1) {
advance(it, -n);
return it;
}
template <class ForwardIt>
ForwardIt next(ForwardIt it,
typename iterator_traits<ForwardIt>::difference_type n = 1) {
advance(it, n);
return it;
}
const double EPS = 1e-9;
const double PI = 3.141592653589793238462;
template <typename T>
inline T sq(T a) {
return a * a;
}
const int MOD = 1e9 + 9;
inline int mul_mod(int a, int b) { return a * 1LL * b % MOD; }
inline void add_mod(int &a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
inline void sub_mod(int &a, int b) {
a -= b;
if (a < 0) a += MOD;
}
int mpow(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) res = mul_mod(res, a);
a = mul_mod(a, a);
b >>= 1;
}
return res;
}
int calc(int a, int b) {
if (b == 0) return 1;
int res = calc(a, b / 2);
int add = res;
if (b % 2 == 0) sub_mod(add, mpow(a, b / 2));
add_mod(res, mul_mod(mpow(a, b / 2 + 1), add));
return res;
}
int main() {
int n, a, b, k;
scanf("%d %d %d %d ", &n, &a, &b, &k);
int ans = 0;
for (int i = 0; i < k; i++) {
if (getchar_unlocked() == '+')
add_mod(ans, mul_mod(mpow(b, i), mpow(a, n - i)));
else
sub_mod(ans, mul_mod(mpow(b, i), mpow(a, n - i)));
}
int c = mul_mod(mpow(mpow(a, k), MOD - 2), mpow(b, k));
printf("%d\n", mul_mod(ans, calc(c, (n + 1) / k - 1)));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using std::vector;
const int N = 200010;
int _w;
int T, n;
char s[N];
namespace SAM {
int ch[N][26], nid;
int len[N], par[N], cnt[N];
vector<int> buc[N];
int append(int p, int c) {
int np = nid++;
len[np] = len[p] + 1;
while (p != -1 && !ch[p][c]) ch[p][c] = np, p = par[p];
if (p == -1) {
par[np] = 0;
} else {
int q = ch[p][c];
if (len[q] == len[p] + 1) {
par[np] = q;
} else {
int nq = nid++;
for (int i = 0; i < 26; ++i) ch[nq][i] = ch[q][i];
par[nq] = par[q];
len[nq] = len[p] + 1;
par[q] = par[np] = nq;
while (p != -1 && ch[p][c] == q) ch[p][c] = nq, p = par[p];
}
}
return np;
}
void build(char *s) {
memset(ch, 0, sizeof ch);
nid = 1;
len[0] = 0, par[0] = -1;
int u = 0;
for (; *s; ++s) u = append(u, *s - 'a');
}
void solve(char *s) {
memset(cnt, 0, sizeof cnt);
int u = 0;
for (; *s; ++s) {
u = ch[u][*s - 'a'];
++cnt[u];
}
for (int i = 0; i <= n; ++i) buc[i].clear();
for (int i = 1; i < nid; ++i) buc[len[i]].push_back(i);
for (int i = n; i; --i)
for (int j = 0; j < (int)buc[i].size(); ++j) {
int u = buc[i][j];
cnt[par[u]] += cnt[u];
}
long long ans = 0;
for (int i = 1; i < nid; ++i)
ans += 1LL * cnt[i] * cnt[i] * (len[i] - len[par[i]]);
printf("%lld\n", ans);
}
} // namespace SAM
int main() {
_w = scanf("%d", &T);
while (T--) {
_w = scanf("%s", s);
n = (int)strlen(s);
SAM::build(s);
SAM::solve(s);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool comp[30000];
int P[30000];
int seive(int n, int* P) {
int p, q, K = 0;
comp[1] = true;
char even = 1;
for (p = 2; p * p <= n; p += 2) {
if (!comp[p]) {
for (q = p * p; q <= n; q += p * (2 - even)) comp[q] = true;
}
if (p == 2) --p, even = 0;
}
for (int i = (1); i <= (n); ++i)
if (!comp[i]) P[K++] = i;
return K;
}
int muls[30000];
int has[30000];
int main() {
int K;
cin >> K;
int lim = 2 * K * K;
int least = (K + 1) / 2;
vector<int> ans;
ans.push_back(1);
int max_added = 0;
int L = seive(5 * K, P);
for (int l = 0; l < L && ((int)ans.size()) < K; ++l) {
for (int l2 = 0; l2 < (l); ++l2) {
has[l2] = 0;
for (int i = 0; i < (((int)ans.size())); ++i)
if (!(ans[i] % P[l2])) ++has[l2];
}
int p = P[l];
set<int> tmp;
for (long long q = p; q <= lim; q *= p) {
for (int i = 0; i < ((int)ans.size()) && (ans[i] % p); ++i) {
long long new_num = 1ll * q * ans[i];
if (new_num <= lim) {
tmp.insert(new_num);
}
}
}
set<int>::iterator it = tmp.begin();
for (int i = 0; it != tmp.end() && i < least; ++it) {
int v = *it;
assert(!(v % p));
for (int j = 0; j < (l); ++j)
if (!(v % P[j])) ++has[j];
if (((int)ans.size()) < K) {
ans.push_back(v);
} else {
bool found = false;
for (int j = (K - 1); j >= (0); --j) {
int w = ans[j];
bool good = true;
for (int h = (0); h <= (l); ++h) {
int& pr = P[h];
if (!(w % pr)) {
if (has[h] <= least) {
good = false;
break;
}
}
}
if (good) {
for (int h = (0); h <= (l - 1); ++h) {
int& pr = P[h];
if (!(w % pr)) {
has[h]--;
}
}
assert(ans[j] % p);
ans[j] = v;
found = true;
break;
}
}
assert(found);
assert(ans.size() == K);
}
++i;
}
assert(((int)ans.size()) <= K);
}
assert(((int)ans.size()) == K);
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
assert(((int)ans.size()) == K);
for (int l = 0; l < (L); ++l) {
int cnt = 0;
for (int i = 0; i < ((int)ans.size()); ++i)
if (!(ans[i] % P[l])) {
++cnt;
}
assert(cnt == 0 || cnt >= least);
}
for (int i = 0; i < (((int)ans.size())); ++i) assert(ans[i] <= lim);
for (int i = 0; i < (K); ++i) {
if (i > 0) printf(" ");
printf("%d", ans[i]);
}
printf("\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char _c;
bool _f;
template <class T>
inline void IN(T& x) {
x = 0, _f = 0;
while (_c = getchar(), !isdigit(_c))
if (_c == '-') _f = 1;
while (isdigit(_c)) x = x * 10 + _c - '0', _c = getchar();
if (_f) x = -x;
}
template <class T>
inline void chkmin(T& x, T y) {
if (x > y) x = y;
}
template <class T>
inline void chkmax(T& x, T y) {
if (x < y) x = y;
}
const int N = 45;
const int K = 15;
inline int popcount(long long S) {
static int sum[(1 << 20) | 5], now = 1;
if (now) {
sum[0] = now = 0;
for (int lim = (1 << 20) - 1, S = 1; S <= lim; ++S)
sum[S] = sum[S ^ (S & (-S))] + 1;
}
return sum[S & 1048575] + sum[S >> 20];
}
int n, k, siz[K];
long long pres[K], oper[K], dan[K][N];
bool solve(int step, long long S) {
if (step == k + 1) {
int cnt1 = popcount(S), cnt0 = n - cnt1;
return S == (((1ll << cnt1) - 1ll) << cnt0);
}
long long T = S ^ (S & oper[step]);
int cnt1 = popcount(S & oper[step]);
int cnt0 = popcount(pres[step - 1] & oper[step]) - cnt1;
for (int i = cnt0; i <= siz[step] - cnt1; ++i)
if (!solve(step + 1, T | (oper[step] ^ dan[step][i]))) return false;
return true;
}
int main() {
IN(n), IN(k);
int p;
for (int i = 1; i <= k; ++i) {
IN(siz[i]);
for (int j = 1; j <= siz[i]; ++j)
IN(p), oper[i] |= 1ll << (p - 1), dan[i][j] = oper[i];
pres[i] = pres[i - 1] | oper[i];
}
if (n == 1) return puts("ACCEPTED");
if (pres[k] != ((1ll << n) - 1ll)) return puts("REJECTED"), 0;
puts(solve(1, 0) ? "ACCEPTED" : "REJECTED");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int N = 3e5 + 10;
int n, m, st, en, w[N], v[N][2];
vector<int> e[N];
vector<pair<int, int> > v2[N];
int low[N], num[N], t[N], br[N];
queue<int> q;
int good[N], t2[N];
void prepare() {
scanf("%d%d", &n, &m);
int x, y;
for (auto i = (1); i <= (m); i++) {
scanf("%d%d%d", &x, &y, w + i);
e[x].push_back(i);
e[y].push_back(i);
v[i][0] = x;
v[i][1] = y;
}
scanf("%d%d", &st, &en);
}
void DFS(int x, int le) {
static int top = 0;
low[x] = num[x] = ++top;
for (auto i : e[x])
if (i != le) {
int y = v[i][0] + v[i][1] - x;
if (!num[y]) {
t[y] = i;
DFS(y, i);
}
low[x] = min(low[x], low[y]);
}
}
void BFS(int st) {
static int n1 = 0;
num[st] = ++n1;
q.push(st);
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto i : e[x])
if (!br[i]) {
int y = v[i][0] + v[i][1] - x;
if (w[i]) good[n1] = 1;
if (!num[y]) {
num[y] = n1;
q.push(y);
}
}
}
}
int solve() {
DFS(st, 0);
for (auto i = (1); i <= (n); i++)
if (low[i] >= num[i]) br[t[i]] = 1;
memset(num, 0, sizeof(num));
for (auto i = (1); i <= (n); i++)
if (!num[i]) BFS(i);
for (auto i = (1); i <= (m); i++)
if (br[i]) {
int x = num[v[i][0]], y = num[v[i][1]];
v2[x].push_back(pair<int, int>(y, w[i]));
v2[y].push_back(pair<int, int>(x, w[i]));
}
st = num[st], en = num[en];
q.push(st);
memset(t2, -1, sizeof(t2));
t2[st] = good[st];
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto i : v2[x])
if (t2[i.first] == -1) {
t2[i.first] = t2[x] | i.second | good[i.first];
q.push(i.first);
}
}
return t2[en];
}
int main() {
prepare();
if (solve())
cout << "YES";
else
cout << "NO";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int now[15][3], ans[15][3], nA, nB, nC, minN = 12, cnt, t[13];
void dfs(int a, int b, int c, int num, int jw, int cou, bool ifA, bool ifB) {
if (!a && !b && !c && !jw) {
minN = num;
cnt = cou;
memcpy(ans, now, sizeof(now));
return;
}
if (a % 10 + b % 10 - c % 10 + jw == 0 && c)
dfs(a / 10, b / 10, c / 10, num, 0, cou + 1, a ? 0 : 1, b ? 0 : 1);
else if (a % 10 + b % 10 - c % 10 + jw == 10 && c)
dfs(a / 10, b / 10, c / 10, num, 1, cou + 1, a ? 0 : 1, b ? 0 : 1);
else {
if (minN - ++num <= 0) return;
now[num][2] = ++cou;
if (!ifA && c) {
now[num][0] = 1;
now[num][1] = (c % 10 - b % 10 - jw + 10) % 10;
bool f = ifB;
if (!b) ifB = 1;
dfs(a, b / 10, c / 10, num, (now[num][1] + b % 10 + jw - c % 10) / 10,
cou, ifA, ifB);
ifB = f;
}
if (!ifB && c) {
now[num][0] = 2;
now[num][1] = (c % 10 - a % 10 + 10 - jw) % 10;
bool f = ifA;
if (a == 0) ifA = 1;
dfs(a / 10, b, c / 10, num, (now[num][1] + a % 10 + jw - c % 10) / 10,
cou, ifA, ifB);
ifA = f;
}
now[num][0] = 3;
now[num][1] = (a % 10 + b % 10 + jw) % 10;
if (!a) ifA = 1;
if (!b) ifB = 1;
dfs(a / 10, b / 10, c, num, (a % 10 + b % 10 + jw - now[num][1]) / 10, cou,
ifA, ifB);
}
}
int main() {
int a, b, c;
bool f;
scanf("%d+%d=%d", &a, &b, &c);
dfs(a, b, c, 0, 0, 0, 0, 0);
int p = 1;
while (p <= minN && ans[p][0] - 1) p++;
for (int i = 1; i <= cnt; i++)
if (p <= minN && ans[p][2] == i) {
t[i] = ans[p++][1];
while (p <= minN && ans[p][0] - 1) p++;
} else {
t[i] = a % 10;
a /= 10;
}
f = 0;
for (int i = cnt; i; i--)
if (f || t[i]) {
putchar(t[i] + '0');
f = 1;
}
putchar('+');
p = 1;
while (p <= minN && ans[p][0] - 2) p++;
for (int i = 1; i <= cnt; i++)
if (p <= minN && ans[p][2] == i) {
t[i] = ans[p++][1];
while (p <= minN && ans[p][0] - 2) p++;
} else {
t[i] = b % 10;
b /= 10;
}
f = 0;
for (int i = cnt; i; i--)
if (f || t[i]) {
putchar(t[i] + '0');
f = 1;
}
putchar('=');
p = 1;
while (p <= minN && ans[p][0] - 3) p++;
for (int i = 1; i <= cnt; i++)
if (p <= minN && ans[p][2] == i) {
t[i] = ans[p][1];
p++;
while (p <= minN && ans[p][0] - 3) p++;
} else {
t[i] = c % 10;
c /= 10;
}
f = 0;
for (int i = cnt; i; i--)
if (f || t[i]) {
putchar(t[i] + '0');
f = 1;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
const long long N = 2005;
const long long MOD = 1e9 + 7;
long long n, m;
long long a[N], fact[N], invfact[N];
long long modinv(long long k) { return pow(k, MOD - 2, MOD); }
void precompute() {
fact[0] = fact[1] = 1;
for (long long i = 2; i < N; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= MOD;
}
invfact[N - 1] = modinv(fact[N - 1]);
for (long long i = N - 2; i >= 0; i--) {
invfact[i] = invfact[i + 1] * (i + 1);
invfact[i] %= MOD;
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
precompute();
cin >> n >> m;
vector<long long> v;
for (long long i = 1; i <= m; i++) {
cin >> a[i];
}
sort(a + 1, a + m + 1);
a[0] = 0;
a[m + 1] = n + 1;
for (long long i = 1; i <= m + 1; i++) {
if (a[i] - a[i - 1] - 1 > 0) v.push_back(a[i] - a[i - 1] - 1);
}
long long ans = fact[n - m];
for (auto it : v) {
ans *= invfact[it];
ans %= MOD;
}
if (a[m] != n && v.size()) v.pop_back();
long long idx = 0;
if (a[1] != 1) idx++;
for (; idx < v.size(); idx++) {
ans *= pow(2LL, v[idx] - 1, MOD);
ans %= MOD;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int t;
cin>>t;
while (t--){
int n;
cin>>n;
int a[202];
int le=0, chan=0;
for (int i=1; i<=2*n; i++){
cin>>a[i];
}
for (int i=1; i<=2*n; i++){
if (a[i]%2==0){
chan ++;
}
if (a[i]%2!=0){
le ++;
}
}
if (le==chan){
cout<<"Yes"<<endl;
} else cout<<"No"<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const char DEBUG = 0;
const int Q = 1 << 20;
mt19937 gen(
(unsigned)chrono::high_resolution_clock::now().time_since_epoch().count());
struct pp {
int min_in;
int max_in;
int lca;
pp() {}
pp(int _min_in, int _max_in) {
min_in = _min_in;
max_in = _max_in;
lca = 0;
}
};
vector<int> g[200000];
int in[200000];
int out[200000];
int h[200000];
pp tr[2 * Q];
int lca_tr[2 * Q];
int s[400001];
int min_t[200000];
int timer, n, lid;
void dfs(int v, int p = -1) {
in[v] = timer++;
out[v] = -1;
s[lid++] = v;
for (int& to : g[v])
if (to != p) {
h[to] = h[v] + 1;
dfs(to, v);
s[lid++] = v;
out[v] = in[to];
}
}
void upd_max_in(int lv, int rv, int v) {
if (lv == -1 && rv == -1)
tr[v].max_in = -1;
else if (lv != -1 && rv != -1) {
if (in[lv] > in[rv])
tr[v].max_in = lv;
else
tr[v].max_in = rv;
} else
tr[v].max_in = (lv != -1 ? lv : rv);
}
void upd_min_in(int lv, int rv, int v) {
if (lv == -1 && rv == -1)
tr[v].min_in = -1;
else if (lv != -1 && rv != -1) {
if (in[lv] < in[rv])
tr[v].min_in = lv;
else
tr[v].min_in = rv;
} else
tr[v].min_in = (lv != -1 ? lv : rv);
}
void build1(int v) {
if (v >= Q) {
if (v - Q < n)
tr[v] = pp(v - Q, v - Q);
else
tr[v] = pp(-1, -1);
} else {
build1(2 * v);
build1(2 * v + 1);
upd_max_in(tr[2 * v].max_in, tr[2 * v + 1].max_in, v);
upd_min_in(tr[2 * v].min_in, tr[2 * v + 1].min_in, v);
tr[v].lca = n;
}
}
void build2(int v) {
if (v >= Q) {
if (v - Q < lid)
lca_tr[v] = s[v - Q];
else
lca_tr[v] = n;
} else {
build2(2 * v);
build2(2 * v + 1);
if (h[lca_tr[2 * v]] < h[lca_tr[2 * v + 1]])
lca_tr[v] = lca_tr[2 * v];
else
lca_tr[v] = lca_tr[2 * v + 1];
}
}
int lca(int l, int r) {
if (l == n || r == n) return l == n ? r : l;
l = min_t[l];
r = min_t[r];
if (l > r) swap(l, r);
int res = n;
for (l += Q, r += Q + 1; l < r; l /= 2, r /= 2) {
if (l & 1) {
if (h[lca_tr[l]] < h[res]) res = lca_tr[l];
l++;
}
if (r & 1) {
--r;
if (h[lca_tr[r]] < h[res]) res = lca_tr[r];
}
}
return res;
}
int get_max(int l, int r) {
int res = -1;
for (l += Q, r += Q; l < r; l /= 2, r /= 2) {
if (l & 1) {
if (tr[l].max_in != -1 && (res == -1 || in[res] < in[tr[l].max_in]))
res = tr[l].max_in;
++l;
}
if (r & 1) {
--r;
if (tr[r].max_in != -1 && (res == -1 || in[res] < in[tr[r].max_in]))
res = tr[r].max_in;
}
}
return res;
}
int get_min(int l, int r) {
int res = -1;
for (l += Q, r += Q; l < r; l /= 2, r /= 2) {
if (l & 1) {
if (tr[l].min_in != -1 && (res == -1 || in[res] > in[tr[l].min_in]))
res = tr[l].min_in;
++l;
}
if (r & 1) {
--r;
if (tr[r].min_in != -1 && (res == -1 || in[res] > in[tr[r].min_in]))
res = tr[r].min_in;
}
}
return res;
}
int find_lca(int l, int r) {
if (l > r) return n;
int res = n;
for (l += Q, r += Q + 1; l < r; l /= 2, r /= 2) {
if (l & 1) res = lca(res, tr[l++].lca);
if (r & 1) res = lca(res, tr[--r].lca);
}
return res;
}
void add(int v, int id) {
tr[v += Q].lca = id;
for (v /= 2; v; v /= 2) tr[v].lca = lca(tr[v].lca, id);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
int q;
cin >> n >> q;
for (int i = 1; i < n; i++) {
int v;
cin >> v;
g[i].push_back(--v);
g[v].push_back(i);
min_t[i] = -1;
}
h[n] = 1000000000;
min_t[0] = -1;
dfs(0);
build1(1);
for (int i = 0; i < lid; i++)
if (min_t[s[i]] == -1) min_t[s[i]] = i;
build2(1);
for (int i = 0; i < n; i++) add(i, i);
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
--l;
--r;
int v1 = get_min(l, r + 1);
int res1 = lca(find_lca(l, v1 - 1), find_lca(v1 + 1, r));
int v2 = get_max(l, r + 1);
int res2 = lca(find_lca(l, v2 - 1), find_lca(v2 + 1, r));
if (h[res1] > h[res2])
cout << v1 + 1 << " " << h[res1] << "\n";
else
cout << v2 + 1 << " " << h[res2] << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int read() {
char ch;
int sig = 1;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') sig = -1;
int x = ch - '0';
for (ch = getchar(); ch >= '0' && ch <= '9'; ch = getchar())
x = x * 10 + ch - '0';
return x * sig;
}
const int N = 5e5 + 5, Mo = 1e9 + 7;
int n, q, a[N], fa[N], pre[N];
long long sum[N], suf[N], pw[N], S[N], an[N];
struct Que {
int l, r, id;
} ask[N];
bool cmp(Que a, Que b) { return a.r < b.r; }
int get(int x) { return fa[x] ? fa[x] = get(fa[x]) : x; }
void merge(int x, int y) {
fa[x] = y;
pre[y] = pre[x];
int len = x - pre[x];
if (len > 30 && sum[y] > 0 || (sum[x] + (sum[y] << len)) > Mo)
sum[y] = Mo;
else
sum[y] = sum[x] + (sum[y] << len);
}
long long query(int l, int r) {
return (suf[l] - suf[r + 1] * pw[r - l + 1] % Mo + Mo) % Mo;
}
int main() {
n = read();
q = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= q; i++)
ask[i].l = read(), ask[i].r = read(), ask[i].id = i;
sort(ask + 1, ask + q + 1, cmp);
for (int i = 1; i <= n; i++) pre[i] = i - 1, fa[i] = 0, sum[i] = a[i];
for (int i = n; i >= 1; i--) suf[i] = ((suf[i + 1] << 1) + a[i] + Mo) % Mo;
pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = (pw[i - 1] << 1) % Mo;
int j = 0;
for (int i = 1; i <= n; i++) {
while (pre[i] && sum[i] >= 0) merge(pre[i], i);
S[i] = (S[pre[i]] + (query(pre[i] + 1, i) << 1)) % Mo;
while (ask[j + 1].r == i) {
int x = get(ask[++j].l);
an[ask[j].id] = (S[i] - S[x] + query(ask[j].l, x) + Mo) % Mo;
}
}
for (int i = 1; i <= q; i++) printf("%lld\n", an[i]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n, m;
int parA[101010], imparA[101010], parB[101010], imparB[101010], inter[101010];
char lst;
pair<int, int> dp[101010];
pair<int, int> acc[101010];
void build() {
for (int i = 0; i < (int)s.size(); i++) {
if (s[i] == 'a') {
if (i % 2 == 0) {
parA[i] = 1;
} else {
imparA[i] = 1;
}
} else if (s[i] == 'b') {
if (i % 2 == 0) {
parB[i] = 1;
} else {
imparB[i] = 1;
}
} else {
inter[i] = 1;
}
parA[i] += (i ? parA[i - 1] : 0);
imparA[i] += (i ? imparA[i - 1] : 0);
parB[i] += (i ? parB[i - 1] : 0);
imparB[i] += (i ? imparB[i - 1] : 0);
inter[i] += (i ? inter[i - 1] : 0);
}
}
int getAPar(int l, int r) { return parA[r] - (l ? parA[l - 1] : 0); }
int getAImpar(int l, int r) { return imparA[r] - (l ? imparA[l - 1] : 0); }
int getBPar(int l, int r) { return parB[r] - (l ? parB[l - 1] : 0); }
int getBImpar(int l, int r) { return imparB[r] - (l ? imparB[l - 1] : 0); }
int getInter(int l, int r) { return inter[r] - (l ? inter[l - 1] : 0); }
bool can(int pos) {
int aFora, bFora;
if (pos % 2 == 0) {
if (lst == 'a') {
aFora = getAImpar(pos - m + 1, pos);
if (aFora > 0) return false;
bFora = getBPar(pos - m + 1, pos);
if (bFora > 0) return false;
} else {
aFora = getAPar(pos - m + 1, pos);
if (aFora > 0) return false;
bFora = getBImpar(pos - m + 1, pos);
if (bFora > 0) return false;
}
} else {
if (lst == 'a') {
aFora = getAPar(pos - m + 1, pos);
if (aFora > 0) return false;
bFora = getBImpar(pos - m + 1, pos);
if (bFora > 0) return false;
} else {
aFora = getAImpar(pos - m + 1, pos);
if (aFora > 0) return false;
bFora = getBPar(pos - m + 1, pos);
if (bFora > 0) return false;
}
}
return true;
}
int getCost(int pos) { return getInter(pos - m + 1, pos); }
pair<int, int> _max(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) return make_pair(a.first, min(a.second, b.second));
if (a.first < b.first) return b;
return a;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
cin >> s;
cin >> m;
if (m % 2)
lst = 'a';
else
lst = 'b';
build();
for (int i = 0; i < m - 1; i++) {
dp[i] = make_pair(0, 0);
}
for (int i = m - 1; i < n; i++) {
if (can(i)) {
dp[i] = make_pair(acc[i - m].first + 1, acc[i - m].second + getCost(i));
} else {
dp[i] = make_pair(0, 0);
}
acc[i] = _max((i ? acc[i - 1] : make_pair(0, 0)), dp[i]);
}
cout << acc[n - 1].second << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
#pragma comment(linker, "/STACK:256000000")
int nod(int a, int b) {
int t;
while (a) {
b %= a;
t = a;
a = b;
b = t;
}
return b;
}
int nok(int a, int b) { return (a / nod(a, b) * b); }
int main() {
long long a, b;
int k;
cin >> a >> b >> k;
long long x, y;
long long t = 1;
for (int i = 2; i <= k; i++) {
t = nok(t, i);
}
x = a % t;
y = b % t;
int *v = new int[t + 1];
int *q = new int[t + 1];
v[0] = 0;
v[1] = 1;
int j;
for (int i = 1; i <= t; i++) {
v[i] = v[i - 1] + 1;
for (j = 2; j <= k; j++) {
if (v[i] > v[i - i % j] + 1) {
v[i] = v[i - i % j] + 1;
}
}
}
for (int i = y; i > y - 17 && i >= 0; i--) {
q[i] = 100000000;
}
q[y] = 0;
for (int i = y + 1; i <= t; i++) {
q[i] = q[i - 1] + 1;
for (j = 2; j <= k; j++) {
if (q[i] > q[i - i % j] + 1) {
q[i] = q[i - i % j] + 1;
}
}
}
long long s = 0;
if (a / t == b / t) {
cout << q[a % t] << endl;
} else {
cout << (long long)v[t] * (a / t - b / t - 1) + v[a % t] + q[t - 1] + 1
<< endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, nl, nh, sl, fh, ans, rt_num, dp[1010][1010];
char s[1010], lk[100], ht[100];
struct AC_auto {
int fil, sn[26];
int v;
} T[1010];
int rd() {
sl = 0;
fh = 1;
char ch = getchar();
while (ch < '0' || '9' < ch) {
if (ch == '-') fh = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') sl = sl * 10 + ch - '0', ch = getchar();
return sl * fh;
}
void ins(char *S, int v, int ln) {
int x, d;
x = 0;
for (int i = 1; i <= ln; ++i) {
d = S[i] - 'a';
if (!T[x].sn[d]) T[x].sn[d] = ++rt_num;
x = T[x].sn[d];
}
T[x].v += v;
}
void get_fil() {
queue<int> q;
int u, v;
for (int i = 0; i < 26; ++i)
if (T[0].sn[i]) q.push(T[0].sn[i]);
while (!q.empty()) {
u = q.front();
q.pop();
T[u].v += T[T[u].fil].v;
for (int i = 0; i < 26; ++i)
if ((v = T[u].sn[i]))
T[v].fil = T[T[u].fil].sn[i], q.push(v);
else
T[u].sn[i] = T[T[u].fil].sn[i];
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
scanf("%s", lk + 1);
nl = strlen(lk + 1);
scanf("%s", ht + 1);
nh = strlen(ht + 1);
ins(lk, 1, nl);
ins(ht, -1, nh);
get_fil();
memset(dp, -127 / 3, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; ++i)
if (s[i] == '*') {
for (int j = 0; j <= rt_num; ++j)
for (int k = 0; k < 26; ++k)
if (dp[i - 1][j] + T[T[j].sn[k]].v > dp[i][T[j].sn[k]])
dp[i][T[j].sn[k]] = dp[i - 1][j] + T[T[j].sn[k]].v;
} else {
int k = s[i] - 'a';
for (int j = 0; j <= rt_num; ++j)
if (dp[i - 1][j] + T[T[j].sn[k]].v > dp[i][T[j].sn[k]])
dp[i][T[j].sn[k]] = dp[i - 1][j] + T[T[j].sn[k]].v;
}
ans = -1e9;
for (int i = 0; i <= rt_num; ++i) ans = max(ans, dp[n][i]);
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
constexpr int INF = 1e9 + 1;
constexpr long long LLINF = 1e18 + 1;
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
const int mod = 1000000007;
int add(int a, int b) {
a += b;
if (a >= mod) a -= mod;
return a;
}
int mul(int a, int b) { return a * 1LL * b % mod; }
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long a, b;
while (cin >> a >> b) {
long long res = (b * (b - 1)) / 2, rest = (a * (a + 1)) / 2;
rest %= mod;
res %= mod;
res = mul(res, add(mul(rest, b), a));
printf("%lld\n", res);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n;
while (n--) {
cin >> s;
for (int i = s.length(); i >= 0; i--) {
if (s[s.length() - 1] == 'o' && s[s.length() - 2] == 'p') {
cout << "FILIPINO" << endl;
break;
} else if (s[s.length() - 1] == 'u' && s[s.length() - 2] == 's' &&
(s[s.length() - 3] == 'e' || s[s.length() - 3] == 'a') &&
(s[s.length() - 4] == 'd' || s[s.length() - 4] == 'm')) {
cout << "JAPANESE" << endl;
break;
} else {
cout << "KOREAN" << endl;
break;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int check(int n, int b[], int c) {
for (int j = 0; j < c; j++) {
if (n == b[j]) {
return 1;
}
}
return 0;
}
int main() {
int n, m;
cin >> n >> m;
int a[n], b[m];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) {
if (check(a[i], b, m) == 1) {
cout << a[i] << " ";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<int, int>> g[10001];
vector<bool> used;
vector<pair<int, int>> s;
int t;
int done[10001];
vector<int> c;
vector<vector<int>> cc;
void dfs(int u, int e) {
t++;
done[u] = t;
for (auto v : g[u])
if (!done[v.first]) {
s.push_back(make_pair(u, e));
dfs(v.first, v.second);
if ((!s.empty()) && (s.back().second == e)) s.pop_back();
} else if (e != v.second)
if (done[v.first] < done[u]) {
s.push_back(make_pair(u, e));
cc.push_back(vector<int>());
cc.back().push_back(c[v.second]);
used[v.second] = 1;
while (s.back().first != v.first) {
used[s.back().second] = 1;
cc.back().push_back(c[s.back().second]);
s.pop_back();
}
}
}
vector<int> r;
vector<int> f;
int root(int u) {
if (r[u] < 0) return u;
return r[u] = root(r[u]);
}
void unite(int u, int v) {
u = root(u);
v = root(v);
f[u]++;
if (u == v) return;
if (r[u] > r[v]) swap(u, v);
r[u] += r[v];
f[u] += f[v];
r[v] = u;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
used.resize(m + 1, 0);
r.resize(m + 1, -1);
f.resize(m + 1, 0);
c.resize(m + 1, 0);
f[0] = 1;
for (int i = 1, u, v; i <= m; i++) {
cin >> u >> v >> c[i];
g[u].push_back(make_pair(v, i));
g[v].push_back(make_pair(u, i));
}
dfs(1, 0);
for (int i = 1; i <= m; i++)
if (!used[i]) unite(0, c[i]);
for (auto &x : cc)
for (int i = 1; i < x.size(); i++) unite(x[i], x[i - 1]);
int ans = -1;
for (int i = 0; i <= m; i++)
if (i == root(i)) {
if (f[i] >= -r[i])
ans += -r[i];
else
ans += -r[i] - 1;
}
cout << ans << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int num, hr, zong;
int main() {
int pre = -100, days = 0, tong = -1;
cin >> num;
cin.ignore();
for (int i = 1; i <= num; i++) {
string s;
getline(cin, s);
hr = (s[1] - '0') * 10 + (s[2] - '0');
if (hr == 12) hr = 0;
if (s[7] == 'p') hr += 12;
zong = hr * 60 + (s[4] - '0') * 10 + (s[5] - '0');
if (pre == -100) {
pre = zong;
days++;
tong++;
} else if (zong > pre) {
pre = zong;
tong = 0;
} else if (pre == zong && tong < 9)
tong++;
else
pre = zong, days++, tong = 0;
}
cout << days;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
if (n <= m) {
for (int i = 1; i <= n; i++) {
cout << 1;
}
cout << "\n";
for (int i = 1; i <= n; i++) {
cout << 9;
}
cout << "\n";
} else {
for (int i = 1; i <= n; i++) {
cout << 1;
}
cout << "\n";
for (int i = 1; i < n; i++) {
cout << 8;
}
cout << 9;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
while (test--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int n;
char s[20];
int ans[300100];
vector<int> dep[300100];
int G[300100][26], siz[300100], son[300100];
vector<int *> a;
void dfs(int o, int depth) {
dep[depth].push_back(o);
siz[o] = 1;
for (int i = 0; i < 26; ++i) {
if (G[o][i] == -1) continue;
dfs(G[o][i], depth + 1);
if (son[o] == -1 || siz[son[o]] < siz[G[o][i]]) {
son[o] = G[o][i];
}
siz[o] += siz[G[o][i]];
}
}
int DFS(int u, int v) {
int ret = 0;
for (int i = 0; i < 26; ++i) {
if (G[u][i] == -1) continue;
if (G[v][i] == -1) {
G[v][i] = G[u][i];
ret += siz[G[u][i]];
a.push_back(&G[v][i]);
} else {
ret += DFS(G[u][i], G[v][i]);
}
}
return ret;
}
int main() {
memset(G, -1, sizeof(G));
memset(son, -1, sizeof(son));
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d%s", &u, &v, s);
G[u][s[0] - 'a'] = v;
}
dfs(1, 0);
int tmp = 0;
for (int i = 0; i <= n; ++i) {
a.clear();
ans[i] += tmp;
for (auto &j : dep[i]) {
if (son[j] != -1) ans[i + 1] += siz[son[j]] - 1;
for (int k = 0; k < 26; ++k) {
if (G[j][k] == -1 || son[j] == G[j][k]) continue;
ans[i + 1] += DFS(G[j][k], son[j]);
}
}
for (auto &i : a) {
*i = -1;
}
tmp += (int)dep[i].size();
}
tmp = 1;
for (int i = 2; i <= n; ++i) {
if (ans[tmp] > ans[i]) {
tmp = i;
}
}
printf("%d\n%d\n", ans[tmp], tmp);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool d[500][500];
char s1[30], s2[30];
int main() {
int n, m;
scanf("%d%d", &n, &m);
scanf("%s%s", s1, s2);
memset(d, 0, sizeof(d));
for (int i = 0; i < (n); i++)
for (int j = 0; j < (m - 1); j++) {
if (s1[i] == '>')
d[i * m + j][i * m + j + 1] = true;
else
d[i * m + j + 1][i * m + j] = true;
}
for (int i = 0; i < (n - 1); i++)
for (int j = 0; j < (m); j++) {
if (s2[j] == '^')
d[(i + 1) * m + j][i * m + j] = true;
else
d[i * m + j][(i + 1) * m + j] = true;
}
for (int k = 0; k < (n * m); k++)
for (int i = 0; i < (n * m); i++)
if (k != i)
for (int j = 0; j < (n * m); j++)
if (i != j && k != j)
if (d[i][k] && d[k][j]) d[i][j] = true;
for (int i = 0; i < (n * m); i++)
for (int j = 0; j < (n * m); j++)
if (i != j && d[i][j] == false) {
printf("NO\n");
return 0;
}
printf("YES\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solveEasy(int N, int x, int y, int z, int w, int a, int b) {
N--;
printf("%d ", x);
for (int i = 0; N; i += 4) {
if (w >= i && w <= i + 3) continue;
if (x >= i && x <= i + 3) continue;
if (y >= i && y <= i + 3) continue;
if (z >= i && z <= i + 3) continue;
if (a >= i && a <= i + 3) continue;
if (b >= i && b <= i + 3) continue;
N -= 4;
printf("%d %d %d %d ", i, i + 1, i + 2, i + 3);
}
}
int main() {
int N, x;
cin >> N >> x;
if (N == 2 && x == 0) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
if (N % 4 == 1)
solveEasy(N, x, -1, -1, -1, -1, -1);
else if (N % 4 == 2) {
if (x != 0) {
cout << 0 << " ";
solveEasy(N - 1, x, -1, -1, -1, -1, -1);
} else {
cout << 1 << " " << 8 << " " << 10 << " " << 12 << " " << 15 << " ";
solveEasy(N - 5, x, 1, 8, 10, 12, 15);
}
} else if (N % 4 == 0) {
if (!(x == 1 || x == 2 || x == 3)) {
cout << 1 << " " << 2 << " " << 3 << " ";
solveEasy(N - 3, x, 1, 2, 3, -1, -1);
} else {
cout << 4 << " " << 9 << " " << 13 << " ";
solveEasy(N - 3, x, 4, 9, 13, -1, -1);
}
} else {
if (!(x == 0 || x == 1)) {
cout << 0 << " " << 1 << " ";
solveEasy(N - 2, (x ^ 1), 0, 1, -1, -1, -1);
} else {
cout << 3 << " " << 5 << " ";
solveEasy(N - 2, (x ^ 6), 3, 5, -1, -1, -1);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e5 + 5;
const long long int INF = 1e18;
const long long int mod = 1e9 + 7;
const double PI = 3.14159265358979323846;
struct node {
long long int l;
long long int r;
long long int second;
};
node a[N];
long long int n, m, x[N];
int main() {
long long int p = 0;
cin >> n >> m;
for (long long int i = 1; i <= n; i++) {
x[i] = -1;
}
for (long long int i = 0; i < m; i++) {
cin >> a[i].l >> a[i].r;
a[i].second = (a[i].r - a[i].l) + 1;
}
for (long long int i = 1; i <= n; i++) {
cout << p;
p = (1 - p);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int mx = 2e5 + 1, Mod = 1e9 + 7;
int n, k;
stack<int> mid;
int a[mx], ans[mx];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k;
int OK = 1;
for (int i = 0; i < k; i++) {
cin >> a[i];
if (!mid.empty() && mid.top() < a[i]) return cout << -1, 0;
mid.push(a[i]);
while (!mid.empty() && mid.top() == OK) {
mid.pop();
OK++;
}
}
for (int i = 0; i + k < n; i++) {
if (mid.empty()) {
ans[i] = n;
mid.push(n);
} else {
ans[i] = mid.top() - 1;
mid.push(mid.top() - 1);
}
while (!mid.empty() && mid.top() == OK) {
mid.pop();
OK++;
}
}
for (int i = 0; i < n; i++) cout << (i < k ? a[i] : ans[i - k]) << ' ';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, m;
cin >> n >> m;
long long x = n * 2, y = m * 3;
while (n >= 3 && m >= 2) {
if (x + 2 >= y + 3) {
y += 3;
m++;
} else {
x += 2;
n++;
}
n -= 3;
m -= 2;
}
cout << max(x, y) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int MAX_N = 50;
const int MAX_T = 2500;
const long long MOD = 1e9 + 7;
int T, n;
int t[MAX_N + 3], g[MAX_N + 3];
int cnt[4] = {0, 0, 0, 0};
long long sil[MAX_N + 3];
long long silMult[MAX_N + 3][MAX_N + 3][MAX_N + 3];
void input() {
std::cin >> n >> T;
for (int i = 1; i <= n; i++) std::cin >> t[i] >> g[i];
sil[0] = 1;
for (long long i = 1; i <= n; i++) sil[i] = (sil[i - 1] * i) % MOD;
for (int i = 1; i <= n; i++) cnt[g[i]]++;
}
long long dpI[MAX_N + 3][MAX_N + 3][MAX_N + 3][4];
long long all[MAX_N + 3][MAX_N + 3][MAX_N + 3];
void prepare_dpI() {
dpI[1][0][0][1] = 1;
dpI[0][1][0][2] = 1;
dpI[0][0][1][3] = 1;
for (int a = 0; a <= n; a++) {
for (int b = 0; b <= n; b++) {
for (int c = 0; c <= n; c++) {
if (a + b + c == 0) continue;
if (a > 0)
dpI[a][b][c][1] =
(dpI[a][b][c][1] + dpI[a - 1][b][c][2] + dpI[a - 1][b][c][3]) %
MOD;
if (b > 0)
dpI[a][b][c][2] =
(dpI[a][b][c][2] + dpI[a][b - 1][c][1] + dpI[a][b - 1][c][3]) %
MOD;
if (c > 0)
dpI[a][b][c][3] =
(dpI[a][b][c][3] + dpI[a][b][c - 1][1] + dpI[a][b][c - 1][2]) %
MOD;
all[a][b][c] =
(dpI[a][b][c][1] + dpI[a][b][c][2] + dpI[a][b][c][3]) % MOD;
}
}
}
all[0][0][0] = 1;
}
long long dp[MAX_T + 3][MAX_N + 3][MAX_N + 3];
void racksack() {
dp[0][0][0] = 1;
for (int i = 1; i <= n; i++) {
if (g[i] != 3) {
for (int S = T; S >= t[i]; S--) {
for (int x = cnt[1]; x >= 0; x--) {
for (int y = cnt[2]; y >= 0; y--) {
if ((x == 0 && g[i] == 1) || (y == 0 && g[i] == 2)) continue;
if (g[i] == 1)
dp[S][x][y] = (dp[S][x][y] + dp[S - t[i]][x - 1][y]) % MOD;
else
dp[S][x][y] = (dp[S][x][y] + dp[S - t[i]][x][y - 1]) % MOD;
}
}
}
}
}
}
bool isBit(int mask, int pos) { return (mask & (1 << pos)) != 0; }
void solve() {
prepare_dpI();
if (cnt[1] <= cnt[3] && cnt[1] <= cnt[2]) {
std::swap(cnt[1], cnt[3]);
for (int i = 1; i <= n; i++) {
if (g[i] == 1)
g[i] = 3;
else if (g[i] == 3)
g[i] = 1;
}
}
if (cnt[2] <= cnt[3] && cnt[2] <= cnt[1]) {
std::swap(cnt[2], cnt[3]);
for (int i = 1; i <= n; i++) {
if (g[i] == 2)
g[i] = 3;
else if (g[i] == 3)
g[i] = 2;
}
}
racksack();
long long res = 0;
std::vector<int> v;
for (int i = 1; i <= n; i++)
if (g[i] == 3) v.push_back(t[i]);
int m = v.size();
for (int a = 0; a <= n; a++)
for (int b = 0; b <= n; b++)
for (int c = 0; c <= n; c++)
silMult[a][b][c] = (((sil[a] * sil[b]) % MOD) * sil[c]) % MOD;
for (int mask = 0; mask < (1 << m); mask++) {
int h = 0;
int sum = 0;
for (int i = 0; i < m; i++) {
if (isBit(mask, i)) {
h++;
sum += v[i];
}
}
if (sum > T) continue;
for (int x = 0; x <= n; x++) {
for (int y = 0; y <= n; y++) {
long long toAdd = (all[h][x][y] * dp[T - sum][x][y]) % MOD;
toAdd = (toAdd * silMult[h][x][y]) % MOD;
res = (res + toAdd) % MOD;
}
}
}
std::cout << res << "\n";
}
int main() {
std::ios_base::sync_with_stdio(0);
std::cin.tie(NULL);
input();
solve();
}
| 9 |
// i_m_arin
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef vector<long long> vll;
typedef vector<string> vs;
typedef priority_queue<ll> pqll;
typedef pair<ll,ll> pll;
typedef vector<pll> vpll;
typedef map<ll,ll> mpll;
typedef set<ll> stll;
#define f(i, a, n) for(ll i=a; i<(ll)n; i++)
#define f2(i, a, b) for(ll i=a; i<=(ll)b; i++)
#define pb push_back
#define ff first
#define ss second
#define pf push_front
#define mp make_pair
#define all(a) (a).begin(),(a).end()
#define decimal(x) fixed<<setprecision(x)
#define fsort(a) sort(all(a))
#define rsort(a) sort(all(a),greater<>())
#define fast_io ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define lcm(a,b) (a*b)/__gcd(a,b)
#define ub(v,x) upper_bound(all(v),x)-v.begin()
#define lb(v,x) lower_bound(all(v),x)-v.begin()
const ld PI = acos(-1);
const ll MOD = 1e9+7;
const ll INF = LLONG_MAX;
const ll SIZE= 100000;
ll func(ll start,ll end){
cout<<"? "<<start<<" "<<end<<"\n";
cout.flush();
ll x;
cin>>x;
return x;
}
void solve(){
ll n;
cin>>n;
if(n==2){
ll z=func(1,2);
if(z==1){
cout<<"! "<<2<<endl;
}
else{
cout<<"! "<<1<<endl;
}
return;
}
ll x=func(1,n);
ll y=-1;
if(x!=1)
y=func(1,x);
if(x==1 || y!=x){
ll l=x,r=n;
while(l!=r){
if(r-l==1){
ll z=func(l,r);
if(z==l) break;
else{
r=l;
break;
}
}
ll mid=ceil((l+r)*1.0/2);
ll some=func(x,mid);
if(some==x){
r=mid;
}
else l=mid;
}
cout<<"! "<<r<<endl;
}
else{
ll l=1;
ll r=x;
while(l!=r){
if(r-l==1){
ll z=func(l,r);
if(z==l) break;
else{
r=l;
break;
}
}
ll mid=(l+r)/2;
ll some=func(mid,x);
if(some==x){
l=mid;
}
else r=mid;
}
cout<<"! "<<r<<endl;
}
}
int main(){
fast_io;
int t=1;
//cin>>t;
while(t--){
solve();
}
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
int read() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int x = 0;
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x;
}
const int maxn = 400002;
struct segtree {
int n, cur;
struct node {
int sum, ls, rs;
} t[maxn * 20];
int rt[maxn], ver;
int p;
void update(int &o, int l, int r) {
t[++cur] = t[o];
o = cur;
t[o].sum++;
if (l == r) return;
int mid = (l + r) / 2;
if (p <= mid)
update(t[o].ls, l, mid);
else
update(t[o].rs, mid + 1, r);
}
void update(int p) {
this->p = p;
rt[ver + 1] = rt[ver];
ver++;
if (!p) return;
update(rt[ver], 1, n);
}
int ql, qr;
int query(int o, int p, int l, int r) {
if (!p) return 0;
if (ql <= l && qr >= r) {
return t[p].sum - t[o].sum;
}
int mid = (l + r) / 2, ans = 0;
if (ql <= mid) ans += query(t[o].ls, t[p].ls, l, mid);
if (qr > mid) ans += query(t[o].rs, t[p].rs, mid + 1, r);
return ans;
}
int get(int l, int r, int ql, int qr) {
this->ql = ql, this->qr = qr;
return query(rt[l - 1], rt[r], 1, n);
}
} sgt;
struct sam {
int ch[maxn][26], f[maxn], st[maxn], pos[maxn];
int p, cur;
sam() { p = cur = 1; }
void extend(int c, int id) {
int np = ++cur;
st[np] = st[p] + 1;
pos[np] = id;
for (; p && !ch[p][c]; p = f[p]) ch[p][c] = np;
if (!p)
f[np] = 1;
else {
int pot = ch[p][c];
if (st[pot] == st[p] + 1)
f[np] = pot;
else {
int wish = ++cur;
st[wish] = st[p] + 1;
for (; ch[p][c] == pot; p = f[p]) ch[p][c] = wish;
for (int i = 0; i < 26; i++) ch[wish][i] = ch[pot][i];
pos[wish] = pos[pot];
f[wish] = f[pot];
f[pot] = f[np] = wish;
}
}
p = np;
}
int nxt[maxn], first[maxn];
void add(int u, int v) {
nxt[v] = first[u];
first[u] = v;
}
int id[maxn], en[maxn], cl;
void dfs(int u) {
id[u] = ++cl;
sgt.update(pos[u]);
for (int i = first[u]; i; i = nxt[i]) dfs(i);
en[u] = cl;
}
int ans = 1;
void dfs2(int u) {
if (f[u] == 1) {
dep[u] = 1;
lst[u] = u;
} else if (u != 1) {
int v = lst[f[u]], r = pos[u] - 1, l = pos[u] - st[u] + st[v];
if (sgt.get(id[v], en[v], l, r))
lst[u] = u, dep[u] = dep[v] + 1, ans = max(ans, dep[u]);
else
lst[u] = v, dep[u] = dep[v];
}
for (int i = first[u]; i; i = nxt[i]) dfs2(i);
}
int dep[maxn], lst[maxn];
int work(char *s) {
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) extend(s[i] - 'a', i);
sgt.n = n;
for (int i = 2; i <= cur; i++) {
add(f[i], i);
}
dfs(1);
dfs2(1);
return ans;
}
} t;
char s[200004];
int main() {
scanf("%*d%s", s + 1);
printf("%d\n", t.work(s));
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
typedef struct widget_ {
char type;
long long int w, h;
long long int border, spacing;
vector<string> filhos;
bool calculated;
} widget;
map<string, widget> m;
vector<string> all;
char line[1024];
char buf[1024];
char name[1024], name2[1024];
int n, p;
long long int w, h;
void calculate(string name) {
widget n = m[name];
if (n.calculated) return;
if (n.type == 'w') return;
m.erase(name);
for (int i = 0; i < (int)n.filhos.size(); i++) calculate(n.filhos[i]);
if (n.type == 'h') {
long long int w = 0;
long long int h = 0;
for (int i = 0; i < (int)n.filhos.size(); i++) {
w += m[n.filhos[i]].w;
h = max(h, m[n.filhos[i]].h);
}
w += 2 * n.border + ((int)n.filhos.size() - 1) * n.spacing;
h += 2 * n.border;
n.w = w;
n.h = h;
} else {
long long int w = 0;
long long int h = 0;
for (int i = 0; i < (int)n.filhos.size(); i++) {
h += m[n.filhos[i]].h;
w = max(w, m[n.filhos[i]].w);
}
h += 2 * n.border + ((int)n.filhos.size() - 1) * n.spacing;
w += 2 * n.border;
n.w = w;
n.h = h;
}
if ((int)n.filhos.size() == 0) {
n.w = 0;
n.h = 0;
}
n.calculated = true;
m[name] = n;
}
int main() {
m.clear();
all.clear();
scanf("%d", &n);
for (int c = 0; c < n; c++) {
scanf(" %[^\n]", line);
if (sscanf(line, "Widget %s", buf) == 1) {
for (p = 0; p < (int)strlen(buf); p++)
if (buf[p] == '(') break;
sscanf(buf + p, "(%I64d,%I64d)", &w, &h);
buf[p] = '\0';
strcpy(name, buf);
widget n;
n.type = 'w';
n.border = n.spacing = 0;
n.filhos.clear();
n.w = w;
n.h = h;
n.calculated = false;
string names = name;
m[names] = n;
} else if (sscanf(line, "VBox %s", name) == 1) {
widget n;
n.type = 'v';
n.border = n.spacing = n.w = n.h = 0;
n.filhos.clear();
n.calculated = false;
string names = name;
m[names] = n;
all.push_back(names);
} else if (sscanf(line, "HBox %s", name) == 1) {
widget n;
n.type = 'h';
n.border = n.spacing = n.w = n.h = 0;
n.filhos.clear();
n.calculated = false;
string names = name;
m[names] = n;
all.push_back(names);
} else {
for (p = 0; p < (int)strlen(line); p++)
if (line[p] == '.') break;
int pname = p;
for (; p < (int)strlen(line); p++)
if (line[p] == '(') break;
line[pname] = '\0';
strcpy(name, line);
string names = name;
if (sscanf(line + p, "(%I64d)", &w) == 1) {
line[p] = '\0';
if (strcmp(line + pname + 1, (char*)"set_border") == 0) {
widget n = m[names];
m.erase(names);
n.border = w;
m[names] = n;
} else if (strcmp(line + pname + 1, (char*)"set_spacing") == 0) {
widget n = m[names];
m.erase(names);
n.spacing = w;
m[names] = n;
}
} else if (sscanf(line + p, "(%s", name2) == 1) {
name2[(int)strlen(name2) - 1] = '\0';
string names2 = name2;
widget father = m[names];
m.erase(names);
father.filhos.push_back(names2);
m[names] = father;
}
}
}
for (int i = 0; i < (int)all.size(); i++) calculate(all[i]);
for (map<string, widget>::iterator i = m.begin(); i != m.end(); i++) {
string names = i->first;
widget n = i->second;
printf("%s %I64d %I64d\n", names.c_str(), n.w, n.h);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, s, k[102], v[102][102], t[102][102];
int main() {
scanf("%i %i", &n, &s);
for (int i = 1; i <= n; i++) {
scanf("%i", &k[i]);
for (int j = 1; j <= k[i]; j++) {
scanf("%i %i", &v[i][j], &t[i][j]);
t[i][j] += t[i][j - 1];
}
v[i][0] = v[i][1];
}
int ans = 0;
for (int x = 1; x <= n - 1; x++)
for (int y = x + 1; y <= n; y++) {
vector<int> s;
int c1 = 0, c2 = 0, s1 = 0, s2 = 0, time = 0;
while (c1 < k[x] && c2 < k[y]) {
if (t[x][c1 + 1] < t[y][c2 + 1]) {
c1++;
s1 += (t[x][c1] - time) * v[x][c1];
s2 += (t[x][c1] - time) * v[y][c2 + 1];
time = t[x][c1];
} else {
c2++;
s1 += (t[y][c2] - time) * v[x][c1 + 1];
s2 += (t[y][c2] - time) * v[y][c2];
time = t[y][c2];
}
if (s1 > s2)
s.push_back(1);
else if (s1 < s2)
s.push_back(2);
}
if (s.size() > 1)
for (int i = 0; i <= s.size() - 2; i++)
if (s[i] != s[i + 1]) ans++;
}
printf("%i\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, d[1002], s[1002], t, f, sum, k;
int main() {
cin >> m >> k;
for (int i = 2; i <= m + 1; i++) {
cin >> d[i];
}
for (int i = 1; i <= m; i++) {
cin >> s[i];
}
for (int i = 1; i <= m; i++) {
f += s[i];
t = max(t, s[i]);
while (f < d[i + 1]) {
sum += k, f += t;
}
sum += d[i + 1], f -= d[i + 1];
}
cout << sum;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e6 + 1, mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int ar[n + 1];
for (long long i = 1; i <= n; i++) {
int x;
cin >> x;
ar[x] = i;
}
int mim[n + 1];
memset(mim, 0, sizeof(mim));
while (m--) {
int x, y;
cin >> x >> y;
x = ar[x];
y = ar[y];
if (y < x) swap(x, y);
mim[y] = max(mim[y], x);
}
long long ans = 0;
int now = 0;
for (long long i = 1; i <= n; i++) {
now = max(now, mim[i]);
ans += i - now;
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int cnt[2][1 << 21];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, i, x = 0, p;
long long ans = 0;
cin >> n;
memset(cnt, 0, sizeof(cnt));
cnt[1][0] = 1;
for (i = 0; i < n; i++) {
cin >> p;
x ^= p;
ans += cnt[i % 2][x];
++cnt[i % 2][x];
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double w, h, a, ans;
scanf("%lf %lf %lf", &w, &h, &a);
if (h > w) swap(h, w);
a = min(a, 180 - a);
a = a * acos(-1) / 180;
if (a == 0)
ans = w * h;
else if (a <= 2 * atan(h / w)) {
ans = w * h;
ans -= tan(a) * pow((1.0 * w - (h * (1 - cos(a)) / sin(a))), 2.0) / 4.0;
ans -= tan(a) * pow((1.0 * h - (w * (1 - cos(a)) / sin(a))), 2.0) / 4.0;
} else
ans = h * h / sin(a);
printf("%.9lf\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chmax(T& a, const T& b) {
return a < b ? (a = b, true) : false;
}
template <typename T>
bool chmin(T& a, const T& b) {
return b < a ? (a = b, true) : false;
}
int N, L;
int main() {
scanf("%d%d", &N, &L);
vector<int> A(N), B(N);
for (int i = (int)(0); i < (int)(N); i++) {
scanf("%d", &A[i]);
}
for (int i = (int)(0); i < (int)(N); i++) {
scanf("%d", &B[i]);
}
deque<int> X, Y;
for (int i = (int)(0); i < (int)(N); i++) {
if (i == N - 1) {
X.push_back(A[0] + L - A[i]);
Y.push_back(B[0] + L - B[i]);
} else {
X.push_back(A[i + 1] - A[i]);
Y.push_back(B[i + 1] - B[i]);
}
}
for (int i = (int)(0); i < (int)(N * 2); i++) {
if (X == Y) {
printf("YES\n");
return 0;
}
X.push_back(X.front());
X.pop_front();
}
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char S[100005];
char P[100005];
int b[100005];
int PF[100005];
long long acum[100005];
long long accum[100005];
long long dp[100005];
const int MOD = 1000000007;
void prepro() {
int n = strlen(P);
int i = 0, j = -1;
b[i] = j;
while (i < n) {
while (j >= 0 && P[i] != P[j]) j = b[j];
i++;
j++;
b[i] = j;
}
}
void match() {
prepro();
int n = strlen(S);
int m = strlen(P);
int i = 0, j = 0;
while (i < n) {
while (j >= 0 && S[i] != P[j]) j = b[j];
i++;
j++;
if (j == m) {
PF[i] = 1;
j = b[j];
}
}
}
int main() {
scanf("%s", S);
scanf("%s", P);
match();
int lon = strlen(P);
dp[0] = 0;
accum[0] = acum[0] = 1;
for (int i = 1; S[i - 1]; i++) {
if (PF[i])
dp[i] = accum[i - lon];
else
dp[i] = dp[i - 1];
dp[i] %= MOD;
acum[i] = acum[i - 1] + dp[i];
acum[i] %= MOD;
accum[i] = acum[i] + accum[i - 1];
accum[i] %= MOD;
}
long long s = 0;
for (int i = 1; S[i - 1]; i++) {
s += dp[i];
s %= MOD;
}
cout << s << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int f[5010][5010], ans[5010][5010];
int v[5010];
int n, m;
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &v[i]), f[i][1] = v[i], ans[i][1] = v[i];
for (int len = 2; len <= n; len++)
for (int pos = 1; pos <= n - len + 1; pos++)
f[pos][len] = f[pos][len - 1] ^ f[pos + 1][len - 1];
for (int len = 2; len <= n; len++)
for (int pos = 1; pos <= n - len + 1; pos++)
ans[pos][len] =
max(f[pos][len], max(ans[pos][len - 1], ans[pos + 1][len - 1]));
}
void query() {
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d %d", &l, &r);
printf("%d\n", ans[l][r - l + 1]);
}
}
int main() {
init();
query();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, m, n, y, p, cnt = 0, ans = 0;
string s, g, s1;
vector<int> v, v1, v2;
map<int, int> mp;
pair<int, int> pr;
cin >> x;
for (int i = 0; i < x - 1; i++) {
cin >> y;
v.push_back(y);
}
sort(v.begin(), v.end());
for (int i = 1; i <= x; i++) {
if (i != v[i - 1]) return cout << i, 0;
}
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.