solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b;
cin >> n >> a >> b;
n *= 6;
long long a2 = max(a, (n + b - 1) / b), b2 = b;
long long n2 = a2 * b2;
for (long long i = a; i <= n;) {
long long k = (n + i - 1) / i;
long long r = (k == 1 ? n : (n - 1) / (k - 1));
long long x = i * max(b, k);
if (x < n2) {
n2 = x;
a2 = i;
b2 = max(b, k);
}
i = r + 1;
}
cout << n2 << '\n' << a2 << ' ' << b2 << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int AL = 26;
vector<int> val;
vector<int> pos;
struct aho_corasick {
struct node {
map<int, int> nxt, go;
int p, pch;
int suf, ssuf;
multiset<int> vals;
bool term;
node() {
nxt.clear();
go.clear();
suf = ssuf = -1;
term = false;
vals.clear();
p = -1, pch = -1;
}
};
vector<node> nodes;
aho_corasick() { nodes = vector<node>(1, node()); }
int add(const string& s) {
int v = 0;
for (int i = 0; i < int(s.size()); i++) {
int c = s[i] - 'a';
if (!nodes[v].nxt.count(c)) {
nodes.push_back(node());
nodes[v].nxt[c] = int(nodes.size()) - 1;
nodes.back().p = v;
nodes.back().pch = c;
}
v = nodes[v].nxt[c];
}
nodes[v].term = true;
nodes[v].vals.insert(0);
return v;
}
int feed(const string& s) {
int v = 0;
int ans = -1;
for (int i = 0; i < int(s.size()); i++) {
int c = s[i] - 'a';
v = go(v, c);
int u = v;
while (u != 0) {
if (!nodes[u].vals.empty()) ans = max(ans, *nodes[u].vals.rbegin());
u = ssuf(u);
}
}
return ans;
}
int go(int v, int c) {
if (nodes[v].go.count(c)) return nodes[v].go[c];
if (nodes[v].nxt.count(c)) return nodes[v].go[c] = nodes[v].nxt[c];
if (v == 0) return nodes[v].go[c] = 0;
return nodes[v].go[c] = go(suf(v), c);
}
int suf(int v) {
if (nodes[v].suf != -1) return nodes[v].suf;
if (v == 0 || nodes[v].p == 0) return nodes[v].suf = 0;
return nodes[v].suf = go(suf(nodes[v].p), nodes[v].pch);
}
int ssuf(int v) {
if (nodes[v].ssuf != -1) return nodes[v].ssuf;
if (v == 0 || nodes[v].p == 0) return nodes[v].ssuf = 0;
int s = suf(v);
if (nodes[s].term) return nodes[v].ssuf = s;
return nodes[v].ssuf = ssuf(s);
}
};
aho_corasick ac;
int main() {
int n, m;
ios::sync_with_stdio(!cin.tie(0));
cin >> n >> m;
pos.resize(n);
val.resize(n, 0);
vector<int> tp2;
ac = aho_corasick();
for (int i = 0; i < int(n); i++) {
string s;
cin >> s;
pos[i] = ac.add(s);
}
for (int i = 0; i < int(m); i++) {
int t;
cin >> t;
if (t == 1) {
int j, x;
cin >> j >> x;
--j;
ac.nodes[pos[j]].vals.erase(ac.nodes[pos[j]].vals.find(val[j]));
val[j] = x;
ac.nodes[pos[j]].vals.insert(val[j]);
} else {
string q;
cin >> q;
printf("%d\n", ac.feed(q));
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, s;
} a[220000];
node operator-(node a, node b) { return {a.x - b.x, a.y - b.y}; }
long long slope(node a, node b) { return 1ll * a.x * b.y - 1ll * a.y * b.x; }
int n, t, s[220000], d[220000];
bool cmp(node a, node b) { return a.x < b.x || (a.x == b.x && a.y < b.y); }
void build() {
t = 0;
for (int i = 0; i <= n; i++)
if (a[i].s ^ 1) {
while (t > 1 && slope(a[s[t]] - a[s[t - 1]], a[i] - a[s[t]]) <= 0) --t;
s[++t] = i;
}
int k = t;
for (int i = n; i >= 0; i--)
if (a[i].s ^ 1) {
while (t > k && slope(a[s[t]] - a[s[t - 1]], a[i] - a[s[t]]) <= 0) --t;
s[++t] = i;
}
}
bool solve() {
memcpy(d, s, sizeof s);
int T = t;
for (int i = 1; i <= T; i++)
if ((a[d[i]].x | a[d[i]].y) & 1) return 1;
for (int i = 2; i <= T - 1; i++)
if (i & 1)
a[d[i]].s = 1;
else
a[d[i]].s = 2;
build();
int p = 0;
for (int i = 2; i <= t; i++)
if ((a[s[i]].x | a[s[i]].y) & 1) return 1;
for (int i = 2; i <= T - 1; i++)
if (i & 1)
a[d[i]].s = 2;
else
a[d[i]].s = 1;
build();
for (int i = 2; i <= t; i++)
if ((a[s[i]].x | a[s[i]].y) & 1) return 1;
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].x, &a[i].y);
sort(a, a + n + 1, cmp);
build();
if (solve())
printf("Ani");
else
printf("Borna");
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long T, a, b, p, q, blc;
map<long long, long long> Mp;
map<long long, long long>::iterator it;
void solve() {
Mp.clear();
blc = sqrt(b - a) + 1;
for (long long i = 0; i < blc; i++) {
if (!Mp.count((i * p * 2) % (q * 2))) Mp[(i * p * 2) % (q * 2)] = i;
}
it = Mp.begin();
Mp[it->first + q * 2] = it->second;
it = Mp.end();
it--;
Mp[it->first - q * 2] = it->second;
long long ans = -1, mi = 1e15;
for (long long i = a; i <= b; i += blc) {
long long cr = ((q - i * p * 2) % (q * 2) + q * 2) % (q * 2);
it = Mp.lower_bound(cr);
if ((abs(cr - it->first) < mi ||
(abs(cr - it->first) == mi && it->second + i < ans)) &&
(it->second + i <= b && it->second + i >= a)) {
mi = abs(cr - it->first);
ans = it->second + i;
}
it--;
if ((abs(cr - it->first) < mi ||
(abs(cr - it->first) == mi && it->second + i < ans)) &&
(it->second + i <= b && it->second + i >= a)) {
mi = abs(cr - it->first);
ans = it->second + i;
}
if (i + blc > b) {
it = Mp.end();
while (1) {
it--;
if ((abs(cr - it->first) < mi ||
(abs(cr - it->first) == mi && it->second + i < ans)) &&
(it->second + i <= b && it->second + i >= a)) {
mi = abs(cr - it->first);
ans = it->second + i;
}
if (it == Mp.begin()) break;
}
}
}
cout << ans << endl;
}
int main() {
cin >> T;
while (T--) {
cin >> a >> b >> p >> q;
if (p > q) {
p %= q;
}
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50005;
const long long mod = 1e9 + 7;
int n, a[maxn], rt = 1;
long long m, ans;
int bac1[32][2];
int bac2[32][2];
int val[maxn * 32];
int son[maxn * 32][2];
int cnt[maxn * 32], tot = 1;
vector<pair<int, int> > pr, tmp;
void insert(int &root, int num, int bit) {
if (!root) root = ++tot;
int p = (num >> bit) & 1;
cnt[root]++;
if (bit < 0) {
val[root] = num;
return;
}
insert(son[root][p], num, bit - 1);
}
void dfs(int root, int bac[32][2]) {
if (!root) return;
if (!son[root][0] && !son[root][1]) {
int num = val[root], _cnt = cnt[root];
for (int j = 30; j >= 0; j--) bac[j][(num >> j) & 1] += _cnt;
return;
}
dfs(son[root][0], bac);
dfs(son[root][1], bac);
}
void update() {
for (int i = 0; i < pr.size(); i++) {
int ls1 = son[pr[i].first][0];
int rs1 = son[pr[i].first][1];
int ls2 = son[pr[i].second][0];
int rs2 = son[pr[i].second][1];
memset(bac1, 0, sizeof bac1);
memset(bac2, 0, sizeof bac2);
dfs(ls1, bac1);
dfs(rs2, bac2);
for (int j = 0; j < 31; j++)
ans += (1ll << j) * bac1[j][0] * bac2[j][1] +
(1ll << j) * bac1[j][1] * bac2[j][0];
if (pr[i].first == pr[i].second) continue;
memset(bac1, 0, sizeof bac1);
memset(bac2, 0, sizeof bac2);
dfs(ls2, bac1);
dfs(rs1, bac2);
for (int j = 0; j < 31; j++)
ans += (1ll << j) * bac1[j][0] * bac2[j][1] +
(1ll << j) * bac1[j][1] * bac2[j][0];
}
}
long long query() {
long long res = 0ll;
for (int i = 0; i < pr.size(); i++) {
int ls1 = son[pr[i].first][0];
int rs1 = son[pr[i].first][1];
int ls2 = son[pr[i].second][0];
int rs2 = son[pr[i].second][1];
if (ls1 && rs2) res += (long long)cnt[ls1] * cnt[rs2];
if (pr[i].first == pr[i].second) continue;
if (ls2 && rs1) res += (long long)cnt[ls2] * cnt[rs1];
}
return res;
}
void trans0() {
for (int i = 0; i < pr.size(); i++) {
int ls1 = son[pr[i].first][0];
int rs1 = son[pr[i].first][1];
int ls2 = son[pr[i].second][0];
int rs2 = son[pr[i].second][1];
if (ls1 && ls2) tmp.push_back(pair<int, int>(ls1, ls2));
if (rs1 && rs2) tmp.push_back(pair<int, int>(rs1, rs2));
}
pr.clear();
swap(pr, tmp);
}
void trans1() {
for (int i = 0; i < pr.size(); i++) {
int ls1 = son[pr[i].first][0];
int rs1 = son[pr[i].first][1];
int ls2 = son[pr[i].second][0];
int rs2 = son[pr[i].second][1];
if (ls1 && rs2) tmp.push_back(pair<int, int>(ls1, rs2));
if (pr[i].first == pr[i].second) continue;
if (ls2 && rs1) tmp.push_back(pair<int, int>(ls2, rs1));
}
pr.clear();
swap(pr, tmp);
}
int main() {
scanf("%d %lld", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), insert(rt, a[i], 30);
long long num = 0;
pr.push_back(pair<int, int>(1, 1));
for (int i = 30; i >= 0; i--) {
long long res = query();
if (res > m) {
trans1();
num |= 1ll << i;
} else {
update();
trans0();
m -= res;
}
}
ans += m * num;
ans %= mod;
printf("%I64d", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, t;
long long lcm(long long a, long long b) {
long long a1 = a, b1 = b;
while (a != 0 && b != 0) {
if (a > b)
a %= b;
else
b %= a;
}
return a1 * b1 / max(a, b);
}
int main() {
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n;
cout << 1 + lcm(4 * n, n + 1) / (n + 1) << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[30], b[30];
int id[1000], B[30], A[30], o[30], c[30][30], N, ans, n;
char s[10];
void update(int S) {
int res = 0, ret = 0;
for (int i = 0; i <= 5; i++) a[i] = A[i], b[i] = B[i];
for (int j = 0; j < 10; j++) o[j] = (S >> j) & 1, res += o[j];
for (int j = 0; j < 5; j++)
for (int k = 1; k <= 5; k++)
if (c[j][k])
if (o[j] && o[k + 4]) ret++, a[j]--, b[k]--;
for (int j = 0; j < 5; j++)
for (int k = 1; k <= 5; k++)
if (c[j][k]) {
if (!(o[j] ^ o[k + 4])) continue;
if ((o[j] && a[j] == 1) || (o[k + 4] && b[k] == 1)) ret++;
}
if (ret < N - 1) return;
ans = min(ans, res);
}
int main() {
id['R'] = 0;
id['G'] = 1;
id['B'] = 2;
id['Y'] = 3;
id['W'] = 4;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%s", s), c[id[s[0]]][s[1] - '0']++;
N = 0;
ans = 1 << 30;
for (int i = 0; i < 5; i++)
for (int j = 1; j <= 5; j++)
if (c[i][j]) A[i]++, B[j]++, N++;
for (int i = 0; i < 1 << 10; i++) update(i);
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int bt = 10, n = 512;
vector<long long> a;
long long v;
for (int(k) = 1; (k) <= (bt); (k)++) {
for (int(i) = 0; (i) < ((1 << k)); (i)++) {
v = 0;
for (int(j) = 0; (j) < (k); (j)++) {
v *= 10;
if (i & (1 << (k - 1 - j)))
v += 7;
else
v += 4;
}
a.push_back(v);
}
}
int la = a.size();
int l, r;
cin >> l >> r;
int in = lower_bound((a).begin(), (a).end(), (l)) - (a).begin(), prev = l;
long long ans = 0;
ans += a[in];
while (a[in] <= r) {
ans += (a[in] - prev) * a[in];
prev = a[in];
in++;
}
ans += (r - prev) * a[in];
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long ret = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') ret = ret * 10 + c - '0', c = getchar();
return ret;
}
const int MAXN = 3005;
int N;
struct node {
int v, next;
} E[MAXN << 1];
int head[MAXN], Elen;
void add(int u, int v) {
++Elen, E[Elen].v = v, E[Elen].next = head[u], head[u] = Elen;
}
long long siz[MAXN], Siz[MAXN], Dp[MAXN][MAXN];
int fa[MAXN], dfn[MAXN], dfncnt, redfn[MAXN];
void dfs(int u, int ff) {
siz[u] = 1, fa[u] = ff, dfn[u] = ++dfncnt, redfn[dfncnt] = u;
for (int i = head[u]; i; i = E[i].next)
if (E[i].v != ff) dfs(E[i].v, u), siz[u] += siz[E[i].v];
}
long long getdp(long long dp[][MAXN], int u, int v, int del = 0, int add = 0) {
if (dp[u][v]) return dp[u][v];
int i;
long long ret = 0;
for (i = head[u]; i; i = E[i].next)
if (E[i].v != fa[u] && E[i].v != del)
ret = max(ret, getdp(dp, E[i].v, v, del, add));
if (add) ret = max(ret, getdp(dp, add, v, del, add));
for (i = head[v]; i; i = E[i].next)
if (E[i].v != fa[v]) ret = max(ret, getdp(dp, u, E[i].v, del, add));
dp[u][v] = siz[u] * siz[v] + ret;
return dp[u][v];
}
long long f[MAXN][MAXN], ans;
void dfs2(int u, int ff) {
int i;
if (u != 1) {
for (i = dfn[u]; i <= dfn[u] + siz[u] - 1; ++i) f[fa[u]][redfn[i]] = 0;
siz[fa[u]] = N - Siz[u];
for (i = dfn[u]; i <= dfn[u] + siz[u] - 1; ++i)
getdp(f, fa[u], redfn[i], u, fa[fa[u]]);
ans = max(ans, f[fa[u]][u]);
for (i = head[u]; i; i = E[i].next)
if (E[i].v != ff) dfs2(E[i].v, u);
for (i = dfn[u]; i <= dfn[u] + siz[u] - 1; ++i)
f[fa[u]][redfn[i]] = Dp[fa[u]][redfn[i]];
siz[fa[u]] = Siz[fa[u]];
} else {
for (i = head[u]; i; i = E[i].next)
if (E[i].v != ff) dfs2(E[i].v, u);
}
}
int main() {
scanf("%d", &N);
int i, j, u, v;
for (i = 1; i < N; ++i) scanf("%d%d", &u, &v), add(u, v), add(v, u);
dfs(1, 0);
for (i = 1; i <= N; ++i) Siz[i] = siz[i];
for (i = 1; i <= N; ++i)
for (j = 1; j <= N; ++j) f[i][j] = getdp(Dp, i, j);
dfs2(1, 0);
printf("%lld\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
const int N = 3e5 + 5, K = 19;
int n, q, A[N], id[N];
bool ans[N];
int g[K][K], last[K];
int gk[N][K];
vector<pair<int, int> > qs[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int x = (0), qwerty = (K); x < qwerty; x++) id[1 << x] = x;
for (int x = (0), qwerty = (n); x < qwerty; x++) cin >> A[x];
for (int _ = (0), qwerty = (q); _ < qwerty; _++) {
int a, b;
cin >> a >> b;
a--;
b--;
qs[a].push_back({b, _});
}
for (int x = (0), qwerty = (K); x < qwerty; x++) last[x] = N - 1;
for (int x = (0), qwerty = (K); x < qwerty; x++) gk[N - 1][x] = N - 1;
for (int x = n - 1; x >= 0; x--) {
for (int i = (0), qwerty = (K); i < qwerty; i++) {
gk[x][i] = (A[x] & (1 << i)) ? x : N - 1;
}
for (int i = (0), qwerty = (K); i < qwerty; i++)
if (A[x] & (1 << i)) {
for (int j = (0), qwerty = (K); j < qwerty; j++)
gk[x][j] = min(gk[last[i]][j], gk[x][j]);
last[i] = x;
}
for (auto p : qs[x]) {
int mn = N;
for (int j = (0), qwerty = (K); j < qwerty; j++)
if (A[p.first] & (1 << j)) {
mn = min(mn, gk[x][j]);
}
ans[p.second] = mn <= p.first;
}
}
for (int x = (0), qwerty = (q); x < qwerty; x++)
cout << (ans[x] ? "Shi" : "Fou") << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double PI = (acos(-1));
long long md = 1000000007;
long long ma = 998244353;
long long pw(long long a, long long b) {
long long c = 1, m = a;
while (b) {
if (b & 1) c = (c * m);
m = (m * m);
b /= 2;
}
return c;
}
long long pwmd(long long a, long long b) {
long long c = 1, m = a;
while (b) {
if (b & 1) c = ((c * m)) % md;
m = (m * m) % md;
b /= 2;
}
return c;
}
long long modinv(long long n) { return pwmd(n, md - 2); }
long long min(long long a, long long b) {
if (a >= b) return b;
return a;
}
long long nc2(long long n) { return (1ll * n * (n - 1)) / 2; }
long long nsum(long long n) { return (1ll * n * (n + 1)) / 2; }
bool prime(long long a) {
for (int i = 2; i * i <= a; i++) {
if (a % i == 0) return false;
}
return true;
}
void Sieve(vector<int> &primes) {
bool IsPrime[100005];
memset(IsPrime, true, sizeof(IsPrime));
for (int p = 2; p * p < 100005; p++) {
if (IsPrime[p] == true) {
for (int i = p * p; i < 100005; i += p) IsPrime[i] = false;
}
}
for (int p = 2; p < 100005; p++)
if (IsPrime[p]) primes.push_back(p);
}
vector<char> sml = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
vector<char> cap = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
void solve() {
long long n;
cin >> n;
string s;
cin >> s;
long long x = 0, y = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
if (s[i] == '1')
x++;
else
y++;
} else {
if (s[i] == '1')
y++;
else
x++;
}
}
cout << min(x, y) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long tests = 1;
while (tests--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using lln = long long int;
using ls = string;
using ch = char;
using lld = long double;
using lf = float;
using ll = int;
using ld = double;
unordered_map<char, int> mark;
vector<pair<ll, ll> > v;
double mini(double a, double b) {
if (a >= b)
return b;
else
return a;
}
int check(ll x, ll y, double mdis) {
double dis = double(1e9);
for (ll i = 0; i < int(v.size()); i++) {
ll t1 = (v[i].first - x);
ll t2 = v[i].second - y;
double d = sqrt(t1 * t1 + t2 * t2);
if (d <= mdis) return -1;
}
return 1;
}
char convert(char c) {
if (c >= 'A' && c <= 'Z') return tolower(c);
if (c >= 'a' && c <= 'z') return toupper(c);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n, m;
double x;
cin >> n >> m;
cin >> x;
char arr[n + 1][m + 1];
for (ll i = 1; i <= n; i++) {
for (ll j = 1; j <= m; j++) {
cin >> arr[i][j];
if (arr[i][j] == 'S')
v.push_back({i, j});
else
mark[arr[i][j]] = 1;
}
}
unordered_map<char, double> dis;
for (ll i = 1; i <= n; i++) {
for (ll j = 1; j <= m; j++) {
if (arr[i][j] >= 'a' && arr[i][j] <= 'z') {
if (dis[arr[i][j]] == -1) continue;
dis[arr[i][j]] = check(i, j, x);
}
}
}
ll q;
cin >> q;
string s;
cin >> s;
ll ans = 0;
for (ll i = 0; i < int(s.size()); i++) {
if (mark[s[i]] != 1 && s[i] >= 'A' && s[i] <= 'Z' &&
mark[convert(s[i])] == 1 && int(v.size()) != 0) {
if (dis[convert(s[i])] == 1) ans++;
} else if (mark[s[i]] == 1)
continue;
else {
cout << "-1" << endl;
exit(0);
}
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
scanf("%lld", &n);
scanf("%lld", &k);
long long int i, j;
long long int ans = 0;
long long int tot = n + 1;
for (i = 0; i < k; i++) {
long long int m;
scanf("%lld", &m);
tot += m - 1;
for (j = 1; j <= m; j++) {
long long int temp;
scanf("%lld", &temp);
if (temp == j) tot -= 2;
}
}
cout << tot << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chkmin(T &x, T y) {
return x > y ? x = y, 1 : 0;
}
template <typename T>
bool chkmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
int readint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n;
int a[500005];
vector<int> vec[500005];
set<int> s[2];
int main() {
int T = readint();
while (T--) {
n = readint();
vector<int> v0(0);
for (int i = 1; i <= n; i++) a[i] = readint();
for (int i = 0; i <= n; i++) vec[i].clear();
for (int i = 1; i <= n; i++) vec[a[i]].push_back(i);
if (!vec[0].size()) {
printf("0\n");
continue;
}
int pl = vec[0][vec[0].size() / 2];
vector<pair<int, int> > pr(0);
for (int i = 1; i <= n; i++) {
if (!vec[i].size()) continue;
int lf = 0, rg = n + 1;
for (auto r : vec[i]) {
if (r <= pl)
chkmax(lf, r);
else
chkmin(rg, r);
}
pr.push_back(make_pair(lf, rg));
}
s[0].clear(), s[1].clear();
for (int i = 1; i <= n; i++) {
if (a[i]) continue;
if (i <= pl)
s[0].insert(i);
else
s[1].insert(i);
}
sort(pr.begin(), pr.end(), [&](pair<int, int> x, pair<int, int> y) {
return x.second > y.second;
});
int ans = 0;
for (auto r : pr) {
auto it0 = s[0].lower_bound(r.first);
if (it0 != s[0].begin()) {
it0--;
ans++;
s[0].erase(it0);
} else {
auto it1 = s[1].lower_bound(r.second);
if (it1 != s[1].end()) {
ans++;
s[1].erase(it1);
}
}
}
printf("%d\n", min(ans, (int)vec[0].size() / 2));
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y <= x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x <= y ? x = y, 1 : 0;
}
const long double eps = 1e-9;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 60;
const int MAXN = 200005;
const int MAXM = 4005;
const int MAXP = 7000000;
const int MX = 200000;
const int G = 3;
const int mods = 1e9 + 7;
const int Gi = (mods + 1) / G;
const int SZ = 62;
const int inv2 = (mods + 1) >> 1;
const int INF = 0x3f3f3f3f;
namespace FastIO {
constexpr int SIZE = (1 << 21) + 1;
int num = 0, f;
char ibuf[SIZE], obuf[SIZE], que[65], *iS, *iT, *oS = obuf,
*oT = obuf + SIZE - 1, c;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char c) {
*oS++ = c;
if (oS == oT) flush();
}
inline void getc(char &c) {
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
c != '.' && c != 'X' && c != EOF;
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
;
}
inline void reads(char *st) {
char c;
int n = 0;
getc(st[++n]);
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
c == '.' || c == 'X';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
st[++n] = c;
st[++n] = '\0';
}
template <class I>
inline void read(I &x) {
for (f = 1, c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
x = (x << 3) + (x << 1) + (c & 15);
x *= f;
}
template <class I>
inline void print(I x) {
if (x < 0) putc('-'), x = -x;
if (!x) putc('0');
while (x) que[++num] = x % 10 + 48, x /= 10;
while (num) putc(que[num--]);
}
inline void putstr(string st) {
for (int i = 0; i < (int)st.size(); ++i) putc(st[i]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_Flusher_;
} // namespace FastIO
using FastIO ::getc;
using FastIO ::print;
using FastIO ::putc;
using FastIO ::putstr;
using FastIO ::read;
using FastIO ::reads;
int cnt, num, sz[MAXN], vis[MAXN], tmp[MAXN], Size, MN, id, ans = 1;
struct enode {
int v, c, d;
};
vector<enode> e[MAXN];
struct Node {
int x, y, c;
} b[MAXN], c[MAXN];
vector<Node> V;
int s[MAXN];
void add(int x, int y) {
for (; x; x -= x & (-x)) s[x] += y;
}
int query(int x) {
int ans = 0;
for (; x <= cnt; x += x & (-x)) ans += s[x];
return ans;
}
int quick_pow(int x, int y) {
int ret = 1;
for (; y; y >>= 1) {
if (y & 1) ret = 1ll * ret * x % mods;
x = 1ll * x * x % mods;
}
return ret;
}
void getrt(int x, int father) {
int mx = 0;
sz[x] = 1;
for (auto t : e[x]) {
int v = t.v;
if (v == father || vis[v]) continue;
getrt(v, x);
sz[x] += sz[v];
upmax(mx, sz[v]);
}
upmax(mx, Size - sz[x]);
if (mx < MN) MN = mx, id = x;
}
void dfs(int x, int father, int num0, int num1, int mul) {
V.push_back(((Node){num0, num1, mul}));
for (auto t : e[x]) {
int v = t.v, d = t.d;
if (vis[v] || v == father) continue;
dfs(v, x, num0 + (d == 0), num1 + (d == 1), 1ll * mul * t.c % mods);
}
}
void getans(int opt) {
sort(b + 1, b + num + 1, [&](Node a, Node b) { return a.x < b.x; });
sort(c + 1, c + num + 1, [&](Node a, Node b) { return a.x < b.x; });
sort(tmp + 1, tmp + cnt + 1);
cnt = unique(tmp + 1, tmp + cnt + 1) - tmp - 1;
for (int i = 1; i <= cnt; ++i) s[i] = 0;
for (int i = 1, nw = 1; i <= num; ++i) {
while (nw <= num && b[nw].x <= c[i].x)
add(lower_bound(tmp + 1, tmp + cnt + 1, b[nw].y) - tmp, 1), ++nw;
int p = quick_pow(c[i].c,
query(lower_bound(tmp + 1, tmp + cnt + 1, c[i].y) - tmp));
if (opt != 1) p = quick_pow(p, mods - 2);
ans = 1ll * ans * p % mods;
}
}
void Solve(int x) {
vis[x] = 1;
V.clear(), cnt = 0, num = 0;
for (auto t : e[x]) {
int v = t.v, d = t.d;
if (vis[v]) continue;
dfs(v, x, (d == 0), (d == 1), t.c);
}
V.push_back(((Node){0, 0, 1}));
for (auto v : V) {
++num;
b[num] = (Node){v.y - v.x - v.x, v.y + v.y - v.x, v.c};
c[num] = (Node){v.x + v.x - v.y, v.x - v.y - v.y, v.c};
tmp[++cnt] = v.y + v.y - v.x, tmp[++cnt] = v.x - v.y - v.y;
}
getans(1);
for (auto t : e[x]) {
int v = t.v, d = t.d;
if (vis[v]) continue;
V.clear(), cnt = 0, num = 0;
dfs(v, x, (d == 0), (d == 1), t.c);
for (auto v : V) {
++num;
b[num] = (Node){v.y - v.x - v.x, v.y + v.y - v.x, v.c};
c[num] = (Node){v.x + v.x - v.y, v.x - v.y - v.y, v.c};
tmp[++cnt] = v.y + v.y - v.x, tmp[++cnt] = v.x - v.y - v.y;
}
getans(-1);
}
for (auto t : e[x]) {
int v = t.v;
if (vis[v]) continue;
Size = sz[v], MN = INF, id = 0, getrt(v, x), Solve(id);
}
}
signed main() {
int n;
read(n);
for (int i = 1, u, v, c, d; i < n; ++i)
read(u), read(v), read(c), read(d), e[u].push_back(((enode){v, c, d})),
e[v].push_back(((enode){u, c, d}));
Size = n, MN = INF, id = 0, getrt(1, 0), Solve(id);
print(ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using LD = long double;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::istream& reader = std::cin;
int n, m, k;
reader >> n >> m >> k;
std::vector<std::vector<LD>> binom(n + 1, std::vector<LD>(n + 1));
for (int i = 0; i <= n; ++i) {
binom[i][0] = binom[i][i] = 1.0;
for (int j = 1; j < i; ++j) {
binom[i][j] = binom[i - 1][j] + binom[i - 1][j - 1];
}
}
std::vector<LD> A(k + 1);
A[0] = 1.0;
for (int i = 1; i <= k; ++i) A[i] = A[i - 1] * (k + 1 - i) / (m + 1 - i);
LD result = 0.0;
for (int r = 0; r <= n; ++r) {
for (int c = 0; c <= n; ++c) {
int t = (r + c) * n - r * c;
if (t <= k) {
result += A[t] * binom[n][r] * binom[n][c];
}
}
}
printf("%.13f\n", std::min<double>(1e99, result));
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9, pi = acos(-1.0);
const long long inf = 2000000009;
int n, a, b, p = 0, c;
vector<pair<int, int> > v;
vector<vector<int> > g, ans;
vector<int> used;
map<pair<int, int>, int> M;
void dfs(int v, int p) {
used[v] = 1;
int c = 1, l;
if (p == -1)
l = 0;
else
l = M.find(make_pair(p, v))->second;
for (int i = 0; i < g[v].size(); i++) {
if (!used[g[v][i]]) {
if (c == l) c++;
M.insert(make_pair(make_pair(g[v][i], v), c));
M.insert(make_pair(make_pair(v, g[v][i]), c));
c++;
dfs(g[v][i], v);
}
}
}
void solve() {
cin >> n;
v.resize(n - 1);
g.resize(n);
used.resize(n, 0);
ans.resize(n);
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
a--, b--;
v[i] = make_pair(a, b);
g[a].push_back(b);
g[b].push_back(a);
p = max(p, max((int)g[a].size(), (int)g[b].size()));
}
dfs(0, -1);
for (int i = 0; i < v.size(); i++) {
int a = v[i].first, b = v[i].second;
int c = M.find(make_pair(a, b))->second;
ans[c].push_back(i + 1);
}
cout << p << '\n';
for (int i = 1; i <= p; i++) {
cout << ans[i].size() << ' ';
for (int j = 0; j < ans[i].size(); j++) cout << ans[i][j] << ' ';
cout << '\n';
}
}
int main() { solve(); }
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int v1, v2;
vector<vector<int>> g;
vector<int> w;
vector<vector<int>> dp;
vector<bool> p;
void md(int start) {
p[start] = 1;
vector<int> vsp;
for (auto it : g[start])
if (!p[it]) vsp.push_back(it), md(it);
int size = vsp.size();
dp[start][0] = w[start];
for (auto it : vsp) dp[start][0] += dp[it][k];
for (int i = 0; i != (size); i++)
for (int j = 0; j != (k / 2); j++) {
int sum = 0;
for (int v = 0; v != (size); v++) sum += dp[vsp[v]][k - j - 1];
sum += dp[vsp[i]][j] - dp[vsp[i]][k - j - 1];
dp[start][j + 1] = max(dp[start][j + 1], sum);
}
for (int i = 0; i != (size); i++)
for (int j = (k / 2); j != (k); j++) {
int sum = 0;
for (int v = 0; v != (size); v++) sum += dp[vsp[v]][j];
dp[start][j + 1] = max(dp[start][j + 1], sum);
}
for (int i = k; i != 0; i--)
dp[start][i - 1] = max(dp[start][i - 1], dp[start][i]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
g.resize(n), w.resize(n);
for (int i = 0; i != (n); i++) cin >> w[i];
for (int i = 0; i != (n - 1) && (cin >> v1 >> v2); i++)
g[v1 - 1].push_back(v2 - 1), g[v2 - 1].push_back(v1 - 1);
p.resize(n, 0);
dp.resize(n, vector<int>(k + 1, 0));
md(0);
cout << dp[0][0];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k;
long long int n;
long long int ara[100000];
scanf("%lld", &n);
for (i = 1, j = 0; (i * i) <= n; i++) {
if (n % i == 0) {
ara[j] = ((n / i) * (2 + ((n / i) - 1) * i)) / 2;
j++;
if ((i * i) != n) {
ara[j] = (i * (2 + (i - 1) * (n / i))) / 2;
j++;
}
}
}
sort(ara, ara + j);
for (i = 0; i < j; i++) {
printf("%lld ", ara[i]);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, M, K, tc;
int main(void) {
int cnt = 0;
scanf("%d%d", &N, &K);
for (int i = 1; i <= N; i++) {
int x;
scanf("%d", &x);
if (x + K <= 5) cnt++;
}
cout << cnt / 3;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, m, count = 0, c = 0, L = 0, R = 0, result = 0, l1, r1;
int a[100002], b[100002];
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i] >> b[i];
L = L + a[i];
R = R + b[i];
}
result = abs(L - R);
for (i = 0; i < n; i++) {
l1 = L - a[i] + b[i];
r1 = R - b[i] + a[i];
c = abs(l1 - r1);
if (c > result) {
result = c;
count = i + 1;
}
}
cout << count;
}
| 1 |
#include<bits/stdc++.h>
#define forn(i, n) for (int i = 0; i < (n); i++)
#define forab(i, a, b) for (int i = (a); i <= (b); i++)
#define forba(i, b, a) for (int i = (b); i >= (a); i--)
#define mset(a, x, n) memset(a, x, sizeof(a[0]) * (n))
#define updiv(x, y) (((x) + (y) - 1) / (y)) // y > 0
#define pb(x) push_back(x)
#define eb emplace_back
#define mp(x, y) make_pair(x, y)
#define fi first
#define se second
#define sz(x) ((int)x.size())
#define all(x) (x).begin(), (x).end()
#ifdef hat
#define fast
#define de(x) cerr << #x << '=' << (x) << ' '
#define dee(x) cerr << #x << '=' << (x) << endl
#else
#define endl '\n'
#define fast ios::sync_with_stdio(0), cin.tie(0)
#define de(x) ((void) 0)
#define dee(x) ((void) 0)
#endif
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef pair<int, int> pii;
typedef vector<int> VI;
const int maxn = 50 + 5;
const int mod = 998244353;
const int INF = 0x3f3f3f3f;
const ll llINF = 0x3f3f3f3f3f3f3f3f;
ll make_compiler_happy() {return INF & maxn & mod & llINF;}
ll fpow(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
ll inv(ll x) {return fpow(x, mod-2);}
mt19937 gen(chrono::high_resolution_clock::now().time_since_epoch().count());
int m, n;
vector<int> g[maxn * 2];
int match[maxn * 2];
bool vis[maxn * 2];
bool dfs(int u)
{
vis[u] = 1;
for(int v : g[u])
{
int w = match[v];
if(w < 0 || (!vis[w] && dfs(w))) {
match[v] = u;
match[u] = v;
return 1;
}
}
return 0;
}
int bi_match()
{
mset(match, -1, 2 * n + 1);
int ans = 0;
forab(i, 1, n)
if(match[i] < 0) {
mset(vis, 0, 2 * n + 1);
if(dfs(i)) ans++;
}
return ans;
}
void addedge(int u, int v)
{
g[u].pb(v + n);
}
bool dfs2(int u)
{
vis[u] = 1;
for(int v : g[u])
{
if(v == match[u]) continue;
int w = match[v];
vis[v] = 1;
if(!vis[w]) dfs2(w);
}
return 0;
}
void find_set()
{
mset(vis, 0, 2 * n + 1);
forab(i, 1, n)
if(match[i] == -1 && !vis[i]) {
dfs2(i);
}
}
ll x[maxn], y[maxn];
ll dp[maxn][maxn];
int from[maxn][maxn];
VI ans;
void print_ans(int i, int j)
{
if(i == 0) {
return;
}
print_ans(i - 1, from[i][j]);
forn(t, j - from[i][j]) {
ans.pb(-1);
}
ans.pb(0);
}
int main()
{
fast;
int k;
cin >> n >> m >> k;
forn(i, m)
{
int u, v;
cin >> u >> v;
addedge(u, v);
}
forab(i, 1, k)
cin >> x[i] >> y[i];
int res = n - bi_match();
if(res > k) {
cout << k << endl;
forn(i, k)
cout << 0 << ' ';
cout << endl;
return 0;
}
find_set();
VI v;
forab(i, 1, n)
{
if(!vis[i]) {
v.pb(i);
}
}
forab(i, n + 1, n + n)
{
if(vis[i]) {
v.pb(i);
}
}
forab(i, 0, n)
forab(j, 0, n)
dp[i][j] = -1e18;
dp[0][res] = 0;
forab(i, 1, k)
{
forab(j, i + 1, n)
{
forab(t, 0, j)
{
ll &d = dp[i][j];
ll val = dp[i - 1][j - t] + max(0LL, x[i] - t * y[i]);
if(val > d) {
d = val;
from[i][j] = j - t;
}
}
}
}
print_ans(k, k + 1);
cout << sz(ans) << endl;
int cur = 0;
for(int i : ans)
{
if(i == -1) {
cout << (v[cur] > n ? n - v[cur] : v[cur]) << ' ';
cur++;
}
else cout << i << ' ';
}
cout << endl;
} | 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = (int)2e6 + 9;
char a[2][MAX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
int allOne = 0, yWin = 0, aWin = 0;
cin >> a[0] >> a[1];
for (int i = 0; i < 2 * n; i++) {
if (a[0][i] == '0' && a[1][i] == '1') aWin++;
if (a[0][i] == '1' && a[1][i] == '0') yWin++;
if (a[0][i] == '1' && a[1][i] == '1') allOne++;
}
int yaro = 0, anr = 0;
yaro += (allOne + 1) / 2;
anr += allOne / 2;
int com = min(aWin, yWin);
yaro += com;
anr += com;
if (yWin > aWin) {
yaro += (yWin - com + !((allOne + 2 * com) & 1)) / 2;
} else {
anr += (aWin - com + ((allOne + 2 * com) & 1)) / 2;
}
if (yaro > anr)
cout << "First" << '\n';
else if (yaro < anr)
cout << "Second" << '\n';
else
cout << "Draw" << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T>
using Table = vector<vector<T>>;
const ld eps = 1e-9;
string getnum(const string from, const string st) {
if (from.size() >= st.size()) {
if (from.substr(from.size() - st.size()) <= st) {
string ans = from.substr(0, from.size() - st.size()) + st;
return ans;
} else {
int anum;
if (from.size() == st.size()) {
anum = 0;
} else {
anum = stoi(from.substr(0, from.size() - st.size()));
}
anum++;
string ans = to_string(anum) + st;
return ans;
}
} else {
return st;
}
}
int main() {
int N;
cin >> N;
while (N--) {
string st;
cin >> st;
st = st.substr(4, st.size() - 4);
string from = "1988";
for (int keta = 1; keta <= st.size(); ++keta) {
from = to_string(stoi(from) + 1);
from = getnum(from, st.substr(st.size() - keta, keta));
if (from[0] == '0') from = '1' + from;
}
cout << from << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[200005][5];
long long int subtree[200005];
vector<long long int> v[200005];
long long int N, K;
long long int ans = 0;
void dfs(long long int u, long long int par) {
dp[u][0] = 1;
subtree[u] = 1;
for (long long int i = 0; i < v[u].size(); i++) {
if (v[u][i] != par) {
dfs(v[u][i], u);
for (long long int j = 0; j < 5; j++) {
for (long long int k = 0; k < 5; k++) {
ans += ((K - (j + k + 1) % K) % K) * dp[u][j] * dp[v[u][i]][k];
}
}
for (long long int j = 0; j < 5; j++)
dp[u][(j + 1) % K] += dp[v[u][i]][j];
subtree[u] += subtree[v[u][i]];
}
}
ans += (subtree[u]) * (N - subtree[u]);
}
int main() {
long long int i, j, k;
cin >> N >> K;
for (i = 0; i < N - 1; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, -1);
cout << ans / K << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void colourNode(vector<int> &A, int colour, int i) {
if (colour == 1) {
A[i] = 2;
} else if (colour == 2) {
A[i] = 1;
}
}
bool bfs(vector<int> &colour, vector<vector<int> > &A, vector<bool> &visited,
int node) {
if (A[node].empty()) {
visited[node] = true;
return true;
}
queue<int> q;
q.push(node);
colour[node] = 1;
while (!q.empty()) {
int f = q.front();
q.pop();
visited[f] = true;
for (int i = 0; i < A[f].size(); i++) {
if (!visited[A[f][i]]) {
q.push(A[f][i]);
if (colour[A[f][i]] == 0) {
colourNode(colour, colour[f], A[f][i]);
} else if (colour[A[f][i]] == colour[f]) {
return false;
} else {
continue;
}
}
}
}
return true;
}
void Print(vector<int> A, int n) {
int c = 0;
for (int i = 1; i < A.size(); i++) {
if (A[i] == n) {
c++;
}
}
cout << c << "\n";
for (int i = 0; i < A.size(); i++) {
if (A[i] == n) {
cout << i << " ";
}
}
cout << "\n";
}
int main() {
int n, e;
cin >> n >> e;
vector<vector<int> > A;
vector<int> temp;
A.resize(n + 1, temp);
for (int i = 0; i < e; i++) {
int a1, a2;
cin >> a1 >> a2;
A[a1].push_back(a2);
A[a2].push_back(a1);
}
vector<int> colour(n + 1, 0);
vector<bool> visited(n + 1, false);
bool flag = true;
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
if (!bfs(colour, A, visited, i)) {
flag = false;
cout << -1 << "\n";
break;
}
}
}
if (flag) {
Print(colour, 1);
Print(colour, 2);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
const int mod = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = 2 * acos(0);
const int M = 50;
const int N = 1e6 + 7;
string s;
int n;
int has = 0;
int cnt = 0;
void solve() {
cin >> n >> s;
for (int i = (0); i < (n); i++) {
if (i == 0 || s[i] != s[i - 1]) {
cnt++;
}
if (i > 0) {
if (s[i] == s[i - 1]) {
has++;
}
}
}
if (has > 1)
cnt += 2;
else if (has == 1)
cnt++;
cout << cnt;
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long fpm(long long b, long long e, long long m) {
long long t = 1;
for (; e; e >>= 1, b = b * b % m) e & 1 ? t = t * b % m : 0;
return t;
}
template <class T>
inline bool chkmin(T &a, T b) {
return a < b ? a = b, true : false;
}
template <class T>
inline bool chkmax(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class edge>
struct Graph {
vector<vector<edge> > adj;
Graph(int n) {
adj.clear();
adj.resize(n + 5);
}
void adde(int s, edge e) { adj[s].push_back(e); }
typename vector<edge>::iterator operator[](int t) { return adj[t].begin(); }
};
const int maxn = 110;
int z[maxn][maxn];
int main() {
ios_base::sync_with_stdio(false);
int k, n;
cin >> k;
for (n = 3; n * (n - 2) * (n - 1) / 6 <= k; ++n)
;
int x = --n;
k -= x * (x - 2) * (x - 1) / 6;
for (int i = 1; i <= x; ++i)
for (int j = 1; j <= x; ++j)
if (i != j) z[i][j] = 1;
for (; k;) {
int t = 2;
for (; t <= x && t * (t - 1) / 2 <= k; ++t)
;
++n;
--t, k -= t * (t - 1) / 2;
for (int i = 1; i <= t; ++i) z[n][i] = z[i][n] = 1;
}
cout << n << endl;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) cout << z[i][j];
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char tp = getchar();
int ans = 0;
while (tp > '9' || tp < '0') tp = getchar();
while (tp <= '9' && tp >= '0') {
ans = ans * 10 + tp - '0';
tp = getchar();
}
return ans;
}
const int mx = 1048576;
struct query {
int ti, l, r, ans;
} q[mx];
int n, nn, m, a[mx], ma[mx], ls[mx], t[mx << 1], pre[mx], bk[mx];
inline bool cmp(query q1, query q2) {
if (q1.r == q2.r) return q1.l < q2.l;
return q1.r < q2.r;
}
inline bool cmpt(query q1, query q2) { return q1.ti < q2.ti; }
inline int qr(int l, int r) {
int ans = 0;
for (l = l + mx - 1, r = r + mx + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
if (l & 1 ^ 1) ans = (ans ^ t[l ^ 1]);
if (r & 1) ans = (ans ^ t[r ^ 1]);
}
return ans;
}
inline void upd(int po, int num) {
po += mx;
t[po] = num;
for (po >>= 1; po; po >>= 1) t[po] = (t[po << 1] ^ t[po << 1 | 1]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) ma[i] = a[i];
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].ti = i;
}
sort(q + 1, q + 1 + m, cmp);
sort(ma + 1, ma + n + 1);
nn = unique(ma + 1, ma + n + 1) - ma - 1;
int cuq = 1;
for (int i = 1; i <= n; i++) {
int po = lower_bound(ma + 1, ma + 1 + nn, a[i]) - ma;
pre[i] = pre[i - 1];
pre[i] = (pre[i] ^ a[i]);
bk[po]++;
if (ls[po]) {
upd(ls[po], 0);
ls[po] = 0;
}
upd(i, a[i]);
ls[po] = i;
while (q[cuq].r == i) {
q[cuq].ans = qr(q[cuq].l, q[cuq].r);
q[cuq].ans = (q[cuq].ans ^ (pre[q[cuq].r] ^ pre[q[cuq].l - 1]));
cuq++;
}
}
sort(q + 1, q + 1 + m, cmpt);
for (int i = 1; i <= m; i++) printf("%d\n", q[i].ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int max(int a, int b) { return a > b ? a : b; }
int main() {
int n, a[105], i, k = 0, p;
cin >> n;
if (n < 3 || n % 2 == 0)
cout << -1;
else {
for (i = 1; i <= n; i++) cin >> a[i];
for (i = (n - 1) / 2; i >= 1; i--) {
p = 0;
p = max(p, a[i * 2]);
p = max(p, a[i * 2 + 1]);
a[i] = max(0, a[i] - p);
a[i * 2] = max(0, a[i * 2] - p);
a[i * 2 + 1] = max(0, a[i * 2 + 1] - p);
k = k + p;
}
cout << k + a[1] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int p, n;
cin >> n;
int a[100001] = {}, dp[100001], h[100001] = {};
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
dp[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; --i) {
if (a[i] == dp[i + 1]) h[i] = 1;
dp[i] = max(dp[i + 1], a[i]);
}
for (int i = 0; i < n - 1; ++i) {
if (dp[i] == a[i]) {
if (h[i] == 1)
cout << "1 ";
else
cout << "0 ";
} else
cout << dp[i] - a[i] + 1 << " ";
}
cout << 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int const N = 1e6 + 10;
struct Node {
ll l{0LL}, r{0LL}, maxx{0LL}, minn{0LL}, lazy{0LL}, sum{0LL};
Node() = default;
} tree[N];
ll a[N];
ll tmpV;
void pushUp(int rt) {
tree[rt].sum = tree[rt << 1].sum + tree[rt << 1 | 1].sum;
tree[rt].maxx = max(tree[rt << 1].maxx, tree[rt << 1 | 1].maxx);
tree[rt].minn = min(tree[rt << 1].minn, tree[rt << 1 | 1].minn);
}
void pushDown(int rt) {
if (tree[rt].lazy) {
tree[rt << 1].lazy = tree[rt << 1 | 1].lazy = tree[rt].lazy;
tree[rt << 1].sum = tree[rt].lazy * (tree[rt << 1].r - tree[rt << 1].l + 1);
tree[rt << 1 | 1].sum =
tree[rt].lazy * (tree[rt << 1 | 1].r - tree[rt << 1 | 1].l + 1);
tree[rt << 1].maxx = tree[rt << 1 | 1].maxx = tree[rt << 1].minn =
tree[rt << 1 | 1].minn = tree[rt].lazy;
tree[rt].lazy = 0;
}
}
void build(int l, int r, int rt) {
if (l == r) {
tree[rt].sum = tree[rt].maxx = tree[rt].minn = a[l];
tree[rt].lazy = 0;
tree[rt].l = tree[rt].r = l;
return;
}
tree[rt].l = l, tree[rt].r = r;
int mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
pushUp(rt);
}
void update(int l, int r, int val, int rt) {
if (l <= tree[rt].l && tree[rt].r <= r) {
if (val <= tree[rt].minn) return;
if (val > tree[rt].maxx) {
tree[rt].sum = val * (tree[rt].r - tree[rt].l + 1);
tree[rt].maxx = tree[rt].minn = val;
tree[rt].lazy = val;
return;
}
}
pushDown(rt);
int mid = (tree[rt].l + tree[rt].r) >> 1;
if (l <= mid) update(l, r, val, rt << 1);
if (r > mid) update(l, r, val, rt << 1 | 1);
pushUp(rt);
}
ll query(int l, int r, int rt) {
if (l <= tree[rt].l && tree[rt].r <= r) {
if (tmpV < tree[rt].minn) return 0;
if (tree[rt].sum <= tmpV) {
tmpV -= tree[rt].sum;
return tree[rt].r - tree[rt].l + 1;
}
}
if (tree[rt].l == tree[rt].r) return 0;
pushDown(rt);
ll sum = 0;
int mid = (tree[rt].l + tree[rt].r) >> 1;
if (l <= mid) sum += query(l, r, rt << 1);
if (r > mid) sum += query(l, r, rt << 1 | 1);
return sum;
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
build(1, n, 1);
while (q--) {
int t, x, y;
cin >> t >> x >> y;
if (t == 1) {
update(1, x, y, 1);
} else if (t == 2) {
tmpV = y;
cout << query(x, n, 1) << '\n';
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
map<int, int> ma;
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int pos = 0;
for (int i = 0; i < n; i++) {
if (a[i] == m) pos = i;
}
int u = 0, d = 0;
for (int i = pos; i < n; i++) {
if (a[i] < m)
d++;
else if (a[i] > m)
u++;
ma[d - u]++;
}
u = 0;
d = 0;
long long ans = 0;
for (int i = pos; i >= 0; i--) {
if (a[i] < m)
d++;
else if (a[i] > m)
u++;
ans += ma[0 - (d - u)] + ma[-1 - (d - u)];
}
printf("%lld", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x;
}
bool bz[200005];
int main() {
int t = read();
while (t--) {
memset(bz, 0, sizeof bz);
int a = read(), b = read(), n = a + b;
for (register int i = 0; i <= a + b + 1 >> 1; ++i) {
int num = b - i, num1 = (a + b >> 1) - num;
if (num >= 0 && num1 >= 0) bz[num1 + i] = 1;
num = a - i, num1 = (a + b >> 1) - num;
if (num >= 0 && num1 >= 0) bz[num1 + i] = 1;
}
int aa = 0;
for (register int i = 0; i <= a + b; ++i)
if (bz[i]) aa++;
printf("%d\n", aa);
for (register int i = 0; i <= a + b; ++i)
if (bz[i]) printf("%d ", i);
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, mod = 1e9 + 7;
unsigned long long a, b;
int main() {
scanf("%lld%lld", &a, &b);
if (b > a) return puts("-1"), 0;
unsigned long long d = a - b, res = 0;
if (d % 2) return puts("-1"), 0;
d /= 2;
for (int i = 0; i < 64; i++) {
unsigned long long B = (1LL << i);
if (d & B) {
if (b & B) return puts("-1"), 0;
res |= B;
}
}
printf("%lld %lld\n", res, a - res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> a(n);
vector<long long> b(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
long long max = 1;
long long ans = 0;
for (int i = 0; i < n; i++) {
max = a[i] + b[i];
if (max > ans) {
ans = max;
}
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 7;
const int M = 20;
const int inf = 1e9 + 7;
const long long linf = 1e18 + 7;
const double pi = acos(-1);
const double eps = 1e-20;
const bool multipleTest = false;
long long sqr(long long x) { return x * x; }
double calc(double x) {
if (x >= 2 * pi) x -= 2 * pi;
if (x < 0) x += 2 * pi;
return x;
}
struct point {
int x, y;
long long dist(point other) { return sqr(x - other.x) + sqr(y - other.y); }
double deg(point other) { return atan2(y - other.y, x - other.x); }
bool straight(point a, point b) {
return ((long long)x - a.x) * ((long long)b.y - a.y) ==
((long long)b.x - a.x) * ((long long)y - a.y);
}
bool sameDir(point a, point r) {
return straight(a, r) && (((long long)x - r.x) * (a.x - r.x)) >= 0 &&
((long long)y - r.y) * (a.y - r.y) >= 0;
}
};
point p[N];
int id[N];
int n;
bool cmp(int i, int j) {
if (!p[i].sameDir(p[j], p[0])) {
return p[i].deg(p[0]) < p[j].deg(p[0]);
}
return p[i].dist(p[0]) < p[j].dist(p[0]);
}
double deg(point a, point b) { return calc(b.deg(p[0]) - a.deg(p[0])); }
void solve() {
cin >> n;
for (int i = 0; i < n; ++i) {
scanf("%d%d", &p[i].x, &p[i].y);
id[i] = i;
}
sort(id + 1, id + n, cmp);
int i = 1;
int j = 2;
while (i < n) {
j = i + 1;
while (j < n && p[id[i]].sameDir(p[id[j]], p[0])) ++j;
if (j == n) break;
double x = deg(p[id[i]], p[id[j]]);
if (p[id[i]].straight(p[0], p[id[j]]) || x <= 0 || x >= pi) {
i = j;
continue;
} else
break;
}
if (j < n)
cout << 1 << " " << id[i] + 1 << " " << id[j] + 1;
else {
int tmp = n - 1;
while (tmp > 2 && p[id[tmp - 1]].sameDir(p[id[n - 1]], p[0])) --tmp;
if (tmp != 1 && !p[0].straight(p[id[tmp]], p[id[1]])) {
double x = deg(p[id[tmp]], p[id[1]]);
if (x > 0 && x < pi) {
cout << 1 << " " << id[tmp] + 1 << " " << id[1] + 1 << "\n";
return;
}
}
}
}
int main() {
int Test = 1;
if (multipleTest) {
cin >> Test;
}
for (int i = 0; i < Test; ++i) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int LIM = 1e5 + 5, MOD = 1e9 + 7;
long long a[500005];
long long N = 500009;
long long seg[20000009];
long long n;
long long gcd(long long a, long long b) {
if (a > b) swap(a, b);
if (a == 0) return b;
return gcd(b % a, a);
}
void create_tree(long long index, long long l, long long r) {
if (l == r) {
seg[index] = a[l];
return;
}
long long mid = (l + r) / 2;
create_tree(2 * index + 1, l, mid);
create_tree(2 * index + 2, mid + 1, r);
seg[index] = gcd(seg[2 * index + 1], seg[2 * index + 2]);
return;
}
long long query(long long index, long long l, long long r, long long ql,
long long qr, long long x) {
long long xl, xr;
if ((l > qr) || (r < ql)) return 0;
if (((l >= ql) && (qr >= r)) && (seg[index] % x == 0)) {
return 0;
}
if (l == r) return 1;
long long mid = (l + r) / 2;
long long cnt = query(2 * index + 1, l, mid, ql, qr, x);
if (cnt > 1) return cnt;
cnt += query(2 * index + 2, mid + 1, r, ql, qr, x);
return cnt;
}
void update(long long index, long long l, long long r, long long i,
long long x) {
if ((l > i) || (r < i))
return;
else if ((l == r) && (l == i)) {
seg[index] = x;
return;
} else {
long long mid = (l + r) / 2;
update(2 * index + 1, l, mid, i, x);
update(2 * index + 2, mid + 1, r, i, x);
seg[index] = gcd(seg[2 * index + 1], seg[2 * index + 2]);
return;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long i, j, k, m, g, cnt;
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
create_tree(0, 0, n - 1);
long long q;
cin >> q;
long long qs;
long long l, r, x, y;
for (int j = 0; j < q; ++j) {
cin >> qs;
if (qs == 1) {
cin >> l >> r >> x;
cnt = 0;
cnt = query(0, 0, n - 1, l - 1, r - 1, x);
if (cnt <= 1)
cout << "YES\n";
else
cout << "NO\n";
} else {
cin >> i >> y;
update(0, 0, n - 1, i - 1, y);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long long N = 1000000;
const long long mod = 1e9 + 7;
using namespace std;
int a[20];
vector<int> b;
const int MAXBUF = 10000;
char buf[MAXBUF], *ps = buf, *pe = buf + 1;
inline void rnext() {
if (++ps == pe)
pe = (ps = buf) +
fread(buf, sizeof(char), sizeof(buf) / sizeof(char), stdin);
}
template <class T>
inline bool rin(T &res) {
res = 0;
T f = 1;
if (ps == pe) return false;
do {
rnext();
if ('-' == *ps) f = -1;
} while (!isdigit(*ps) && ps != pe);
if (ps == pe) return false;
do {
res = (res << 1) + (res << 3) + *ps - 48;
rnext();
} while (isdigit(*ps) && ps != pe);
res *= f;
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
rin(n);
rin(k);
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < k; j++) {
sum *= 2;
int t;
rin(t);
sum += t;
}
a[sum]++;
}
for (int i = 0; i <= (1 << k); i++)
if (a[i]) b.push_back(i);
if (b[0] == 0) {
cout << "YES"
<< "\n";
return 0;
}
for (int i = 0; i < b.size() - 1; i++) {
for (int j = i + 1; j < b.size(); j++) {
int t = b[i] & b[j];
if (!t) {
cout << "YES"
<< "\n";
return 0;
}
}
}
cout << "NO"
<< "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, a[9] = {}, b[9] = {}, i, o;
char in[5];
scanf("%d", &o);
n = o;
while (n--) {
scanf("%s", in);
if (strlen(in) == 4)
if (in[3] == 'S')
a[8]++;
else
a[0]++;
else if (strlen(in) == 3)
if (in[2] == 'S')
a[7]++;
else
a[1]++;
else if (strlen(in) == 2)
if (in[1] == 'S')
a[6]++;
else
a[2]++;
else if (in[0] == 'S')
a[5]++;
else if (in[0] == 'M')
a[4]++;
else
a[3]++;
}
n = o;
while (n--) {
scanf("%s", in);
if (strlen(in) == 4)
if (in[3] == 'S')
b[8]++;
else
b[0]++;
else if (strlen(in) == 3)
if (in[2] == 'S')
b[7]++;
else
b[1]++;
else if (strlen(in) == 2)
if (in[1] == 'S')
b[6]++;
else
b[2]++;
else if (in[0] == 'S')
b[5]++;
else if (in[0] == 'M')
b[4]++;
else
b[3]++;
}
int sum = 0;
for (i = 0; i < 9; i++) sum += abs(a[i] - b[i]);
printf("%d\n", sum / 2);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
map<int, int> mp;
for (int i = 0; i < n / 2; i++) {
mp[arr[i] - i]++;
mp[arr[n - 1 - i] - i]++;
}
if (n % 2) {
mp[arr[n / 2] - n / 2]++;
}
int maxx = 0;
for (auto i : mp) {
if (i.first == 0) continue;
if (i.second > maxx) maxx = i.second;
}
cout << n - maxx << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<pair<int, int>> g[N];
int val[N], vis[N], col[N];
vector<pair<int, int>> edges;
vector<int> nodes[2];
bool findOddCycle(int v, int c) {
if (vis[v]) {
return (c != col[v]);
}
vis[v] = 1;
col[v] = c;
nodes[c].push_back(v);
for (auto& e : g[v]) {
edges.emplace_back(e);
bool found = findOddCycle(e.first, c ^ 1);
if (found) return true;
edges.pop_back();
}
return false;
}
bool apply(int v, int s, int c) {
if (vis[v] == c) {
return (val[v] == s);
}
vis[v] = c;
val[v] = s;
for (auto& e : g[v]) {
bool ok = apply(e.first, e.second - s, c);
if (!ok) return false;
}
return true;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
--u, --v;
w *= 2;
g[u].emplace_back(v, w);
g[v].emplace_back(u, w);
}
for (int i = 0; i < n; ++i) {
if (vis[i]) continue;
nodes[0].clear();
nodes[1].clear();
edges.clear();
edges.emplace_back(i, -1);
bool found = findOddCycle(i, 0);
if (found) {
int last = edges.back().first;
int sum = edges.back().second;
edges.pop_back();
int sign = -1;
while (last != edges.back().first) {
sum += sign * edges.back().second;
sign = -sign;
edges.pop_back();
}
sum /= 2;
bool ok = apply(last, sum, 2);
if (!ok) {
puts("NO");
return 0;
}
} else {
bool ok = apply(i, 0, 2);
if (!ok) {
puts("NO");
return 0;
}
int offset = 0;
long long sum = 0;
vector<int> vals;
long long sumright = 0, sumleft = 0;
for (int j = 0; j < 2; ++j) {
for (int v : nodes[j]) {
int cur = val[v];
if (col[v] != col[i]) cur = -cur;
vals.emplace_back(cur);
sum += abs(cur);
sumright += cur;
}
}
sort(vals.begin(), vals.end());
for (int j = 0; j < (int)vals.size(); ++j) {
long long cntleft = j, cntright = (int)vals.size() - j;
long long cur =
(sumright - cntright * vals[j]) + (cntleft * vals[j] - sumleft);
if (sum > cur) {
sum = cur;
offset = -vals[j];
}
sumright -= vals[j];
sumleft += vals[j];
}
apply(i, offset, 3);
}
}
puts("YES");
for (int i = 0; i < n; ++i) {
int x = abs(val[i]) / 2;
if (val[i] < 0) printf("-");
printf("%d.%d%c", x, (val[i] & 1) ? 5 : 0, i + 1 == n ? '\n' : ' ');
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, sum, anss, ans[100000];
char s[100000];
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
s[++n] = 'W';
for (int i = 1; i <= n; i++)
if (s[i] == 'W') {
if (sum) ans[++anss] = sum;
sum = 0;
} else
sum++;
printf("%d\n", anss);
for (int i = 1; i <= anss; i++)
printf("%d%c", ans[i], (i == anss ? '\n' : ' '));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e4 + 5;
int n, m, x[maxn], y[maxn], ans[5000 + 5];
bool vis[5000 + 5];
struct node {
int y, t;
node(int y = 0, int t = 0) : y(y), t(t) {}
bool operator<(const node& g) const { return t > g.t; }
};
vector<node> g[5000 + 5], h[5000 + 5];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x[i], &y[i]);
x[i]--;
y[i]--;
g[x[i]].push_back(node(y[i], (y[i] - x[i] + n) % n));
}
int mx = 0;
for (int i = 0; i < n; i++) {
sort(g[i].begin(), g[i].end());
mx = max(mx, (int)g[i].size());
}
for (int i = 0; i < n; i++) {
for (int j = max(0, mx - 2); j < g[i].size(); j++) h[i].push_back(g[i][j]);
}
for (int i = 0; i < n; i++) {
int num = 0;
int dis = -1e9;
memset(vis, 0, sizeof(vis));
int st = i;
while (true) {
if (num < h[st].size()) {
int y = h[st][num].y;
if (vis[y] && dis < (y - i + n) % n) dis = (y - i + n) % n;
if (!vis[y] && dis < (y - i + n) % n - n) dis = (y - i + n) % n - n;
}
vis[st] = 1;
st = (st + 1) % n;
if (st == i) break;
}
if (mx == 1) {
ans[i] += n + dis;
continue;
}
if (dis <= 0)
dis = -1e9;
else
dis = dis - n;
ans[i] += n;
st = i;
memset(vis, 0, sizeof(vis));
num++;
while (true) {
if (num < h[st].size()) {
int y = h[st][num].y;
if (vis[y] && dis < (y - i + n) % n) dis = (y - i + n) % n;
if (!vis[y] && dis < (y - i + n) % n - n) dis = (y - i + n) % n - n;
}
vis[st] = 1;
st = (st + 1) % n;
if (st == i) break;
}
ans[i] += n + dis;
}
for (int i = 0; i < n; i++) printf("%d\n", ans[i] + max(0, mx - 2) * n);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int num[64], oth[64];
int check(int x) {
int res = num[0] - x;
for (int i = 1; i <= 40; i++) {
res += oth[i];
if (x > num[i]) {
res -= min(res, x - num[i]);
x = num[i];
} else
res += num[i] - x;
}
return res == 0;
}
int main() {
int n;
scanf("%d", &n);
long long ret = 1, x, cnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &x);
while (ret < x) ret *= 2, cnt++;
if ((ret ^ x) == 0)
num[cnt]++;
else
oth[cnt]++;
}
int l = 1, r = num[0], ans = -1;
while (r >= l) {
int mid = l + r >> 1;
if (check(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
if (ans == -1) return 0 * printf("-1\n");
for (int i = ans; i <= num[0]; i++)
printf("%d%c", i, i == num[0] ? '\n' : ' ');
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = -1e8;
const double Pi = acos(-1);
bool inline equ(double a, double b) { return fabs(a - b) < EPS; }
struct MinCostMaxFlow {
static const int MAXV = 20010;
static const int INF = 1000000000;
struct Edge {
int v, cap, w, rev;
Edge() {}
Edge(int t2, int t3, int t4, int t5) : v(t2), cap(t3), w(t4), rev(t5) {}
};
int V, s, t;
vector<Edge> g[MAXV];
void init(int n) {
V = n + 2;
s = n + 1, t = n + 2;
for (int i = 1; i <= V; i++) g[i].clear();
}
void addEdge(int a, int b, int cap, int w) {
g[a].push_back(Edge(b, cap, w, (int)g[b].size()));
g[b].push_back(Edge(a, 0, -w, ((int)g[a].size()) - 1));
}
int d[MAXV], id[MAXV], mom[MAXV];
bool inqu[MAXV];
int qu[2000000], ql, qr;
pair<int, int> mncmxf() {
int mxf = 0, mnc = 0;
while (1) {
fill(d + 1, d + 1 + V, INF);
fill(inqu + 1, inqu + 1 + V, 0);
fill(mom + 1, mom + 1 + V, -1);
mom[s] = s;
d[s] = 0;
ql = 1, qr = 0;
qu[++qr] = s;
inqu[s] = 1;
while (ql <= qr) {
int u = qu[ql++];
inqu[u] = 0;
for (int i = 0; i < (int)g[u].size(); i++) {
Edge &e = g[u][i];
int v = e.v;
if (e.cap > 0 && d[v] > d[u] + e.w) {
d[v] = d[u] + e.w;
mom[v] = u;
id[v] = i;
if (!inqu[v]) qu[++qr] = v, inqu[v] = 1;
}
}
}
if (mom[t] == -1) break;
int df = INF;
for (int u = t; u != s; u = mom[u]) df = min(df, g[mom[u]][id[u]].cap);
for (int u = t; u != s; u = mom[u]) {
Edge &e = g[mom[u]][id[u]];
e.cap -= df;
g[e.v][e.rev].cap += df;
}
mxf += df;
mnc += df * d[t];
}
return pair<int, int>(mnc, mxf);
}
} flow;
const int MAXN = 55;
int n, k, c[MAXN][MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) cin >> c[i][j];
int lb = 0, ub = 100000000, ans = -1;
while (lb <= ub) {
int mid = (lb + ub) / 2;
flow.init(n);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++) {
if (c[i][j]) {
flow.addEdge(i, j, c[i][j], 0);
flow.addEdge(i, j, k, 1);
}
}
flow.addEdge(flow.s, 1, mid, 0);
flow.addEdge(n, flow.t, mid, 0);
pair<int, int> p = flow.mncmxf();
if (p.first <= k) {
ans = p.second;
lb = mid + 1;
} else
ub = mid - 1;
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int T;
scanf("%d", &T);
while (T--) {
int a;
scanf("%d", &a);
if (a <= 2) {
printf("2\n");
printf("1 2\n");
} else {
printf("%d\n", 2);
printf("%d %d\n", a, a - 2);
printf("%d %d\n", a - 1, a - 1);
for (int i = a - 1; i >= 3; i--) printf("%d %d\n", i, i - 2);
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int arr[500 + 5];
int dp[505][505];
int rec(int st, int en) {
if (st > en) return 0;
if (st == en) {
return 1;
}
if (st + 1 == en) {
if (arr[st] == arr[en])
return 1;
else
return 2;
}
if (dp[st][en] != -1) return dp[st][en];
int ret = en - st + 1;
ret = min(ret, rec(st + 1, en) + 1);
ret = min(ret, rec(st, en - 1) + 1);
if (arr[st] == arr[en])
ret = min(ret, rec(st + 1, en - 1));
else
ret = min(ret, rec(st + 1, en - 1) + 2);
for (int i = st + 1; i <= en; i++) {
if (arr[st] == arr[i]) {
if (i == st + 1) {
ret = 1 + rec(i + 1, en);
} else {
ret = min(ret, rec(st + 1, i - 1) + rec(i + 1, en));
}
}
}
return dp[st][en] = ret;
}
int main() {
int n;
while (cin >> n) {
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
memset(dp, -1, sizeof dp);
cout << rec(0, n - 1) << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a1[101000];
long long sum;
void find_limit(int tmp, long long& l, long long& r, int p) {
l = r = 0;
int i;
for (i = p - 1; i; i--) {
if ((a1[i] & tmp) == 0) break;
l++;
}
for (i = p + 1; i <= n; i++) {
if ((a1[i] & tmp) == 0) break;
r++;
}
}
void solve(int p, int new_value, int origin_value) {
int i;
long long cont_left = 0, cont_right = 0;
for (i = 0; (1 << i) < 101000; i++) {
int tmp = (1 << i);
if ((new_value & tmp) == (origin_value & tmp)) continue;
find_limit(tmp, cont_left, cont_right, p);
long long sub_value =
(cont_left * cont_right + cont_left + cont_right + 1) * (long long)tmp;
if (new_value & tmp)
sum += sub_value;
else
sum -= sub_value;
}
}
void build() {
sum = 0;
int i, j;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a1[i]);
for (i = 0; (1 << i) < 101000; i++) {
int tmp = (1 << i);
long long num = 0;
for (j = 1; j <= n; j++) {
if (a1[j] & tmp)
num++;
else {
if (num) sum += (num * (num + 1) * (long long)tmp / 2);
num = 0;
}
}
if (num) sum += (num * (num + 1) * (long long)tmp / 2);
}
}
int main() {
build();
int p, v, i;
for (i = 0; i < m; i++) {
scanf("%d%d", &p, &v);
solve(p, v, a1[p]);
a1[p] = v;
printf("%I64d\n", sum);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string grid[60];
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int t;
cin >> t;
int r, c;
while (t--) {
cin >> r >> c;
for (int i = 0; i < r; i++) cin >> grid[i];
bool quina = false, borda = false, meio = false, all = true, tdb1 = true,
tdb2 = true, tdb3 = true, tdb4 = true, tdm1 = false, tdm2 = false;
for (int i = 0; i < r; i++) {
bool at = true;
for (int j = 0; j < c; j++) {
if (grid[i][j] == 'A') {
if ((i == 0 && j == 0) || (i == 0 && j == c - 1) ||
(i == r - 1 && j == 0) || (i == r - 1 && j == c - 1))
quina = true;
else if (i == 0 || j == c - 1 || i == r - 1 || j == 0)
borda = true;
else
meio = true;
} else {
all = false;
at = false;
}
}
tdm1 = tdm1 || at;
}
for (int i = 0; i < c; i++) {
bool at = true;
for (int j = 0; j < r; j++) {
if (grid[j][i] == 'P') {
at = false;
}
}
tdm2 = tdm2 || at;
}
for (int i = 0; i < r; i++) {
if (grid[i][0] == 'P') tdb1 = false;
}
for (int i = 0; i < r; i++) {
if (grid[i][c - 1] == 'P') tdb2 = false;
}
for (int i = 0; i < c; i++) {
if (grid[0][i] == 'P') tdb3 = false;
}
for (int i = 0; i < c; i++) {
if (grid[r - 1][i] == 'P') tdb4 = false;
}
if (all)
cout << 0 << endl;
else if (tdb1 || tdb2 || tdb3 || tdb4)
cout << 1 << endl;
else if (quina || tdm1 || tdm2)
cout << 2 << endl;
else if (borda)
cout << 3 << endl;
else if (meio)
cout << 4 << endl;
else
cout << "MORTAL" << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
;
map<long long, long long> x;
for (long long i = 0; i < n; i++) {
x[a[i]]++;
}
vector<long long> b;
for (auto i : x) {
if (i.second >= 4) {
b.push_back(i.first);
b.push_back(i.first);
} else if (i.second >= 2) {
b.push_back(i.first);
}
}
double c1 = b[0];
double c2 = b[1];
double c3 = c1 / c2 + c2 / c1;
long long ans = 0;
double min = c3;
long long b1 = b.size();
for (long long i = 0; i < b1 - 1; i++) {
c1 = b[i];
c2 = b[i + 1];
c3 = c1 / c2 + c2 / c1;
if (c3 < min) {
min = c3;
ans = i;
}
}
cout << b[ans] << " " << b[ans] << " " << b[ans + 1] << " " << b[ans + 1]
<< "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, k = 0;
int a[15], b[15], c[15];
cin >> m >> n;
for (int i = 0; i < m; i++) {
cin >> a[i];
}
for (int j = 0; j < n; j++) {
cin >> b[j];
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (b[j] == a[i]) c[k++] = a[i];
}
}
if (!k)
cout << endl;
else {
for (int i = 0; i < k - 1; i++) {
cout << c[i] << ' ';
}
cout << c[k - 1];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> input;
int temp;
for (int i = 0; i < n; i++) {
cin >> temp;
input.push_back(temp);
}
if (n <= 2) {
cout << "0\n";
} else {
int mini = *min_element(input.begin(), input.end());
int maxi = *max_element(input.begin(), input.end());
int count = 0;
for (int i = 0; i < n; i++) {
if (input[i] != mini && input[i] != maxi) {
count++;
}
}
cout << count << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<long long, int> Map;
int num1[55];
int num2[55];
int maxx;
bool judge(int x) {
int ans = 0;
for (int i = 0; i <= maxx; i++) {
if (num1[i] >= x) {
ans += (num1[i] - x);
} else {
if (i == 0) return false;
ans = max(ans - x + num1[i], 0);
x = num1[i];
}
ans += num2[i];
}
if (ans <= x) return true;
return false;
}
int main() {
for (int i = 0; i <= 50; i++) Map[1LL << i] = i + 1;
int n;
scanf("%d", &n);
maxx = 0;
for (int i = 1; i <= n; i++) {
long long a;
scanf("%lld", &a);
maxx = max(Map[a] - 1, maxx);
if (Map[a])
num1[Map[a] - 1] += 1;
else {
int k = log2(a);
num2[k]++;
maxx = max(maxx, k);
}
}
bool K = 1;
for (int i = 0; i <= maxx; i++) {
if (num1[i] == 0 && num2[i]) {
puts("-1");
return 0;
}
}
for (int i = 1; i <= n; i++)
if (judge(i)) printf("%d ", i), K = 0;
if (K) puts("-1");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
for (int i = 0; i < n.length(); ++i) {
if (n[i] > '1') {
for (int j = i; j < n.length(); ++j) n[j] = '1';
break;
}
}
int n2 = 0;
for (int i = 0; i < n.length(); ++i) n2 = (n2 * 2) + (n[i] - '0');
cout << n2 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int flag = 0, flag1 = 0;
char r[s.length() + 1];
if (s.length() % 2) {
r[((s.length() + 1) / 2) - 1] = s[0];
int k = 1;
for (int i = 1; i < s.length(); i++) {
if (i % 2) {
r[((s.length() + 1) / 2) - k - 1] = s[i];
} else {
r[((s.length() + 1) / 2) + k - 1] = s[i];
flag = 1;
}
if (flag == 1) {
k++;
flag = 0;
}
}
}
if (s.length() % 2 == 0) {
r[((s.length()) / 2) - 1] = s[0];
r[s.length() - 1] = s[s.length() - 1];
int k = 1;
for (int i = 1; i < (s.length() - 1); i++) {
if (i % 2) {
r[((s.length()) / 2) + k - 1] = s[i];
} else {
r[((s.length()) / 2) - k - 1] = s[i];
flag = 1;
}
if (flag == 1) {
k++;
flag = 0;
}
}
}
for (int i = 0; i < s.length(); i++) {
cout << r[i];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
inline long long rint() {
long long x = 0;
char s = getchar();
for (; s < '0' || '9' < s; s = getchar())
;
for (; '0' <= s && s <= '9'; s = getchar()) x = x * 10 + (s ^ '0');
return x;
}
const int MAXN = 5e4, MAXLGK = 59;
long long K;
int P, n, m, s[MAXN + 5], lgk;
std::pair<long long, int> mdf[MAXN + 5];
inline int mul(const long long a, const int b) { return a * b % P; }
inline int add(int a, const int b) { return (a += b) < P ? a : a - P; }
struct Matrix {
int mat[2][2];
Matrix() { mat[0][0] = mat[0][1] = mat[1][0] = mat[1][1] = 0; }
inline int* operator[](const int k) { return mat[k]; }
inline Matrix operator*(const Matrix m) const {
Matrix ret;
for (int i = 0; i < 2; ++i) {
for (int k = 0; k < 2; ++k) {
for (int j = 0; j < 2; ++j) {
ret[i][j] = add(ret[i][j], mul(mat[i][k], m.mat[k][j]));
}
}
}
return ret;
}
} trs[MAXN + 5][MAXLGK + 5], ans, tmp;
inline void init() {
for (int i = 0; i < n; ++i) {
trs[i][0][0][1] = 1;
trs[i][0][1][0] = s[i], trs[i][0][1][1] = s[(i + 1) % n];
}
lgk = 1;
for (int j = 1; 1ll << j <= K; lgk = j++) {
for (int i = 0; i < n; ++i) {
trs[i][j] = trs[(i + (1ll << j >> 1)) % n][j - 1] * trs[i][j - 1];
}
}
}
inline void jump(long long& cur, const long long tar) {
for (int i = lgk; ~i; --i) {
if (cur + (1ll << i) < tar) {
ans = trs[cur % n][i] * ans;
cur += 1ll << i;
}
}
}
int main() {
K = rint(), P = rint();
n = rint();
for (int i = 0; i < n; ++i) s[i] = rint() % P;
init();
m = rint();
for (int i = 1; i <= m; ++i) {
mdf[i].first = rint(), mdf[i].second = rint() % P;
if (mdf[i].first >= K) --i, --m;
}
std::sort(mdf + 1, mdf + m + 1);
long long cur = 0;
ans[1][0] = 1 % P;
for (int i = 1; i <= m; ++i) {
jump(cur, mdf[i].first);
if (cur < mdf[i].first) {
tmp[0][1] = 1, tmp[1][0] = s[cur % n], tmp[1][1] = mdf[i].second;
ans = tmp * ans, ++cur;
}
tmp[0][1] = 1, tmp[1][0] = mdf[i].second;
if (i < m && mdf[i + 1].first == mdf[i].first + 1) {
tmp[1][1] = mdf[i + 1].second;
} else {
tmp[1][1] = s[(cur + 1) % n];
}
ans = tmp * ans, ++cur;
}
jump(cur, K);
printf("%d\n", ans[cur < K][0]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
unsigned long long int k, a[200005] = {}, p[15] = {1}, z = 0;
for (int i = 1; i <= 14; i++) p[i] = p[i - 1] * 10;
vector<unsigned long long int> b[13] = {};
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 12; j++)
if (p[j] > a[i]) {
if ((unsigned long long int)(a[i] * p[j] + a[i]) % k == 0) z--;
break;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 12; j++)
if (p[j] > a[i]) {
b[j].push_back(a[i]);
break;
}
}
for (int i = 1; i <= 10; i++)
if (b[i].size()) {
map<unsigned long long int, int> m;
for (unsigned long long int h : b[i]) m[h % k]++;
m[k] = m[0];
for (int j = 0; j < n; j++) {
z += m[k - a[j] * p[i] % k];
}
}
cout << z;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve();
signed main() {
srand(time(0));
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(9);
solve();
}
const long long INF = 1e9, MAXN = 3e5 + 10, MOD = 998244353;
bool correct(long long num) {
long long sum = 0;
while (num != 0) {
sum += (num % 10);
num /= 10;
}
return sum == 10;
}
void solve() {
vector<long long> zbs;
for (long long i = 1; i <= 2e7; ++i) {
if (correct(i)) {
zbs.push_back(i);
}
}
long long k;
cin >> k;
cout << zbs[k - 1] << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 2e4 + 15;
const long long Mod = 1e9 + 7;
long long c[1010][2020];
int main() {
ios::sync_with_stdio(false);
int n, m, k, i, j;
for (int i = 0; i <= 1000; i++) {
c[i][0] = 1;
c[i][i] = 1;
for (j = 1; j < i; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % Mod;
}
cin >> n >> m >> k;
cout << c[n - 1][2 * k] * c[m - 1][2 * k] % Mod << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4010;
const long long mod = 998244853;
int n, m;
int f[N][N], g[N][N], binom[N][N];
template <typename T>
inline void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
inline void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
inline void read(T &x) {
T f = 1;
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= f;
}
signed main() {
read(n);
read(m);
for (int i = 0; i <= 2000; ++i) {
for (int j = 0; j <= 2000; ++j) {
if (!i)
f[i][j] = 1;
else if (i > j)
f[i][j] = 0;
else
f[i][j] = (f[i - 1][j] + f[i][j - 1]) % mod;
}
}
for (int i = 0; i <= 4000; ++i) {
binom[i][0] = binom[i][i] = 1;
for (int j = 1; j < i; ++j)
binom[i][j] = (binom[i - 1][j] + binom[i - 1][j - 1]) % mod;
}
for (int i = 0; i <= 2000; ++i) {
for (int j = 0; j <= 2000; ++j) {
if (!i)
g[i][j] = 0;
else if (!j)
g[i][j] = i;
else
g[i][j] =
(long long)(binom[i + j - 1][j] + g[i - 1][j] % mod + g[i][j - 1] -
binom[i + j - 1][i] + f[i][j - 1] % mod) %
mod;
while (g[i][j] < 0) g[i][j] += mod;
g[i][j] %= mod;
}
}
printf("%lld\n", (g[n][m] % mod + mod) % mod);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
void say(int x) {
;
printf("%d\n", x + 1);
fflush(stdout);
}
int main() {
int n, m, c;
scanf("%d %d %d", &n, &m, &c);
vector<int> cur(n, inf);
auto win = [&]() {
for (int i = 0; i < n; ++i) {
if (cur[i] == inf) return false;
if (i && cur[i - 1] > cur[i]) return false;
}
return true;
};
for (int i = 0; i < m; ++i) {
int x;
scanf("%d", &x);
bool ok = false;
int y = 0;
if (x <= c / 2) {
for (int j = 0; j < n && !ok; ++j) {
if (cur[j] == inf || j + 1 == n || cur[j] > x) {
ok = true;
y = j;
cur[j] = x;
}
}
} else {
for (int j = n - 1; j >= 0 && !ok; --j) {
if (cur[j] == inf || j == 0 || cur[j] < x) {
ok = true;
y = j;
cur[j] = x;
}
}
}
say(y);
if (win()) break;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
int l = 1, r = n, ans = -1;
while (l <= r) {
int m = l + (r - l) / 2;
int x = m, sum = m;
while (x > 0) {
sum += (x / k);
x /= k;
}
if (sum >= n)
ans = m, r = m - 1;
else
l = m + 1;
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long LL_MIN = std::numeric_limits<long long>::min();
const long long LL_MAX = std::numeric_limits<long long>::max();
template <class T, class R>
ostream& operator<<(ostream& o, const pair<T, R>& p) {
o << "(" << p.first << ", " << p.second << ")";
return o;
}
template <class T, class R>
istream& operator>>(istream& o, pair<T, R>& p) {
o >> p.first >> p.second;
return o;
}
template <class T>
string to_string(const T& x) {
stringstream o;
o << "[";
for (__typeof((x).begin()) i = ((x).begin()); i != (x).end(); ++i) {
o << ((i != x.begin()) ? ", " : "") << *i;
}
o << "]";
string r;
getline(o, r);
return r;
}
template <class T>
T get_next(string& s) {
stringstream ss(s);
T r;
ss >> r;
getline(ss, s);
return r;
}
template <class T>
void split_string(const string& s, vector<T>& o) {
stringstream ss(s);
o.clear();
T x;
while (ss >> x) {
o.push_back(x);
}
}
void trim(string& s) {
stringstream ss;
ss << s;
s.clear();
ss >> s;
}
template <class T, class R>
ostream& operator<<(ostream& o, const map<T, R>& x) {
o << to_string(x);
return o;
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& x) {
o << to_string(x);
return o;
};
template <class T>
ostream& operator<<(ostream& o, const set<T>& x) {
o << to_string(x);
return o;
};
template <class T>
ostream& operator<<(ostream& o, const deque<T>& x) {
o << to_string(x);
return o;
};
const long long INFL = 1000000000LL * 1000000000LL + 1000LL;
const int INF = 1000000000 + 1000;
const long long MOD = 1000000009;
struct Tri {
int a, b, c;
Tri(int a, int b, int c) : a(a), b(b), c(c) {}
};
queue<Tri> q;
int n, m, a, b;
vector<int> graf[510];
bool sol[510][510][2];
int dist[510][510][2], f[510][510][2];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &a, &b);
graf[a].push_back(b);
graf[b].push_back(a);
}
dist[1][n][0] = 0;
q.push(Tri(1, n, 0));
sol[1][n][0] = true;
while (q.size()) {
Tri t = q.front();
q.pop();
if (t.c == 0) {
for (__typeof((graf[t.a]).begin()) a = ((graf[t.a]).begin());
a != (graf[t.a]).end(); ++a) {
if (!sol[*a][t.b][1]) {
sol[*a][t.b][1] = true;
dist[*a][t.b][1] = dist[t.a][t.b][0] + 1;
q.push(Tri(*a, t.b, 1));
f[*a][t.b][1] = t.a;
}
}
} else {
for (__typeof((graf[t.b]).begin()) b = ((graf[t.b]).begin());
b != (graf[t.b]).end(); ++b) {
if (!sol[t.a][*b][0] && t.a != *b) {
sol[t.a][*b][0] = true;
dist[t.a][*b][0] = dist[t.a][t.b][1];
q.push(Tri(t.a, *b, 0));
f[t.a][*b][0] = t.b;
}
}
}
}
if (!sol[n][1][0]) {
printf("-1\n");
} else {
printf("%d\n", dist[n][1][0]);
a = n;
b = 1;
vector<int> ra, rb;
ra.push_back(n);
rb.push_back(1);
while (make_pair(a, b) != make_pair(1, n)) {
rb.push_back(f[a][b][0]);
b = f[a][b][0];
ra.push_back(f[a][b][1]);
a = f[a][b][1];
}
for (__typeof((rb).begin()) it = ((rb).begin()); it != (rb).end(); ++it) {
printf("%d ", *it);
}
printf("\n");
for (__typeof((ra).begin()) it = ((ra).begin()); it != (ra).end(); ++it) {
printf("%d ", *it);
}
printf("\n");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int temp1;
string temp2;
int answer;
int main() {
cin >> temp1 >> temp2;
answer = temp1;
for (int i = 0, j = 1; i < temp2.size(); i++, j *= 10) {
answer += ((int)temp2[i] - (int)'0') * j;
}
cout << answer;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int Maxn3 = 1e3 + 10;
const long long int Maxn4 = 1e4 + 10;
const long long int Maxn5 = 1e5 + 10;
const long long int Maxn6 = 1e6 + 10;
const long long int Maxn7 = 1e7 + 10;
const long long int Maxn8 = 1e8 + 10;
const long long int Maxn9 = 1e9 + 10;
const long long int Maxn18 = 1e18 + 10;
const long long int Mod1 = 1e7 + 7;
const long long int Mod2 = 1e9 + 7;
const long long int LLMax = LLONG_MAX;
const long long int LLMin = LLONG_MIN;
const long long int INTMax = INT_MAX;
const long long int INTMin = INT_MIN;
long long int mn = LLMax, mx = LLMin;
vector<long long int> g[3 * Maxn5];
long long int f[3 * Maxn5][32], w[3 * Maxn5], a[3 * Maxn5], m, n;
void dfs(long long int x, long long int p) {
w[x] = 1;
for (long long int y : g[x])
if (y != p) dfs(y, x), ((w[x]) = max((w[x]), (1 + w[y])));
f[x][1] = n;
for (long long int i = 2; i < 21; i++) {
long long int m = 0;
for (long long int y : g[x])
if (y != p) a[m++] = f[y][i - 1];
sort(a, a + m);
reverse(a, a + m);
f[x][i] = 0;
while (f[x][i] < m and a[f[x][i]] > f[x][i]) f[x][i]++;
((f[x][i]) = max((f[x][i]), (1ll)));
}
f[x][21] = 1;
}
void dfs2(long long int x, long long int p) {
for (long long int y : g[x])
if (y != p) {
dfs2(y, x);
for (long long int i = 1; i < 21; i++)
((f[x][i]) = max((f[x][i]), (f[y][i])));
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
scanf("%lld", &n);
for (long long int i = 1; i < n; i++) {
long long int u, v;
scanf("%lld %lld", &u, &v);
u--;
v--;
g[u].push_back(v), g[v].push_back(u);
}
dfs(0ll, -1ll);
dfs2(0ll, -1ll);
long long int res = 0;
for (long long int i = 0; i < n; i++) {
res += w[i];
for (long long int j = 1; j < 21; j++) res += j * (f[i][j] - f[i][j + 1]);
}
return cout << res, 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
int fa[maxn][21], deep[maxn], to[maxn << 1], nex[maxn << 1], hed[maxn],
vis[maxn], u, v, n, k, ed;
inline void add_edge(int u, int v) {
++ed;
to[ed] = v;
nex[ed] = hed[u];
hed[u] = ed;
}
void dfs(int u) {
for (int i = hed[u]; i; i = nex[i]) {
int v = to[i];
if (fa[u][0] != v) {
fa[v][0] = u;
deep[v] = deep[u] + 1;
dfs(v);
}
}
}
inline void init() {
for (int i = 1; i <= 20; ++i)
for (int j = 1; j <= n; ++j)
if (fa[j][i - 1] != 0) fa[j][i] = fa[fa[j][i - 1]][i - 1];
}
int lfxk(int x) {
for (int i = 20; i >= 0; --i)
if (!vis[fa[x][i]]) x = fa[x][i];
return fa[x][0];
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
add_edge(u, v);
add_edge(v, u);
}
fa[n][0] = n;
dfs(n);
init();
vis[n] = 1;
k = n - k - 1;
for (int i = n - 1; i; --i)
if (!vis[i]) {
int x = lfxk(i);
if (deep[i] - deep[x] <= k) {
k -= deep[i] - deep[x];
int v = i;
while (!vis[v]) {
vis[v] = 1;
v = fa[v][0];
}
}
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) printf("%d ", i);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int res[110000];
int opt[10];
struct node {
int r, c, d1, d2, idx;
} ori[110000];
bool cmpr(node a, node b) {
if (a.r == b.r) return a.c < b.c;
return a.r < b.r;
}
bool cmpc(node a, node b) {
if (a.c == b.c) return a.r < b.r;
return a.c < b.c;
}
bool cmpd1(node a, node b) {
if (a.d1 == b.d1) return a.r < b.r;
return a.d1 < b.d1;
}
bool cmpd2(node a, node b) {
if (a.d2 == b.d2) return a.r < b.r;
return a.d2 < b.d2;
}
bool cmpidx(node a, node b) { return a.idx < b.idx; }
void calc_r() {
int i, j, cur;
for (i = 1, cur = 0; i < m; i++) {
if (ori[i].r != ori[cur].r) {
if (i > cur + 1) {
for (j = cur; j < i; j++) res[ori[j].idx]++;
for (j = cur + 1; j < i - 1; j++) res[ori[j].idx]++;
}
cur = i;
}
}
if (i > cur + 1) {
for (j = cur; j < i; j++) res[ori[j].idx]++;
for (j = cur + 1; j < i - 1; j++) res[ori[j].idx]++;
}
}
void calc_c() {
int i, j, cur;
for (i = 1, cur = 0; i < m; i++) {
if (ori[i].c != ori[cur].c) {
if (i > cur + 1) {
for (j = cur; j < i; j++) res[ori[j].idx]++;
for (j = cur + 1; j < i - 1; j++) res[ori[j].idx]++;
}
cur = i;
}
}
if (i > cur + 1) {
for (j = cur; j < i; j++) res[ori[j].idx]++;
for (j = cur + 1; j < i - 1; j++) res[ori[j].idx]++;
}
}
void calc_d1() {
int i, j, cur;
for (i = 1, cur = 0; i < m; i++) {
if (ori[i].d1 != ori[cur].d1) {
if (i > cur + 1) {
for (j = cur; j < i; j++) res[ori[j].idx]++;
for (j = cur + 1; j < i - 1; j++) res[ori[j].idx]++;
}
cur = i;
}
}
if (i > cur + 1) {
for (j = cur; j < i; j++) res[ori[j].idx]++;
for (j = cur + 1; j < i - 1; j++) res[ori[j].idx]++;
}
}
void calc_d2() {
int i, j, cur;
for (i = 1, cur = 0; i < m; i++) {
if (ori[i].d2 != ori[cur].d2) {
if (i > cur + 1) {
for (j = cur; j < i; j++) res[ori[j].idx]++;
for (j = cur + 1; j < i - 1; j++) res[ori[j].idx]++;
}
cur = i;
}
}
if (i > cur + 1) {
for (j = cur; j < i; j++) res[ori[j].idx]++;
for (j = cur + 1; j < i - 1; j++) res[ori[j].idx]++;
}
}
void Solve() {
int i, j, val, cur;
memset(res, 0, sizeof res);
memset(opt, 0, sizeof opt);
for (i = 0; i < m; i++) {
scanf("%d%d", &ori[i].r, &ori[i].c);
ori[i].idx = i;
ori[i].d1 = ori[i].r + ori[i].c;
ori[i].d2 = ori[i].r - ori[i].c;
}
sort(ori, ori + m, cmpr);
calc_r();
sort(ori, ori + m, cmpc);
calc_c();
sort(ori, ori + m, cmpd1);
calc_d1();
sort(ori, ori + m, cmpd2);
calc_d2();
for (i = 0; i < m; i++) opt[res[i]]++;
for (i = 0; i <= 8; i++) printf("%d%s", opt[i], i == 8 ? "\n" : " ");
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) Solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int inp[1001], i, j, k, n;
cin >> n;
for (i = 0; i < n; i++) cin >> inp[i];
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
for (k = 0; k < n; k++)
if (inp[i] == inp[j] + inp[k] && i != j && i != k && j != k) {
cout << i + 1 << " " << j + 1 << " " << k + 1 << endl;
return 0;
}
cout << "-1" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef int (*funI_I)(int);
typedef int (*funI_II)(int, int);
constexpr int N = 200100;
int n, a[N], b[N], vis[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int _;
cin >> _;
while (_--) {
cin >> n;
fill(b, b + 1 + n, -1);
for (int i = (1); i <= (n); ++i) cin >> a[i], vis[i] = 0;
b[1] = a[1];
vis[b[1]] = 1;
for (int i = (2); i <= (n); ++i)
if (a[i - 1] < a[i]) {
b[i] = a[i];
vis[b[i]] = 1;
}
int now = 1, flag = 0;
for (int i = (1); i <= (n); ++i)
if (b[i] == -1) {
while (now <= n && vis[now]) ++now;
if (now <= n) b[i] = now, vis[now] = 1;
if (b[i] == -1) flag = 1;
}
int mx = -100000;
for (int i = (1); i <= (n); ++i) {
mx = max(mx, b[i]);
if (mx != a[i]) flag = 1;
}
if (flag)
cout << -1 << "\n";
else {
for (int i = (1); i <= (n); ++i) cout << b[i] << " ";
cout << "\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, k;
cin >> n >> k;
vector<long long int> a(n + 1, 0);
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] % k != 0)
a[i] = k - (a[i] % k);
else
a[i] = 0;
}
sort(a.begin(), a.end());
long long int count = 1;
vector<long long int> temp;
temp.push_back(a[1]);
for (long long int i = 2; i <= n; i++) {
if (a[i] > 0 && a[i] == a[i - 1]) {
temp.push_back(a[i] + (k * count));
count++;
} else {
temp.push_back(a[i]);
count = 1;
}
}
sort(temp.begin(), temp.end());
long long int moves = 0;
long long int x = 0;
for (long long int j = 0; j < temp.size(); j++) {
if (temp[j] != 0) {
moves += temp[j] - x;
moves += 1;
x = temp[j] + 1;
}
}
cout << moves << "\n";
}
int main() {
long long int test;
cin >> test;
while (test--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T pbs(T x, int k) {
if (!k) return 1;
if (k < 0) {
x = 1 / x;
k = -k;
}
T y = 1;
while (k > 1) {
if (k & 1) y *= x;
x *= x;
k = k >> 1;
}
return x * y;
}
template <typename T>
inline T parse(std::string s) {
T v;
std::istringstream istr(s);
istr >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
inline vector<string> split(const string& s, char delim = ' ') {
vector<string> elems;
stringstream ss(s);
string item;
while (getline(ss, item, delim)) elems.push_back(item);
return elems;
}
template <class C>
inline ostream& print(C c, string sep = " ", string left = "",
string right = "") {
cout << left;
auto it = c.begin();
if (c.size()) cout << *it++;
for (; it != c.end(); it++) cout << sep << *it;
return cout << right;
}
template <class C, typename T = typename C::value_type>
inline T max(C c) {
return *max_element(begin(c), end(c));
}
template <class C, typename T = typename C::value_type>
inline T min(C c) {
return *min_element(begin(c), end(c));
}
struct _ {
_() {
cin.sync_with_stdio(false);
cin.tie(0);
}
} _;
int main() {
int n, b, p, k;
cin >> n >> b >> p;
long bottles = 0, towels = n * p;
while (n > 1) {
k = 1;
while (k * 2 <= n) k *= 2;
bottles += (k / 2) * (2 * b + 1);
n = k / 2 + (n - k);
}
cout << bottles << " " << towels << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, a, b, ta, tb, i, nowm, nowms, nia, nib;
cin >> n;
cin >> a >> b;
ta = min(a, b);
cin >> a >> b;
tb = min(a, b);
nia = ta;
nowm = ta + tb;
nowms = 0;
for (i = 1; i < 4; i++) {
cin >> a >> b;
ta = min(a, b);
cin >> a >> b;
tb = min(a, b);
if ((ta + tb) < nowm) {
nowm = (ta + tb);
nowms = i;
nia = ta;
}
}
if (nowm > n) {
cout << "-1" << endl;
} else {
cout << nowms + 1 << " " << nia << " " << n - nia << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, r;
cin >> n >> l >> r;
long long minn = 0, maxx = 0;
minn += n - l + 1;
long long tmp = 2;
for (int i = 1; i < l; i++) {
minn += tmp;
tmp *= 2;
}
for (int L = l; L <= r; L++) {
long long p = 0;
tmp = 1ll;
for (int i = 1; i < L; i++) {
p += tmp;
tmp *= 2;
}
p += (n - L + 1) * tmp;
maxx = max(maxx, p);
}
cout << minn << " " << maxx << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long MXN = 1e5 + 12;
const double eps = 1e-10;
const double pi = acos(-1.0);
const long long OO = 1e18 + 1;
const int MNN = 1e5 + 1;
const int MOD = 1e9 + 7;
using namespace std;
string s;
int main() {
ios_base::sync_with_stdio(0), cout.tie(0), cin.tie(0);
;
cin >> s;
int sz = s.size();
for (int i = 1; i <= 100; i++) {
int x = sz / i;
if (sz % x > 0) x++;
if (x > 20) {
continue;
}
long long b = x, a = i;
x = sz / i;
long long k = a - (sz % x);
if (sz % x == 0) k = 0;
cout << a << " " << b << '\n';
long long kek = 1, lol = 0;
while (lol < sz) {
if (kek % b == 0 && k > 0) {
cout << '*' << '\n';
k--;
kek++;
continue;
}
cout << s[lol];
if (kek % b == 0) cout << '\n';
kek++, lol++;
}
exit(0);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
long long t;
cin >> t;
for (long long e = 0; e < t; ++e) {
long long n, g, b;
cin >> n >> g >> b;
long long x = n / 2 + n % 2;
if (g >= x) {
cout << n << '\n';
continue;
}
if (x % g == 0) {
cout << max(n, x + (x / g - 1) * b) << '\n';
continue;
}
long long sol = max(n, x + x / g * b);
cout << sol << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
template <typename T>
using pair2 = pair<T, T>;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) { return (ull)rng() % B; }
clock_t startTime;
double getCurrentTime() {
return (double)(clock() - startTime) / CLOCKS_PER_SEC;
}
const int N = 100100;
int n;
ll a[N], b[N];
vector<int> g[N];
bool dfs(int v, int par) {
ll x = -b[v];
for (int u : g[v]) {
if (u == par) continue;
if (!dfs(u, v)) return false;
b[v] += b[u];
x += a[u];
}
if (x > a[v] || (a[v] - x) % 2 != 0 || abs(a[v]) > b[v]) return false;
return true;
}
void solve() {
int m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%lld", &b[i]);
}
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
for (int i = 0; i < n; i++) g[i].clear();
for (int i = 1; i < n; i++) {
int v, u;
scanf("%d%d", &v, &u);
v--;
u--;
g[v].push_back(u);
g[u].push_back(v);
}
if (dfs(0, -1))
printf("YES\n");
else
printf("NO\n");
}
int main() {
startTime = clock();
int t;
scanf("%d", &t);
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
long long add(long long x, long long y) { return (x + y) % MOD; }
long long sub(long long x, long long y) { return (x - y + MOD) % MOD; }
long long mult(long long x, long long y) { return (x * y) % MOD; }
const int N = (int)1e6 + 7;
int cnt[N];
long long p2[N], a[N];
int main() {
p2[0] = 1;
for (int i = 1; i < N; i++) p2[i] = add(p2[i - 1], p2[i - 1]);
int n;
scanf("%d", &n);
while (n--) {
int x;
scanf("%d", &x);
cnt[x]++;
}
for (int i = 1; i < N; i++) {
int y = 0;
for (int j = i; j < N; j += i) y += cnt[j];
if (y == 0) continue;
a[i] = mult(y, p2[y - 1]);
}
long long ans = 0;
for (int x = N - 1; x > 1; x--) {
for (int y = 2 * x; y < N; y += x) a[x] = sub(a[x], a[y]);
ans = add(ans, mult(x, a[x]));
}
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int k, x, n, m;
int f(int x) {
if (x > 0) return 1;
return 0;
}
void print(int cnt1, int cnt2, int t) {
if (t & 8) printf("C");
for (int i = 1; i <= cnt1; i++) printf("AC");
for (int i = 2 * cnt1 + 1 + f(t & 8); i <= n - f(t & 4); i++) printf("B");
if (t & 4) printf("A");
printf("\n");
if (t & 2) printf("C");
for (int i = 1; i <= cnt2; i++) printf("AC");
for (int i = 2 * cnt2 + 1 + f(t & 2); i <= m - f(t & 1); i++) printf("B");
if (t & 1) printf("A");
printf("\n");
}
int main() {
scanf("%d%d%d%d", &k, &x, &n, &m);
int cnt1, cnt2, cnt3;
for (int i = 0; i <= n / 2; i++)
for (int j = 0; j <= m / 2; j++)
for (int t = 0; t < 16; t++) {
if (i * 2 + f(t & 8) + f(t & 4) > n) continue;
if (j * 2 + f(t & 2) + f(t & 1) > m) continue;
cnt1 = i, cnt2 = j;
bool fin = 1;
for (int p = 3; p <= k; p++) {
cnt3 = cnt1 + cnt2;
if (p == 3)
cnt3 += (f(t & 4) & f(t & 2));
else if (p % 2 == 0)
cnt3 += (f(t & 8) & f(t & 1));
else if (p % 2 == 1)
cnt3 += (f(t & 2) & f(t & 1));
cnt1 = cnt2, cnt2 = cnt3;
if (cnt2 > x) {
fin = 0;
break;
}
}
if (cnt2 != x) fin = 0;
if (fin) {
print(i, j, t);
return 0;
}
}
printf("Happy new year!\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int num[50];
int main() {
int cube;
int sum = 0;
scanf("%d", &cube);
num[1] = 1;
for (int i = 1; i < 50; ++i) num[i] = (1 + i) * i / 2;
for (int i = 1; i < 504; ++i) {
sum = sum + num[i + 1];
if (sum >= cube) {
printf("%d\n", i);
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> all(n);
for (int i = 0; i < n; i++) {
if (s[i] == '1') all[i] = 1;
if (s[i] == '0') all[i] = 0;
if (s[i] == '?') all[i] = -1;
}
int c1 = 0;
int c0 = 0;
int ct = 0;
for (int i = 0; i < k; i++) {
int y = i;
while (y < n) {
if (all[y] == 0) c0++;
if (all[y] == 1) c1++;
if (all[y] == -1) ct++;
y += k;
}
if (c0 == 0 && c1 == 0) {
ct = 0;
continue;
}
if (c0 > 0 && c1 > 0) {
cout << "NO" << endl;
return;
}
int h = 0;
if (c1 > 0) h = 1;
for (int y = i; y < n; y += k) {
all[y] = h;
}
c0 = 0;
c1 = 0;
ct = 0;
}
int cnt = 0;
int sum = 0;
for (int i = 0; i < k; i++) {
if (all[i] > -1)
sum += all[i];
else
cnt++;
}
if (sum <= k / 2 && sum + cnt >= k / 2) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int t;
cin >> t;
while (t > 0) {
solve();
t--;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int maxx(int a, int b) { return a > b ? a : b; }
int minn(int a, int b) { return a < b ? a : b; }
int abss(int a) { return a < 0 ? (-a) : a; }
const int maxn = 2010;
int N;
char inpt[maxn][maxn];
bool row[maxn][2];
bool col[maxn][2];
bool Map[maxn][maxn];
int main() {
while (~scanf("%d", &N)) {
memset(row, 0, sizeof(row));
memset(col, 0, sizeof(col));
for (int i = 1; i <= N; i++) scanf(" %s", inpt[i] + 1);
int ans = 0;
for (int i = 1; i < N; i++) {
for (int j = N; j > i; j--) {
bool nsta = row[i][0] ^ col[j][0];
bool orin = inpt[i][j] == '0' ? 0 : 1;
if (nsta ^ orin) {
ans++;
row[i][0] ^= 1;
col[j][0] ^= 1;
}
}
}
for (int i = N; i > 1; i--) {
for (int j = 1; j < i; j++) {
bool nsta = row[i][1] ^ col[j][1];
bool orin = inpt[i][j] == '0' ? 0 : 1;
if (nsta ^ orin) {
ans++;
row[i][1] ^= 1;
col[j][1] ^= 1;
}
}
}
for (int i = 1; i <= N; i++) {
bool nsta = row[i][0] ^ row[i][1] ^ col[i][0] ^ col[i][1];
bool orin = inpt[i][i] == '0' ? 0 : 1;
if (nsta ^ orin) ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
struct seg {
int l, r, d;
inline bool operator<(const seg& x) const {
return d < x.d || d == x.d && l < x.l;
}
inline bool operator!=(const seg& x) const {
return l != x.l || r != x.r || d != x.d;
}
} a[200005], b[200005];
inline bool check(int d) {
for (int i = 1; i <= m; i++) {
b[i].l = (a[i].l + d - 1) % n + 1;
b[i].r = (a[i].r + d - 1) % n + 1;
b[i].d = a[i].d;
if (b[i].d * 2 == n && b[i].l > b[i].r) swap(b[i].l, b[i].r);
}
sort(b + 1, b + m + 1);
for (int i = 1; i <= m; i++)
if (a[i] != b[i]) return false;
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a[i].l, &a[i].r);
a[i].d = (a[i].r - a[i].l + n) % n;
if (a[i].d * 2 > n) {
swap(a[i].l, a[i].r);
a[i].d = n - a[i].d;
} else if (a[i].d * 2 == n) {
if (a[i].l > a[i].r) swap(a[i].l, a[i].r);
}
}
sort(a + 1, a + m + 1);
for (int d = 1; d * d <= n; d++) {
if (n % d) continue;
if (check(d)) {
puts("Yes");
return 0;
}
if (d > 1 && check(n / d)) {
puts("Yes");
return 0;
}
}
puts("No");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long double v[3];
long double cont(long double x, long double y, long double z, bool c) {
if (c) return z * log(pow(x, y));
return pow(y, z) * log(x);
}
void calc(bool &com, int &head, vector<int> &tail, long double &maxi,
bool parenthesis, int k, vector<int> &resp) {
long double temp = cont(v[k], v[tail[0]], v[tail[1]], parenthesis);
if (maxi + 1e-14 < temp) {
resp = tail;
head = k;
maxi = temp;
com = parenthesis;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
char op[3] = {'x', 'y', 'z'};
vector<vector<int> > perm(3);
for (int i = 0; i < 3; i++) cin >> v[i];
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
if (i != j) perm[i].push_back(j);
vector<int> resp = perm[0];
bool com = false;
long double maxi = cont(v[0], v[1], v[2], false);
int head = 0;
for (int k = 0; k < perm.size(); k++) {
vector<int> temp = perm[k];
do {
calc(com, head, temp, maxi, false, k, resp);
} while (next_permutation(temp.begin(), temp.end()));
temp = perm[k];
do {
calc(com, head, temp, maxi, true, k, resp);
} while (next_permutation(temp.begin(), temp.end()));
}
if (com)
cout << "(" << op[head] << "^" << op[resp[0]] << ")^" << op[resp[1]]
<< "\n";
else
cout << op[head] << "^" << op[resp[0]] << "^" << op[resp[1]] << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct str {
int y, ind, zn;
str() {}
str(int y, int ind, int zn) : y(y), ind(ind), zn(zn) {}
};
int n, q;
int a[200000];
int tree[200000];
long long ans[4000000];
vector<vector<str> > sp;
void update(int v) {
for (; v < n; v = (v | (v + 1))) tree[v]++;
}
long long sum(int r) {
long long res = 0;
for (; r > -1; r = (r & (r + 1)) - 1) res += tree[r];
return res;
}
bool f(int x, int y) { return -1 < x && x < n && -1 < y && y < n; }
void col(int x, int y, int x2, int y2, int ind) {
int mxx = max(x, x2);
int mxy = max(y, y2);
int mnx = min(x, x2);
int mny = min(y, y2);
if (!f(x, y) || !f(x2, y2)) return;
if (f(mxx, mxy)) sp[mxx].push_back(str(mxy, ind, +1));
if (f(mxx, mny - 1)) sp[mxx].push_back(str(mny - 1, ind, -1));
if (f(mnx - 1, mxy)) sp[mnx - 1].push_back(str(mxy, ind, -1));
if (f(mnx - 1, mny - 1)) sp[mnx - 1].push_back(str(mny - 1, ind, +1));
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) scanf("%d", a + i), a[i]--;
sp.resize(n);
for (int i = 0; i < q; i++) {
int x, y, x2, y2;
scanf("%d%d%d%d", &x, &y, &x2, &y2);
x--, y--, x2--, y2--;
col(x - 1, y - 1, 0, 0, i * 18 + 0);
col(n - 1, n - 1, x, y, i * 18 + 1);
col(x - 1, y2, 0, y, i * 18 + 2);
col(n - 1, n - 1, x, 0, i * 18 + 3);
col(x - 1, n - 1, 0, y2 + 1, i * 18 + 4);
col(n - 1, y2, x, 0, i * 18 + 5);
col(x2, n - 1, x, y2 + 1, i * 18 + 6);
col(n - 1, y2, x, 0, i * 18 + 7);
col(n - 1, n - 1, x2 + 1, y2 + 1, i * 18 + 8);
col(x2, y2, x, 0, i * 18 + 9);
col(n - 1, y2, x2 + 1, y, i * 18 + 10);
col(x2, y2, x, 0, i * 18 + 11);
col(n - 1, y - 1, x2 + 1, 0, i * 18 + 12);
col(x2, y2, x, y, i * 18 + 13);
col(x2, y - 1, x, 0, i * 18 + 14);
col(x2, y2, x, y, i * 18 + 15);
col(x2, y2, x, y, i * 18 + 16);
col(x2, y2, x, y, i * 18 + 17);
}
for (int i = 0; i < n; i++) {
update(a[i]);
for (int j = 0; j < sp[i].size(); j++)
ans[sp[i][j].ind] += sum(sp[i][j].y) * sp[i][j].zn;
}
for (int i = 0; i < q; i++) {
long long res = 0;
for (int j = 0; j < 16; j += 2)
res += ans[i * 18 + j] * ans[i * 18 + j + 1];
res += ans[i * 18 + 16] * (ans[i * 18 + 17] - 1) / 2;
printf("%I64d\n", res);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long pref[511111];
long long suff[511111];
long long solve(long long n, long long t, long long a) {
long long ans = 1;
for (int i = 1; i < n; i++) {
if (suff[i] <= t) {
long long count = n - i + 1;
ans = max(ans, count);
long long time = t - suff[i] - (count - 1) * a;
auto it = lower_bound(pref, pref + n, time);
int index = it - pref;
if (pref[index] == time) {
ans = max(ans, count + index);
} else {
ans = max(ans, count + index - 1);
}
}
}
return ans;
}
int main() {
long long n, a, b;
long long t;
cin >> n >> a >> b >> t;
string s;
cin >> s;
t--;
if (s[0] == 'w') t -= b;
if (t < 0) {
cout << 0 << endl;
return 0;
}
for (int i = 1; i < n; i++) {
pref[i] = pref[i - 1] + a + 1;
if (s[i] == 'w') pref[i] += b;
}
suff[n - 1] = 1 + a;
if (s[n - 1] == 'w') suff[n - 1] += b;
for (int i = n - 2; i > 0; i--) {
suff[i] = suff[i + 1] + a + 1;
if (s[i] == 'w') suff[i] += b;
}
long long ans = 1;
for (int i = 1; i < n; i++) {
if (pref[i] <= t) ans = i + 1;
}
if (ans == n) {
cout << n << endl;
return 0;
}
ans = solve(n, t, a);
for (int i = 1; i < n; i++) {
swap(pref[i], suff[n - i]);
}
ans = max(ans, solve(n, t, a));
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int n, m;
string ss, sss;
multiset<unsigned long long> ac;
set<unsigned long long> cur;
inline unsigned long long calc(string &s) {
unsigned long long sum = 0;
for (int i = 0; i < s.length(); i++) {
sum = sum * 1000000007 + s[i];
}
return sum;
}
void dfs(int x) {
if (x == ss.length()) {
cur.insert(calc(sss));
return;
}
if (ss[x] == '?') {
for (char i = 'a'; i <= 'e'; i++) {
sss += i;
dfs(x + 1);
sss.pop_back();
}
dfs(x + 1);
} else {
sss += ss[x];
dfs(x + 1);
sss.pop_back();
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
while (n--) {
cin >> ss;
ac.insert(calc(ss));
}
while (m--) {
cin >> ss;
cur.clear();
sss = "";
dfs(0);
int res = 0;
for (unsigned long long i : cur) {
res += ac.count(i);
}
cout << res << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<int> p;
int res;
void rec(int q) {
if (q == k) {
int inv_cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (p[i] > p[j]) {
inv_cnt++;
}
}
}
res += inv_cnt;
return;
}
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
reverse(p.begin() + i, p.begin() + j + 1);
rec(q + 1);
reverse(p.begin() + i, p.begin() + j + 1);
}
}
inline void solve1() {
res = 0;
rec(0);
cout << res * pow(1.0 / (n * (n + 1) / 2), k) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cout.precision(13);
cout.setf(ios::fixed);
cin >> n >> k;
p.resize(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
p[i]--;
}
if (n <= 6 && k <= 4) {
solve1();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int x[200005];
int res[3];
bool enough(long long d) {
d *= 2;
res[0] = x[0];
int k = 0;
for (int i = 0; i < n; ++i) {
if (res[k] + d < x[i]) {
++k;
if (k == 3) return false;
res[k] = x[i];
}
}
for (int i = k + 1; i < 3; ++i) res[i] = res[k];
return true;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &x[i]);
sort(x, x + n);
for (int i = 0; i < n; ++i) x[i] *= 2;
int l = 0, r = 2000000001, m;
while (l < r) {
m = ((long long)l + r) / 2;
if (!enough(m))
l = m + 1;
else
r = m;
}
enough(l);
printf("%d.%d00000\n", l / 2, 5 * (l % 2));
for (int i = 0; i < 3; ++i) {
int x = res[i] / 2 + l / 2;
printf("%d.%d00000%c", x, 5 * (l % 2), " \n"[i + 1 == 3]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
vector<string> grid(n);
for (auto &it : grid) cin >> it;
vector<array<int, 2>> pos = {
{0, 1}, {1, 0}, {n - 1, n - 2}, {n - 2, n - 1}};
array<char, 4> an1 = {'0', '0', '1', '1'}, an2 = {'1', '1', '0', '0'};
int cnt = 0;
for (int i = 0; i < 4; ++i)
if (an1[i] != grid[pos[i][0]][pos[i][1]]) {
++cnt;
}
if (cnt <= 2) {
cout << cnt << '\n';
for (int i = 0; i < 4; ++i)
if (an1[i] != grid[pos[i][0]][pos[i][1]]) {
cout << pos[i][0] + 1 << ' ' << pos[i][1] + 1 << '\n';
}
continue;
}
cnt = 0;
for (int i = 0; i < 4; ++i)
if (an2[i] != grid[pos[i][0]][pos[i][1]]) {
++cnt;
}
if (cnt <= 2) {
cout << cnt << '\n';
for (int i = 0; i < 4; ++i)
if (an2[i] != grid[pos[i][0]][pos[i][1]]) {
cout << pos[i][0] + 1 << ' ' << pos[i][1] + 1 << '\n';
}
continue;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
multiset<string> s[2];
string a;
void mount() {
string ans;
for (auto x : s[1]) s[0].erase(s[0].find(x));
vector<string> aux;
for (auto x : s[0]) aux.push_back(x);
sort(aux.begin(), aux.end(),
[](string a, string b) { return a.size() < b.size(); });
ans += aux[0];
for (int i = 0; i + 1 < aux.size(); i++) {
multiset<char> s1, s2;
for (auto x : aux[i]) s1.insert(x);
for (auto x : aux[i + 1]) s2.insert(x);
for (auto x : s1) s2.erase(s2.find(x));
ans += *s2.begin();
}
reverse(ans.begin(), ans.end());
cout << "! " << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
cout << "? " << 1 << " " << n << endl;
for (int i = 0; i < (n * (n + 1)) / 2; i++) {
cin >> a;
sort(a.begin(), a.end());
s[0].insert(a);
}
if (n > 1) {
cout << "? " << 1 << " " << n - 1 << endl;
for (int i = 0; i < (n * (n - 1)) / 2; i++) {
cin >> a;
sort(a.begin(), a.end());
s[1].insert(a);
}
}
mount();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int a[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + 1 + n);
long long res = 0, now = 1, cnt = 0;
for (int i = n; i >= 2; i--) {
if (a[i] == a[i - 1] || a[i] == a[i - 1] + 1) {
now *= a[i - 1];
if (++cnt == 2) {
res += now;
cnt = 0;
now = 1;
}
i--;
}
}
cout << res << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
const int maxn = 2e5 + 10;
int n;
vector<int> vec[maxn];
priority_queue<int, vector<int>, greater<int> > Q;
void solve() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
vec[i].clear();
}
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d %d", &x, &y);
vec[x].push_back(y);
}
while (!Q.empty()) Q.pop();
int cnt = 0, now = n;
long long ans = 0;
for (int i = n - 1; i; i--) {
for (int x : vec[i]) Q.push(x);
now -= vec[i].size();
while (cnt < i - now && !Q.empty()) {
cnt++, ans += Q.top(), Q.pop();
}
}
printf("%I64d\n", ans);
}
int main() {
int T;
scanf("%d", &T);
while (T--) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> sq;
bool is_square(int x) { return x == (*lower_bound(sq.begin(), sq.end(), x)); }
int step_to_sq(int x) {
auto it = lower_bound(sq.begin(), sq.end(), x);
int c1 = *it - x;
it--;
int c2 = x - *it;
return min(c1, c2);
}
int main() {
for (int i = 0; i * i < 1010500500; i++) sq.push_back(i * i);
int n;
cin >> n;
vector<int> A, B;
int cnt = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (is_square(x)) {
cnt += 1;
A.push_back(x);
} else {
cnt -= 1;
B.push_back(x);
}
}
long long res = 0;
if (cnt > 0) {
cnt /= 2;
vector<int> g;
for (int i = 0; i < A.size(); i++) {
int cc = 0;
while (is_square(A[i])) {
A[i]++;
cc++;
}
g.push_back(cc);
}
sort(g.begin(), g.end());
for (int i = 0; i < cnt; i++) res += g[i];
} else if (cnt < 0) {
cnt *= -1;
cnt /= 2;
vector<int> g;
for (int i = 0; i < B.size(); i++) {
g.push_back(step_to_sq(B[i]));
}
sort(g.begin(), g.end());
for (int i = 0; i < cnt; i++) res += g[i];
}
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 55, mod = 1e9 + 7;
long long ct[50];
int main() {
string s;
long long i, j, k, n;
cin >> n >> k;
cin >> s;
for (i = 0; i < s.size(); i++) {
ct[s[i] - 'A']++;
}
j = *min_element(ct, ct + k);
j = j * k;
cout << j << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int tree[N << 2], ans[N], ap[N], pre[N];
int n, x;
vector<int> vec[N], Q[N];
void update(int now, int l, int r, int x, int y) {
tree[now] += y;
if (l == r) return;
int mid = (l + r) >> 1;
if (mid >= x)
update(now << 1, l, mid, x, y);
else
update(now << 1 | 1, mid + 1, r, x, y);
}
int query(int now, int l, int r, int k) {
if (l == r) return l;
int mid = (l + r) >> 1;
if (tree[now << 1] <= k)
return query(now << 1 | 1, mid + 1, r, k - tree[now << 1]);
else
return query(now << 1, l, mid, k);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
pre[i] = ap[x];
ap[x] = i;
vec[pre[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
Q[1].push_back(i);
if (!pre[i]) update(1, 1, n + 1, i, 1);
}
for (int i = 1; i <= n; i++) {
while (!Q[i].empty()) {
int k = Q[i].back();
Q[i].pop_back();
Q[query(1, 1, n + 1, k)].push_back(k);
ans[k]++;
}
if (i != n) {
if (pre[i] < i) update(1, 1, n + 1, i, -1);
for (int j = 0, sz = vec[i].size(); j < sz; j++)
update(1, 1, n + 1, vec[i][j], 1);
}
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return puts(""), 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n], i, j, temp, ct = 0, ans;
unordered_map<int, bool> mp;
unordered_map<int, bool> mp2;
for (i = 0; i < n; i++) {
cin >> a[i];
j = a[i];
mp[j] = true;
mp2[j] = true;
}
if (n == 1) {
cout << "-1" << endl;
} else {
for (i = 1; i <= 2047; i++) {
ct = 0;
for (j = 0; j < n; j++) {
temp = a[j] ^ i;
mp2[temp] = false;
}
for (j = 0; j < n; j++) {
temp = a[j];
if (mp2[temp] == true) {
ct = 1;
break;
}
}
if (ct == 0) {
ans = i;
break;
}
for (j = 0; j < n; j++) {
temp = a[j];
mp2[temp] = true;
}
}
if (ct) {
cout << "-1" << endl;
} else {
cout << ans << endl;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int a[100005], t[400005], res, n, m, w, mx = 0;
long long int bs(long long int high, long long int low) {
if (low > high) return -100;
long long int mid = (high + low) / 2, cur = 0, sh = 0;
for (int i = 0; i < n; i++) {
cur -= t[i];
t[i] = 0;
if (mid > a[i] + cur) {
sh += (mid - (a[i] + cur));
t[i + w] += (mid - (a[i] + cur));
cur = mid - a[i];
}
}
if (sh > m) return bs(mid - 1, low);
return max(mid, bs(high, mid + 1));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(t, 0, sizeof t);
cin >> n >> m >> w;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > mx) mx = a[i];
}
res = bs(m + mx + 1, 0);
cout << res << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
long long n, k, tmp, pair = 0;
long long m[101] = {0};
long double res = 0;
scanf("%I64d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &tmp);
m[tmp] += 1;
}
for (int i = 1; i <= 100; i++) {
pair += m[i] / 2;
}
printf("%d", pair / 2);
}
| 1 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int in[200020];
int del_head[200020],del_last[200020];
bool get_ans(int n,int left,int right)
{
if(left==n&&del_head[n]==0)
return true;
for(int i = 1; i <= n-1; i++)
{
if(left < i-1||right > i+2)
continue;
else
{
if(in[i+1]-del_head[i-1] >= 0&&in[i]-del_last[i+2] >= 0)
{
/*cout<<i<<endl;
cout<<in[i+1]-del_head[i-1]<<endl;
cout<<in[i]-del_last[i+2]<<endl;*/
if(in[i+1]-del_head[i-1]==in[i]-del_last[i+2])
return true;
else
continue;
}
else
continue;
}
}
return false;
}
int main()
{
ios::sync_with_stdio(false);
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
for(int i = 1; i <= n; i++)
cin>>in[i];
del_head[1] = in[1];
int rest0 = in[1],left = 1;
for(int i = 2; i <= n; i++)
{
if(in[i] >= rest0)
{
del_head[i] = in[i]-rest0;
rest0 = del_head[i];
left = i;
}
else if(in[i] < rest0)
{
left = i-1; break;
}
}
del_last[n] = in[n];
int rest1 = in[n],right = n;
for(int i = n-1; i >= 1; i--)
{
if(in[i] >= rest1)
{
del_last[i] = in[i]-rest1;
rest1 = del_last[i];
right = i;
}
else if(in[i] < rest1)
{
right = i+1; break;
}
}
bool flag = get_ans(n,left,right);
if(flag==true)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.