solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long n, x, y, ans;
struct Edge {
long long to, next;
} edge[2 * 300001];
long long head[300001], sze;
long long fa[300001], Tsze[300001], deep[300001];
inline long long read() {
long long res = 0;
char c;
while ((c = getchar()) < '0' || c > '9')
;
res = (c ^ 48);
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c ^ 48);
return res;
}
inline void add(long long u, long long v) {
edge[++sze] = (Edge){v, head[u]}, head[u] = sze;
edge[++sze] = (Edge){u, head[v]}, head[v] = sze;
}
inline void dfs(long long u, long long f) {
fa[u] = f, deep[u] = deep[f] + 1, Tsze[u] = 1;
long long i;
for (i = head[u]; i; i = edge[i].next) {
long long v = edge[i].to;
if (v == f) continue;
dfs(v, u), Tsze[u] += Tsze[v];
}
}
inline long long ask() {
if (deep[x] > deep[y]) swap(x, y);
long long ok = 0, i;
for (i = y; i; i = fa[i])
if (i == x) {
ok = 1;
break;
}
if (ok) return (n - Tsze[x] + 1) * Tsze[y];
return Tsze[x] * Tsze[y];
}
signed main() {
n = read(), x = read(), y = read(), ans = n * (n - 1);
long long i;
for (i = 1; i < n; i++) add(read(), read());
dfs(1, 0);
long long a = x, b = y, ok = 0;
for (; a; a = fa[a])
if (fa[a] == y) ans -= Tsze[x] * (n - Tsze[a]), ok = 1;
for (; b; b = fa[b])
if (fa[b] == x) ans -= Tsze[y] * (n - Tsze[b]), ok = 1;
if (!ok) ans -= Tsze[x] * Tsze[y];
printf("%lld", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, d, j, tmp;
string s;
int main() {
cin >> n >> d;
cin >> s;
tmp = 1;
j = 0;
while (tmp != n) {
if (n - tmp <= d) {
j++;
tmp = n;
} else {
int i = d;
while (s[tmp + i - 1] == '0') i--;
if (i == 0) {
cout << -1;
return 0;
} else {
j++;
tmp += i;
}
}
}
cout << j;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 4e5 + 5, N = 5e3 + 5;
int n, _n;
long long ans;
char b[MAX];
int F[N];
bool use[N][N];
struct SAM {
struct p {
int x, y;
} c[MAX];
int l, r, L, num;
int h[MAX], fa[MAX], siz[MAX], len[MAX], tax[MAX], id[MAX];
long long anx[MAX];
int son[MAX][26];
SAM() { l = r = 1; }
void add(int x, int y) { c[++num] = (p){h[x], y}, h[x] = num; }
void ins(int x) {
int tt = r;
len[r = ++l] = ++L, siz[r] = 1;
for (; tt && !son[tt][x]; tt = fa[tt]) son[tt][x] = r;
if (!tt) return void(fa[r] = 1);
int qwq = son[tt][x];
if (len[qwq] == len[tt] + 1) return void(fa[r] = son[tt][x]);
len[++l] = len[tt] + 1;
for (int i = 0; i < 26; ++i) son[l][i] = son[qwq][i];
fa[l] = fa[qwq], fa[qwq] = fa[r] = l;
for (int i = tt; son[i][x] == qwq; i = fa[i]) son[i][x] = l;
}
void Solve(int l, int r) {
int _L = 0;
for (int i = l, x = 1; i <= r; ++i) {
while (x && !son[x][b[i] - 'a']) _L = len[x = fa[x]];
if (!x)
x = 1;
else
x = son[x][b[i] - 'a'], ++_L;
if (_L == i - l + 1)
use[l][i] = 1;
else
break;
}
}
} _S;
int A, B;
int main() {
scanf("%d%d%d%s", &n, &A, &B, b + 1);
memset(F, 1, sizeof(F));
for (int i = 1; i <= n; ++i) {
_S.Solve(i, min(2 * i - 1, n));
_S.ins(b[i] - 'a');
F[i] = A * i;
}
for (int i = 2; i <= n; ++i) {
F[i] = min(F[i], F[i - 1] + A);
for (int j = i; j <= min(2 * i - 1, n); ++j)
if (use[i][j])
F[j] = min(F[j], F[i - 1] + B);
else
break;
}
printf("%d", F[n]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size();
long long left = 0, right = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '^') {
for (int j = i; j < n; j++)
if (s[j] >= '1' && s[j] <= '9') right += (s[j] - '0') * (j - i);
for (int j = i; j >= 0; j--)
if (s[j] >= '1' && s[j] <= '9') left += (s[j] - '0') * (i - j);
break;
}
}
if (left > right)
cout << "left\n";
else if (right > left)
cout << "right\n";
else
cout << "balance\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 510000;
using namespace std;
int n;
vector<vector<int> > had[20];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
had[0].resize(1);
had[0][0].push_back(1);
for (int i = 1; i <= 9; i++) {
had[i].resize(1 << i);
int sz = (1 << i);
sz /= 2;
for (int j = 0; j < (1 << i); j++) {
had[i][j].resize(1 << i);
for (int q = 0; q < (1 << i); q++) {
had[i][j][q] = had[i - 1][j % sz][q % sz];
if (j >= sz && q >= sz) had[i][j][q] ^= 1;
}
}
}
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < (1 << n); j++) {
if (had[n][i][j])
cout << "+";
else
cout << "*";
}
cout << endl;
}
cin.get();
cin.get();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long fp(long long x, long long y, long long m = 998244353) {
long long ANS = 1;
while (y) {
if (y & 1) ANS = (ANS * x) % 998244353;
x = (x * x) % 998244353;
y >>= 1;
}
return ANS;
}
long long inv(long long x, long long m = 998244353) { return fp(x, m - 2); }
long long testcases, arr[200001], n;
string s;
int32_t main() {
iostream::sync_with_stdio(0), cin.tie(0);
cin >> testcases;
while (testcases--) {
cin >> n;
for (long long i = 0; i < n; i++) cin >> arr[i];
cin >> s;
multiset<long long> L, S;
for (long long i = 0; i < n; i++) {
if (s[i] == 'R')
L.insert(arr[i]);
else
S.insert(arr[i]);
}
for (long long i = 1; i <= n; i++) {
auto itr = S.lower_bound(i);
if (itr == S.end()) {
auto itr2 = L.upper_bound(i);
if (itr2 == L.begin()) {
cout << "NO" << '\n';
goto a;
}
itr2--;
L.erase(itr2);
} else
S.erase(itr);
}
cout << "YES" << '\n';
a:;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
if (n % m == 0) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long l, r;
cin >> l >> r;
long long ans = r;
long long d1 = ceil(log10(r + 1)), d2 = ceil(log10(l + 1));
long long rem = pow(10, d1) - 1;
if (r >= rem / 2 && l <= rem / 2) {
ans = rem / 2;
} else if (d1 == d2) {
if (r >= rem / 2) ans = l;
}
long long mirr = rem - ans;
long long mul = mirr * ans;
cout << mul;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[m], i, sum = 0;
for (i = 0; i < m; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + m);
int four = n, two = 2 * n, one = 0, count = 0, extra = 0;
i = m - 1;
while (i >= 0) {
if (a[i] == 0) {
i--;
continue;
}
if (a[i] == 1) {
extra++;
a[i] = 0;
i--;
} else if (a[i] >= 3) {
if (four > 0) {
count += (a[i] > 4 ? 4 : a[i]);
a[i] -= (a[i] > 4 ? 4 : a[i]);
four--;
} else if (two > 0) {
a[i] -= 2;
two--;
count += 2;
} else {
extra += a[i];
a[i] = 0;
i--;
}
} else {
if (two > 0) {
count += 2;
a[i] = 0;
two--;
} else if (four > 0) {
four--;
one++;
a[i] = 0;
count += 2;
} else {
extra += a[i];
a[i] = 0;
i--;
}
}
}
while (extra > 0) {
if (one > 0) {
count += (one > extra ? extra : one);
extra -= one;
one = 0;
} else if (two > 0) {
count++;
extra--;
two--;
} else if (four > 0) {
count += ((extra > 2) ? 2 : extra);
extra -= 2;
four--;
} else {
break;
}
}
if (count == sum)
cout << "YES";
else
cout << "NO";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
const int md = 1000000007;
long long f[maxn], h[maxn], pre[maxn], suf[maxn];
int n;
vector<int> g[maxn];
void dfs1(int p) {
f[p] = 1;
for (int i = 0; i < g[p].size(); i++) {
int v = g[p][i];
dfs1(v);
f[p] = (f[p] * (f[v] + 1)) % md;
}
}
void dfs2(int p) {
if (!g[p].size()) return;
pre[0] = 1;
for (int i = 1; i <= g[p].size() - 1; i++) {
int v = g[p][i - 1];
pre[i] = (pre[i - 1] * (f[v] + 1)) % md;
}
suf[g[p].size() - 1] = 1;
for (int i = g[p].size() - 2; i >= 0; i--) {
int v = g[p][i + 1];
suf[i] = (suf[i + 1] * (f[v] + 1)) % md;
}
for (int i = 0; i < g[p].size(); i++) {
int v = g[p][i];
h[v] = (h[p] * suf[i] % md * pre[i] % md) % md;
h[v] = (h[v] + 1) % md;
}
for (int i = 0; i < g[p].size(); i++) dfs2(g[p][i]);
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int x;
scanf("%d", &x);
g[x].push_back(i);
}
dfs1(1);
h[1] = 1;
dfs2(1);
for (int i = 1; i <= n; i++) {
long long ans = h[i] * f[i] % md;
printf("%I64d ", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, hd[500005], bg[500005], lg[500005], b2[25], st[500005][21],
ed[500005];
unsigned long long bin[500005], b17[500005], hs[500005], HS[500005], ht[500005],
HT[500005];
char s[500005], t[500005];
void gethash() {
for (int i = 1; i <= n; i++)
hs[i] = hs[i - 1] * 26 + s[i] - 'a', HS[i] = HS[i - 1] * 17 + s[i] - 'a';
for (int i = 1; i <= m; i++)
ht[i] = ht[i - 1] * 26 + t[i] - 'a', HT[i] = HT[i - 1] * 17 + t[i] - 'a';
}
unsigned long long get(int l, int r, unsigned long long *x) {
return x[r] - x[l - 1] * bin[r - l + 1];
}
unsigned long long GET(int l, int r, unsigned long long *x) {
return x[r] - x[l - 1] * b17[r - l + 1];
}
void getmatch(int *x) {
int l, r, ans, mid;
for (int i = 1; i <= n; i++) {
l = ans = 0;
r = min(min(m, n - i + 1), k);
while (l <= r) {
mid = (l + r) >> 1;
if (get(i, i + mid - 1, hs) == get(1, 1 + mid - 1, ht) &&
GET(i, i + mid - 1, HS) == GET(1, 1 + mid - 1, HT))
l = (ans = mid) + 1;
else
r = mid - 1;
}
x[i] = ans;
}
}
int Max(int x, int y) { return ed[x] > ed[y] ? x : y; }
int ask(int x, int y) {
int t = lg[y - x + 1];
return Max(st[x][t], st[y - b2[t] + 1][t]);
}
void predeal() {
bin[0] = b2[0] = b17[0] = 1;
for (int i = 1; i <= n; i++) bin[i] = bin[i - 1] * 26;
for (int i = 1; i <= n; i++) b17[i] = b17[i - 1] * 17;
gethash();
getmatch(bg);
reverse(s + 1, s + 1 + n);
reverse(t + 1, t + 1 + m);
gethash();
getmatch(ed);
reverse(ed + 1, ed + 1 + n);
for (int i = 1; i <= n; i++) st[i][0] = i;
for (int i = 1; i <= 20; i++) b2[i] = b2[i - 1] << 1;
for (int i = 2; i <= n; i++) lg[i] = lg[i >> 1] + 1;
for (int j = 1; b2[j] <= n; j++)
for (int i = 1; i + b2[j - 1] <= n; i++)
st[i][j] = Max(st[i][j - 1], st[i + b2[j - 1]][j - 1]);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
scanf("%s%s", s + 1, t + 1);
predeal();
int x, y, len;
for (int i = 1; i <= n; i++)
if (bg[i] == m) {
puts("Yes");
int mid = n >> 1, a1, a2;
if (i > mid)
printf("%d %d", a1 = 1, a2 = i + k <= n ? i + k : n - k + 1);
else if (i + m <= mid)
printf("%d %d", a1 = i + m - k >= 1 ? i + m - k : 1, a2 = mid + 1);
else
printf("%d %d", a1 = mid - k + 1, a2 = mid + 1);
return 0;
}
for (int i = 1; i <= n; i++) {
x = bg[i];
if (i <= k - x) continue;
if (i + x + k - 1 > n) continue;
if (i + m - 1 > n) break;
y = ask(i + m - 1, n - k + m - x);
len = min(ed[y], m - x);
if (y - len + k > n) continue;
if (len + x == m) {
puts("Yes");
printf("%d %d", i + x - k, y - len + 1);
return 0;
}
}
puts("No");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 1e6 + 50;
const long long INF = 2e18;
long long qpower(long long x, long long p, long long M = MOD) {
long long ans = 1;
while (p) {
if (p & 1) ans = ans * x % M;
p >>= 1;
x = x * x % M;
}
return ans;
}
long long gcd(long long a, long long b) {
long long x;
while (b) {
x = a % b;
a = b;
b = x;
}
return a;
}
long long modp(long long x, long long p = MOD) { return (x % p + p) % p; }
long long addp(long long x, long long y, long long p = MOD) {
return x + y >= p ? x + y - p : x + y;
}
long long subp(long long x, long long y, long long p = MOD) {
return x - y < 0 ? x - y + p : x - y;
}
vector<int> E[N];
int ans = 0;
int dep[N];
void dfs(int u, int depth, int fa) {
dep[u] = depth;
for (int v : E[u]) {
if (v != fa) {
dfs(v, dep[u] + 1, u);
if (dep[v] == 1) dep[u] = min(dep[u], 2);
if (dep[v] > 2) ans++, dep[u] = min(dep[u], 1);
}
}
}
int main() {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
int ui, vi;
for (int i = 0; i < n - 1; ++i) {
cin >> ui >> vi;
E[ui].push_back(vi);
E[vi].push_back(ui);
}
dfs(1, 0, 0);
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
inline void gn(long long &first) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, first = 0) : (first = c - '0');
while ((c = getchar()) >= '0' && c <= '9') first = first * 10 + c - '0';
first *= sg;
}
inline void gn(int &first) {
long long t;
gn(t);
first = t;
}
inline void gn(unsigned long long &first) {
long long t;
gn(t);
first = t;
}
inline void gn(double &first) {
double t;
scanf("%lf", &t);
first = t;
}
inline void gn(long double &first) {
double t;
scanf("%lf", &t);
first = t;
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int N, Q, a[200010];
struct Node {
int st, ed;
double sum, fm, fs;
} Mem[200010 * 3];
void push_up(int u) {
Mem[u].sum = Mem[(u << 1)].sum + Mem[((u << 1) + 1)].sum;
}
void build(int u, int st, int ed) {
Mem[u].st = st;
Mem[u].ed = ed;
Mem[u].fm = 1;
Mem[u].fs = 0;
if (st + 1 == ed) {
Mem[u].sum = a[st];
return;
}
build((u << 1), st, (st + ed >> 1));
build(((u << 1) + 1), (st + ed >> 1), ed);
push_up(u);
}
void push_down(int u) {
int st = Mem[u].st, ed = Mem[u].ed;
Mem[(u << 1)].fm *= Mem[u].fm;
Mem[(u << 1)].fs = Mem[(u << 1)].fs * Mem[u].fm + Mem[u].fs;
Mem[(u << 1)].sum =
Mem[(u << 1)].sum * Mem[u].fm + Mem[u].fs * ((st + ed >> 1) - st);
Mem[((u << 1) + 1)].fm *= Mem[u].fm;
Mem[((u << 1) + 1)].fs = Mem[((u << 1) + 1)].fs * Mem[u].fm + Mem[u].fs;
Mem[((u << 1) + 1)].sum =
Mem[((u << 1) + 1)].sum * Mem[u].fm + Mem[u].fs * (ed - (st + ed >> 1));
Mem[u].fm = 1;
Mem[u].fs = 0;
}
void update(int u, int st, int ed, double m, double s) {
st = max(Mem[u].st, st);
ed = min(Mem[u].ed, ed);
if (st >= ed) return;
if (st == Mem[u].st && ed == Mem[u].ed) {
Mem[u].fm *= m;
Mem[u].fs = Mem[u].fs * m + s;
Mem[u].sum = s * (ed - st) + Mem[u].sum * m;
return;
}
push_down(u);
update((u << 1), st, ed, m, s);
update(((u << 1) + 1), st, ed, m, s);
push_up(u);
}
double calc(int u, int st, int ed) {
st = max(Mem[u].st, st);
ed = min(Mem[u].ed, ed);
if (st >= ed) return 0;
if (st == Mem[u].st && ed == Mem[u].ed) {
return Mem[u].sum;
}
push_down(u);
return calc((u << 1), st, ed) + calc(((u << 1) + 1), st, ed);
}
int main() {
int l, r, l_, r_, t;
gn(N);
gn(Q);
for (int i = 0; i < N; i++) gn(a[i]);
build(1, 0, N);
while (Q--) {
gn(t);
if (t == 1) {
gn(l);
gn(r);
gn(l_);
gn(r_);
l--;
l_--;
double s1 = calc(1, l, r);
double s2 = calc(1, l_, r_);
int L1 = r - l, L2 = r_ - l_;
update(1, l, r, 1.0 * (L1 - 1) / L1, s2 / (1.0 * L1 * L2));
update(1, l_, r_, 1.0 * (L2 - 1) / L2, s1 / (1.0 * L1 * L2));
} else {
gn(l);
gn(r);
l--;
printf("%.10lf\n", calc(1, l, r));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct circle {
long long x, y, r;
} C[100100];
long long X, Y, V, T, R;
int n;
const long double eps = 1e-8;
const long double pi = acos(-1.0);
int dcmp(long double x) {
if (fabs(x) <= eps) return 0;
return x < 0 ? -1 : 1;
}
vector<pair<long double, int> > ans;
int flag = 0;
void solve(circle c) {
long double dis = sqrt((long double)(c.x - X) * (c.x - X) +
(long double)(c.y - Y) * (c.y - Y));
if (dis <= c.r) {
flag = 1;
return;
}
if (dcmp(dis - c.r - R) >= 0) return;
long double angO = atan2(c.y - Y, c.x - X);
if (dcmp(angO) < 0) angO += 2 * pi;
long double d = sqrt(dis * dis - c.r * c.r);
long double ang;
if (dcmp(R - d) >= 0) {
ang = asin(c.r / dis);
} else {
ang = acos((R * R + dis * dis - c.r * c.r) / (2.0 * dis * R));
}
long double ang1 = angO - ang;
long double ang2 = angO + ang;
if (dcmp(ang1) < 0) {
ang1 += 2.0 * pi;
ans.push_back(make_pair(ang1, 1));
ans.push_back(make_pair(2 * pi, -1));
ans.push_back(make_pair(0.0, 1));
ans.push_back(make_pair(ang2, -1));
} else if (dcmp(ang2 - 2 * pi) > 0) {
ang2 -= 2.0 * pi;
ans.push_back(make_pair(ang1, 1));
ans.push_back(make_pair(2 * pi, -1));
ans.push_back(make_pair(0.0, 1));
ans.push_back(make_pair(ang2, -1));
} else {
ans.push_back(make_pair(ang1, 1));
ans.push_back(make_pair(ang2, -1));
}
}
int main() {
scanf("%I64d%I64d%I64d%I64d", &X, &Y, &V, &T);
scanf("%d", &n);
R = V * T;
for (int i = 1; i <= n; i++) {
scanf("%I64d%I64d%I64d", &C[i].x, &C[i].y, &C[i].r);
}
for (int i = 1; i <= n; i++) {
solve(C[i]);
if (flag) {
printf("1.00000000000\n");
return 0;
}
}
sort(ans.begin(), ans.end());
int now = 0, last = 0, tmp = 0;
long double sum = 0.0;
for (int i = 0; i < ans.size(); i++) {
tmp += ans[i].second;
now = i;
if (tmp == 0) {
sum += ans[now].first - ans[last].first;
last = now + 1;
}
}
cout << setprecision(11) << sum / (2.0 * pi) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long cnt = 0.5 * n / (k + 1);
cout << cnt << " " << cnt * k << " " << n - cnt - cnt * k << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void recur(long long int taken, long long int pkg_size, long long int capacity,
vector<long long int> &pkg, bool &ok,
vector<vector<long long int> > &dp) {
if (capacity == 0) {
ok = true;
return;
}
if (taken >= pkg_size || capacity < 0 || ok) return;
if (dp[taken][capacity] == 1) return;
dp[taken][capacity] = 1;
recur(taken + 1, pkg_size, capacity - pkg[taken], pkg, ok, dp);
recur(taken + 1, pkg_size, capacity, pkg, ok, dp);
}
void solve() {
long long int n;
cin >> n;
vector<long long int> v(2 * n);
for (long long int i = 0; i < (2 * n); i++) {
cin >> v[i];
}
vector<long long int> pkg;
long long int cur = -1, count = 0;
for (long long int i = 0; i < (2 * n); i++) {
if (v[i] > cur) {
cur = v[i];
if (count > 0) pkg.push_back(count);
count = 0;
}
count++;
}
if (count > 0) pkg.push_back(count);
long long int pkg_size = pkg.size();
bool ok = false;
vector<vector<long long int> > dp(pkg_size + 1, vector<long long int>(n + 1));
recur(0, pkg_size, n, pkg, ok, dp);
if (ok)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
int main() {
long long int t;
cin >> t;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int N = 2048;
int main() {
long long n, m, x1, x2, y1, y2, l1, l2, r1, r2, d1, d2, u1, u2, l, r, d, u,
ans, a1, a2, b1, b2;
int _;
scanf("%d", &_);
while (_--) {
cin >> n >> m >> x1 >> y1 >> x2 >> y2;
if (x1 > x2) {
swap(x1, x2);
swap(y1, y2);
}
l1 = x1 - 1;
r1 = n - x1;
u1 = y1 - 1;
d1 = m - y1;
l2 = x2 - 1;
r2 = n - x2;
u2 = y2 - 1;
d2 = m - y2;
l = min(l1, l2);
r = min(r1, r2);
u = min(u1, u2);
d = min(d1, d2);
ans = (l + r + 1) * (1 + u + d) * 2;
if (x1 < x2) {
a1 = x1 + r;
a2 = x2 - l;
if (y1 < y2) {
b1 = y1 + d;
b2 = y2 - u;
if (a1 >= a2 && b1 >= b2) {
ans -= (a1 - a2 + 1) * (b1 - b2 + 1);
}
} else if (y1 == y2) {
if (a1 >= a2) ans -= (a1 - a2 + 1) * m;
} else {
b1 = y1 - u;
b2 = y2 + d;
if (a1 >= a2 && b1 <= b2) {
ans -= (a1 - a2 + 1) * (b2 - b1 + 1);
}
}
} else if (x1 == x2) {
if (y1 > y2) {
b1 = y1 - u;
b2 = y2 + d;
if (b1 <= b2) ans -= (b2 - b1 + 1) * n;
} else {
b1 = y1 + d;
b2 = y2 - u;
if (b1 >= b2) {
ans -= (b1 - b2 + 1) * n;
}
}
}
cout << n * m - ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Maxm = 120 + 5, Mod = 1000000007;
int n, m, t;
int cnt[Maxm];
int ans, mid;
void dfs(int k, long long res, bitset<Maxm> remain) {
if (k > mid) {
ans = (ans + res) % Mod;
return;
}
dfs(k + 1, res, remain);
if (cnt[k] && !remain[k]) {
bitset<Maxm> bit = remain | remain << k | remain >> k | remain << (m - k) |
remain >> (m - k);
dfs(k + 1, res * cnt[k] % Mod, bit);
}
}
int main() {
scanf("%*d%d%d", &m, &t);
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < t; ++i) {
int x;
scanf("%d", &x);
x %= m;
x = min(x, m - x);
cnt[x]++;
}
ans = 0;
mid = (m + 1) / 2;
bitset<Maxm> bit(1);
dfs(1, 1, bit);
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) { return (y == 0 ? x : gcd(y, x % y)); }
set<pair<long long, long long> > setik;
const int N = 2020;
pair<long long, long long> a[N];
int n;
pair<long long, long long> C;
pair<long long, long long> b[N];
long long p[N];
bool solve(long long x, long long y) {
for (int i = 0; i < n; i++) p[i] = a[i].first * x + a[i].second * y;
sort(p, p + n);
long long S = p[0] + p[n - 1];
for (int i = 0; i < n; i++)
if (p[i] + p[n - 1 - i] != S) return false;
return true;
}
int main() {
scanf("%d", &n);
C = make_pair(0LL, 0LL);
for (int i = 0; i < n; i++) {
long long x, y;
scanf("%lld%lld", &x, &y);
C.first += x;
C.second += y;
x *= 2 * n;
y *= 2 * n;
a[i] = make_pair(x, y);
setik.insert(a[i]);
}
C.first *= 2;
C.second *= 2;
while (!setik.empty()) {
pair<long long, long long> t = *setik.begin();
if (t == C) {
setik.erase(setik.begin());
continue;
}
pair<long long, long long> t2 =
make_pair(2 * C.first - t.first, 2 * C.second - t.second);
if (setik.count(t2) != 0) {
setik.erase(t);
setik.erase(t2);
continue;
}
break;
}
if (setik.empty()) {
printf("-1\n");
return 0;
}
int m = 0;
pair<long long, long long> t1 = *setik.begin();
for (auto t2 : setik) {
b[m++] = make_pair((t1.first + t2.first) / 2 - C.first,
(t1.second + t2.second) / 2 - C.second);
}
for (int i = 0; i < m; i++) {
if (b[i].first < 0 || (b[i].first == 0 && b[i].second < 0)) {
b[i].first *= -1;
b[i].second *= -1;
}
long long g = gcd(abs(b[i].first), abs(b[i].second));
b[i].first /= g;
b[i].second /= g;
}
sort(b, b + m);
m = unique(b, b + m) - b;
int ans = 0;
for (int i = 0; i < m; i++)
if (solve(-b[i].second, b[i].first)) ans++;
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline int rd() {
char ch = getchar();
int i = 0, f = 1;
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
i = (i << 1) + (i << 3) + ch - '0';
ch = getchar();
}
return i * f;
}
const int N = 4e5 + 50;
int n, q, ind;
vector<int> edge[N];
struct node {
node *fa, *lc, *rc;
int dep, tag, id, mn, mx;
node() : fa(NULL), lc(NULL), rc(NULL) {}
inline void upt() {
mn = (mx = dep);
if (lc) mn = min(mn, lc->mn), mx = max(mx, lc->mx);
if (rc) mn = min(mn, rc->mn), mx = max(mx, rc->mx);
}
inline void dec(int v) {
tag += v;
mn -= v;
mx -= v;
dep -= v;
}
inline void pushdown() {
if (!tag) return;
if (lc) lc->dec(tag);
if (rc) rc->dec(tag);
tag = 0;
}
} Pool[N], *pool = Pool, *bg[N], *ed[N], *rt;
inline node *newnode(int dep, int id) {
++pool;
pool->dep = dep;
pool->id = id;
pool->mn = (pool->mx = dep);
return pool;
}
inline void rotate(node *x) {
node *y = x->fa, *z = y->fa;
if (z) (z->lc == y ? z->lc : z->rc) = x;
y->fa = x;
x->fa = z;
if (y->lc == x) {
node *b = x->rc;
x->rc = y;
y->lc = b;
if (b) b->fa = y;
} else {
node *b = x->lc;
x->lc = y;
y->rc = b;
if (b) b->fa = y;
}
y->upt();
x->upt();
}
inline bool which(node *x) { return x->fa->lc == x; }
inline void splay(node *x, node *tar = NULL) {
static node *sta[N];
static int tl;
sta[tl = 1] = x;
for (node *y = x; y->fa; y = y->fa) sta[++tl] = y->fa;
for (int i = tl; i; i--) sta[i]->pushdown();
while (x->fa != tar) {
node *y = x->fa;
if (y->fa != tar) {
if (which(x) == which(y))
rotate(y);
else
rotate(x);
}
rotate(x);
}
if (!tar) rt = x;
}
inline node *inc(node *&now, node *v) {
if (!now) {
now = v;
return v;
}
inc(now->rc, v);
now->rc->fa = now;
now->upt();
return v;
}
inline void dfs(int x, int f) {
bg[x] = newnode((!f) ? 1 : bg[f]->dep + 1, x);
splay(inc(rt, bg[x]));
for (int e = 0; e < edge[x].size(); e++) {
int v = edge[x][e];
if (v == f) continue;
dfs(v, x);
}
ed[x] = newnode((!f) ? 1 : bg[f]->dep + 1, x);
splay(inc(rt, ed[x]));
}
inline node *find(node *k, int v) {
k->pushdown();
if (k->lc && k->lc->mn <= v) return find(k->lc, v);
if (k->dep == v) return k;
return find(k->rc, v);
}
inline node *find_pre(node *k) {
splay(k);
k = k->lc;
while (k->rc) k = k->rc;
return splay(k), k;
}
inline node *find_suf(node *k) {
splay(k);
k = k->rc;
while (k->lc) k = k->lc;
return splay(k), k;
}
inline void print(node *k) {
if (k->lc) print(k->lc);
printf("%d ", k->id);
if (k->rc) print(k->rc);
}
int main() {
n = rd(), q = rd();
for (int i = 1; i <= n; i++) {
int x = rd();
while (x--) edge[i].push_back(rd());
}
dfs(1, 0);
while (q--) {
int op = rd(), x = rd();
if (op == 1) {
int y = rd(), v = 0;
splay(bg[x]);
splay(ed[y], rt);
v = bg[x]->dep + ed[y]->dep;
if (bg[x]->lc && bg[x]->lc == ed[y]) {
swap(x, y);
splay(bg[x]);
splay(ed[y], rt);
}
printf("%d\n", v - 2 * (ed[y]->lc->mn - 1));
} else if (op == 2) {
int y = rd(), tar;
splay(ed[x]);
tar = ed[x]->dep - y;
node *now = ed[x]->rc;
now = find(now, tar);
splay(now);
node *t1 = find_pre(bg[x]), *t2 = find_suf(ed[x]);
splay(t1);
splay(t2, rt);
node *t3 = t2->lc;
t2->lc = NULL;
t3->fa = NULL;
t2->upt();
t1->upt();
t3->dec(y - 1);
node *t4 = find_pre(ed[now->id]);
splay(t4);
splay(ed[now->id], rt);
rt->rc->lc = t3;
t3->fa = rt->rc;
rt->rc->upt();
rt->upt();
} else {
node *now = rt;
int bz = 1;
++x;
do {
now->pushdown();
if (now->rc && now->rc->mx >= x)
now = now->rc;
else if (now->dep == x)
bz = 0;
else
now = now->lc;
} while (bz);
printf("%d\n", now->id);
splay(now);
}
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
queue<int> q[2];
unordered_map<int, int> f[2], w[2];
unordered_set<int> s[2];
int a0[99], a1[99];
int qp(int a, int b, int p) {
int r = 1;
for (; b; b >>= 1, a = a * 1ll * a % p)
if (b & 1) r = r * 1ll * a % p;
return r;
}
int main() {
int j, k, l, o, u, v, p, t0 = 0, t1 = 0;
bool i;
cin >> u >> v >> p;
q[0].push(u), s[0].insert(u), q[1].push(v), s[1].insert(v);
while (1) {
i = s[0].size() > s[1].size(), j = q[i].front(), q[i].pop();
for (k = 1; k < 4; ++k) {
l = ((k == 1 ? j + 1 : (k == 2 ? j - 1 : qp(j, p - 2, p))) + p) % p;
if (s[i].count(l)) continue;
f[i][l] = j, w[i][l] = k, q[i].push(l), s[i].insert(l);
if (s[!i].count(l)) goto gg;
}
}
gg:;
for (j = l; j != u; j = f[0][j]) a0[++t0] = w[0][j];
for (; l != v; l = f[1][l]) a1[++t1] = w[1][l];
cout << t0 + t1 << '\n';
for (; t0; --t0) cout << a0[t0] << ' ';
for (j = 1; j <= t1; ++j)
if (a1[j] == 1)
cout << "2 ";
else if (a1[j] == 2)
cout << "1 ";
else
cout << "3 ";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
struct shoes {
int cost, size, id;
shoes(int cost = 0, int size = 0, int id = 0)
: cost(cost), size(size), id(id) {}
bool operator<(const shoes &b) const { return size < b.size; }
} p[100100], q[100100];
int n, m;
long long f[100100][2][2];
int buy[100100][2][2], prv[100100][2][2];
vector<pair<int, int> > prt;
int find(int x) {
int k = lower_bound(p + 1, p + n + 1, shoes(0, x, 0)) - p;
return p[k].size == x ? k : n + 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d %d", &p[i].cost, &p[i].size), p[i].id = i;
sort(p + 1, p + n + 1);
p[n + 1].cost = inf;
scanf("%d", &m);
for (int i = 1; i <= m; i++)
scanf("%d %d", &q[i].cost, &q[i].size), q[i].id = i;
sort(q + 1, q + m + 1);
q[0].size = -1;
for (int i = 1; i <= m; i++) {
int x = q[i].size, xx = q[i - 1].size;
for (int j = 0; j <= 1; j++) {
for (int k = 0; k <= 1; k++) {
int jj, kk;
if (xx < x - 1)
jj = 0, kk = 0;
else if (xx == x - 1)
jj = k, kk = 0;
else
jj = j, kk = k;
if (f[i - 1][j][k] > f[i][jj][kk]) {
f[i][jj][kk] = f[i - 1][j][k];
buy[i][jj][kk] = 0;
prv[i][jj][kk] = j + 2 * k;
}
if (!jj) {
jj = 1;
int z = find(x);
if (q[i].cost >= p[z].cost) {
long long tmp = f[i - 1][j][k] + p[z].cost;
if (tmp > f[i][jj][kk]) {
f[i][jj][kk] = tmp;
buy[i][jj][kk] = z;
prv[i][jj][kk] = j + 2 * k;
}
}
jj = 0;
}
if (!kk) {
kk = 1;
int z = find(x + 1);
if (q[i].cost >= p[z].cost) {
long long tmp = f[i - 1][j][k] + p[z].cost;
if (tmp > f[i][jj][kk]) {
f[i][jj][kk] = tmp;
buy[i][jj][kk] = z;
prv[i][jj][kk] = j + 2 * k;
}
}
kk = 0;
}
}
}
}
long long ans = 0, x = 0;
for (int j = 0; j <= 1; j++) {
for (int k = 0; k <= 1; k++)
if (f[m][j][k] > ans) ans = f[m][j][k], x = j + 2 * k;
}
printf("%I64d\n", ans);
for (int i = m; i >= 1; i--) {
int j = buy[i][x & 1][x >> 1];
if (j) prt.push_back(make_pair(q[i].id, p[j].id));
x = prv[i][x & 1][x >> 1];
}
printf("%d\n", prt.size());
for (int i = 0; i < prt.size(); i++)
printf("%d %d\n", prt[i].first, prt[i].second);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int res = 0;
void add(int a, int b, int c) {
if (a < b && b < c) {
res += 6;
return;
}
if (a == b && b == c) {
res += 1;
return;
}
res += 3;
}
long long n;
vector<int> divi;
int main() {
cin >> n;
if (n % 3 != 0) {
cout << 0 << endl;
return 0;
}
int a_max = pow(n / 24., 1 / 3.);
long long m = n / 3;
int b_max = pow(n / 6., 1 / 3.);
for (int i = 2; i <= b_max + a_max; i++)
if (m % i == 0) divi.push_back(i);
for (int a = 1; a <= a_max; a++)
for (int bi = 0; bi < divi.size(); bi++) {
int sum = divi[bi];
int b = sum - a;
if (b < a || b > b_max) continue;
long long K = m / sum;
long long B = sum * 1L * sum;
long long di = B - 4 * (a * 1L * b - K);
double desc = sqrt(di + 0.);
int desc2 = (int)(desc + 0.5);
if (abs(desc - desc2) > 0.000001) continue;
int c = (-sum + desc2) / 2;
if (c < b) continue;
add(a, b, c);
}
cout << res << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int powm(long long int x, long long int y,
long long int m = 1000000007) {
x = x % m;
long long int res = 1;
while (y) {
if (y & 1) res = res * x;
res %= m;
y = y >> 1;
x = x * x;
x %= m;
}
return res;
}
long long int factorialNumInverse[200001 + 1];
long long int naturalNumInverse[200001 + 1];
long long int fact[200001 + 1];
void InverseofNumber(long long int p) {
naturalNumInverse[0] = naturalNumInverse[1] = 1;
for (int i = 2; i <= 200001; i++)
naturalNumInverse[i] = naturalNumInverse[p % i] * (p - p / i) % p;
}
void InverseofFactorial(long long int p) {
factorialNumInverse[0] = factorialNumInverse[1] = 1;
for (int i = 2; i <= 200001; i++)
factorialNumInverse[i] =
(naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
}
void factorial(long long int p) {
fact[0] = 1;
for (int i = 1; i <= 200001; i++) {
fact[i] = (fact[i - 1] * i) % p;
}
}
long long int Binomial(long long int n, long long int R, long long int p) {
if (R == 0 or R == n) return 1;
long long int ans =
((fact[n] * factorialNumInverse[R]) % p * factorialNumInverse[n - R]) % p;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
InverseofNumber(1000000007);
InverseofFactorial(1000000007);
factorial(1000000007);
long long int n;
cin >> n;
vector<long long int> arr(n);
for (int i = (0); i <= (n - 1); i += (1)) cin >> arr[i];
long long int ans = 0;
if (n % 2 == 0) {
if ((n / 2) & 1) {
for (int i = (0); i <= (n - 1); i += (2)) {
ans += arr[i] * Binomial((n - 2) / 2, i / 2, 1000000007);
ans %= 1000000007;
}
for (int i = (1); i <= (n - 1); i += (2)) {
ans += arr[i] * Binomial((n - 2) / 2, i / 2, 1000000007);
ans %= 1000000007;
}
} else {
for (int i = (0); i <= (n - 1); i += (1)) {
ans += (i & 1 ? -1 : 1) * arr[i] *
Binomial((n - 2) / 2, i / 2, 1000000007);
ans %= 1000000007;
}
}
} else {
if ((n / 2) & 1) {
for (int i = (0); i <= (n - 1); i += (1)) {
ans += arr[i] *
(i & 1 ? 2 * Binomial((n - 3) / 2, i / 2, 1000000007)
: (i / 2 <= (n - 3) / 2
? Binomial((n - 3) / 2, i / 2, 1000000007)
: 0) -
(i / 2 - 1 >= 0
? Binomial((n - 3) / 2, i / 2 - 1, 1000000007)
: 0));
ans %= 1000000007;
}
} else {
for (int i = (0); i <= (n - 1); i += (2)) {
ans += (arr[i] * Binomial((n - 1) / 2, i / 2, 1000000007));
ans %= 1000000007;
}
}
}
while (ans < 0) ans += 1000000007;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long v[200005];
long long dp[200005];
long long fr[200005];
bool vis[200005];
long long d(long long n) {
if (n < 0) return 0;
if (vis[n]) return dp[n];
vis[n] = 1;
pair<long long, long long> mnn =
min(pair<long long, long long>{(long long)1e15, -1},
pair<long long, long long>{v[n + 1] - v[n] + d(n - 1), 1LL});
if (n >= 2)
mnn = min(mnn, pair<long long, long long>{v[n] - v[n - 2] + d(n - 3), 2LL});
return fr[n] = mnn.second, dp[n] = mnn.first;
}
vector<long long> rtb(long long n, long long *v) {
vector<pair<long long, long long> > vs;
vector<long long> rv(n);
for (long long i = 0; i < n; i++) vs.push_back({v[i], i});
sort(vs.begin(), vs.end());
for (long long i = 0; i < n; i++) rv[vs[i].second] = i;
return rv;
}
long long tid[200005];
long long track(long long n) {
long long i = n - 1, tcnt = 0;
while (i >= 0) {
if (fr[i] == 1)
tid[i] = tcnt, i = i - 1;
else
tid[i] = tid[i - 1] = tid[i - 2] = ++tcnt, i = i - 3;
}
return tcnt;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
long long n;
cin >> n;
for (long long i = 0; i < n; i++) cin >> v[i];
vector<long long> rv = rtb(n, v);
sort(v, v + n);
fr[n - 1] = 2;
cout << (v[n - 1] - v[n - 3] + d(n - 4)) << ' ';
cout << track(n) << '\n';
for (long long i = 0; i < n; i++) cout << tid[rv[i]] << ' ';
cout << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char game[100000 + 8];
int main() {
gets(game);
int a = 0, b = 0, c = 0, len = strlen(game);
bool mark[] = {0, 0, 0, 0};
string result[] = {"00", "01", "10", "11"};
for (int i = 0; i < len; i++)
if (game[i] == '1')
a++;
else if (game[i] == '0')
b++;
else
c++;
if (a + c > b + 1) mark[3] = 1;
if (a < b + c) mark[0] = 1;
if (game[len - 1] == '?' || game[len - 1] == '1') {
int x = a, y = b, z = c;
if (game[len - 1] == '?') x++, z--;
int r = y + z + (len % 2) - x;
r /= 2;
if (r <= z && r >= 0) mark[1] = 1;
}
if (game[len - 1] == '?' || game[len - 1] == '0') {
int x = a, y = b, z = c;
if (game[len - 1] == '?') y++, z--;
int r = y + z + (len % 2) - x;
r /= 2;
if (r <= z && r >= 0) mark[2] = 1;
}
for (int i = 0; i < 4; i++)
if (mark[i]) printf("%s\n", result[i].c_str());
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> works;
int main() {
int N;
cin >> N;
int a = 1;
while (a < 210000 * 10) {
if (a == N || a + 1 == N) {
cout << 1;
return 0;
}
if (a % 2 == 1) {
++a;
a *= 2;
} else {
a *= 2;
++a;
}
}
cout << 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k = 0;
cin >> n;
bool napr[100000];
int a[100000];
char zn;
int pos = 0;
for (int i = 0; i < n; i++) {
cin >> zn;
if (zn == '>')
napr[i] = true;
else
napr[i] = false;
}
for (int i = 0; i < n; i++) cin >> a[i];
int i = 0;
while (k < 101000) {
if (napr[i] == true)
pos += a[i];
else
pos -= a[i];
i = pos;
k++;
if (pos < 0 || pos >= n) {
cout << "FINITE";
return 0;
}
}
cout << "INFINITE";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, T, s, k, m, a1, a2, ans;
int A[1005];
bool ok, ok1, ok2;
int main() {
cin >> T;
for (int i = 1; i <= T; i++) {
cin >> n >> s >> k;
ok = false;
for (int j = 1; j <= k; j++) cin >> A[j];
sort(A + 1, A + k + 1);
m = 0;
for (int j = 1; j <= k; j++)
if (A[j] == s) {
m = j;
ok = true;
break;
}
if (ok == false)
cout << 0 << endl;
else {
ok1 = false;
ok2 = false;
a1 = k;
a2 = 1;
for (int j = m + 1; j <= k; j++)
if (A[j] != A[j - 1] + 1) {
a1 = j - 1;
ok1 = true;
break;
}
if (ok1 == false && A[k] == n) a1 = 1e9 + 1;
for (int j = m - 1; j >= 1; j--)
if (A[j] != A[j + 1] - 1) {
a2 = j + 1;
ok2 = true;
break;
}
if (ok2 == false && A[1] == 1) a2 = -1e9;
ans = min(a1 - m + 1, m - a2 + 1);
cout << ans << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define FOR(i, a, b) for (int (i) = (a); (i) <= (b); (i)++)
#define ROF(i, a, b) for (int (i) = (a); (i) >= (b); (i)--)
#define REP(i, n) FOR(i, 0, (n)-1)
#define sqr(x) ((x) * (x))
#define all(x) (x).begin(), (x).end()
#define reset(x, y) memset(x, y, sizeof(x))
#define uni(x) (x).erase(unique(all(x)), (x).end())
#define BUG(x) cerr << #x << " = " << (x) << endl
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define _1 first
#define _2 second
#define chkmin(a, b) a = min(a, b)
#define chkmax(a, b) a = max(a, b)
int n, q;
int a[35];
int main() {
#ifdef ONLINE_JUDGE
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
#endif
cin >> n >> q;
REP(i, n) cin >> a[i];
while (q--) {
int op;
cin >> op;
if (op == 1) {
int pos, val;
cin >> pos >> val;
a[pos] = val;
continue;
}
vector<ll> now(a, a + n);
int x;
ll k;
cin >> x >> k;
ll ans = 0, have = accumulate(a, a + x + 1, 0LL);
while (have < k) {
FOR(i, x + 1, n - 1) {
ll inc = min(now[i], (k - have) / (1LL << i - x));
ans += inc * ((1 << i - x) - 1);
have += inc * (1 << i - x);
now[i] -= inc;
now[x] += inc * (1 << i - x);
}
ll mx = 0;
REP(i, x + 1) mx += (1 << i) * now[i];
if (mx >= k) {
ans += k - have;
break;
}
int j = x + 1;
while (j < n && !now[j]) j++;
if (j == n) {
ans = -1;
break;
}
ans += j - x;
have += 2;
now[x] += 2;
FOR(i, x + 1, j - 1) now[i]++;
now[j]--;
}
cout << ans << '\n';
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
scanf("%I64d %I64d", &n, &k);
long long a = (n / 2) / (k + 1);
long long b = k * a;
long long c = n - (a + b);
printf("%I64d %I64d %I64d\n", a, b, c);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, a[33][33], vis[33];
int dfs(int u, int sum, int lim) {
if (sum > lim) return 0;
if (u > n) return 1;
int ans = dfs(u + 1, sum, lim);
for (int v = 1; v <= n && ans < k; v++)
if (!vis[v] && a[u][v])
vis[v] = 1, ans += dfs(u + 1, sum + a[u][v], lim), vis[v] = 0;
return ans;
}
int main() {
cin >> n >> m >> k;
while (m--) {
int x, y, z;
cin >> x >> y >> z;
a[x][y] = z;
}
int l = 0, r = 20000, ans = 0;
while (l <= r) {
m = (l + r) / 2;
if (dfs(1, 0, m) >= k)
ans = m, r = m - 1;
else
l = m + 1;
}
cout << ans << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char x[64][500005];
int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
long long d = 0;
for (int i = 0, to = n; i < to; ++i) {
long long a, b, c;
cin >> a >> b;
d ^= b;
c = a ^ b;
for (int j = 0, to = 60; j < to; ++j) x[j][i] = (c >> j) & 1;
}
for (int j = 0, to = 60; j < to; ++j) x[j][n] = (d >> j) & 1;
int i = 0, j = 0;
while (i < 60 && j < n) {
if (!x[i][j]) {
for (int i0 = i + 1, to = 60; i0 < to; ++i0) {
if (x[i0][j]) {
for (int j0 = j, to = n + 1; j0 < to; ++j0) {
swap(x[i][j0], x[i0][j0]);
}
break;
}
}
}
if (x[i][j]) {
for (int i0 = i + 1, to = 60; i0 < to; ++i0) {
if (x[i0][j]) {
for (int j0 = j, to = n + 1; j0 < to; ++j0) {
x[i0][j0] ^= x[i][j0];
}
}
}
i++;
}
j++;
}
int m = 60;
for (int i = 0, to = 60; i < to; ++i) {
bool w = true;
for (int j = 0, to = n; j < to; ++j) {
if (x[i][j]) {
w = false;
break;
}
}
if (w) {
if (x[i][n]) {
m = -1;
break;
} else
m--;
}
}
if (m < 0)
cout << "1/1" << endl;
else
cout << (1LL << m) - 1 << '/' << (1LL << m) << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5;
vector<int> e[N], circ[N];
int v[N], deep[N], top = 0, n, k;
bool use[N];
bool dfs(int u, int pr) {
if (deep[u] + 1 >= (n - 1) / k + 1) {
cout << "PATH" << endl;
cout << deep[u] + 1 << endl;
cout << u << ' ';
return true;
}
use[u] = true;
for (int i = 0; i < e[u].size(); ++i)
if (!use[e[u][i]]) {
deep[e[u][i]] = deep[u] + 1;
if (dfs(e[u][i], u)) {
cout << u << ' ';
return true;
}
}
return false;
}
void find_circle(int u, int pr) {
use[u] = true;
bool lst = true;
v[deep[u]] = u;
int u1 = -1, u2 = -1;
for (int i = 0; i < e[u].size(); ++i)
if (deep[e[u][i]] == deep[u] + 1) {
lst = false;
find_circle(e[u][i], u);
} else if (e[u][i] != pr)
if (u1 < 0)
u1 = e[u][i];
else
u2 = e[u][i];
if (lst && top < k) {
++top;
circ[top].push_back(u);
if ((-deep[u1] + deep[u]) % 3 != 2) {
for (int i = deep[u1]; i < deep[u]; ++i) circ[top].push_back(v[i]);
if (circ[top].size() % 3 == 0) exit(1);
return;
}
if ((-deep[u2] + deep[u]) % 3 != 2) {
for (int i = deep[u2]; i < deep[u]; ++i) circ[top].push_back(v[i]);
if (circ[top].size() % 3 == 0) exit(1);
return;
}
for (int i = min(deep[u1], deep[u2]); i <= max(deep[u1], deep[u2]); ++i)
circ[top].push_back(v[i]);
}
}
int main() {
int i, j, m, a, b;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (i = 0; i < m; ++i) {
cin >> a >> b;
e[a].push_back(b);
e[b].push_back(a);
}
for (i = 1; i <= n; ++i)
if (dfs(i, 0)) return 0;
for (i = 1; i <= n; ++i) use[i] = false;
for (i = 1; i <= n; ++i)
if (!use[i]) find_circle(i, 0);
cout << "CYCLES\n";
for (i = 1; i <= k; ++i) {
if (circ[i].size() == 0) exit(1);
cout << circ[i].size() << "\n";
for (j = 0; j < circ[i].size(); ++j) cout << circ[i][j] << ' ';
cout << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, mod = 998244353, si[2] = {1, -1};
inline int power(int a, int b) {
int k = b % 998244352, t = 1, y = a % mod;
while (k) {
if (k & 1) t = (1ll * t * y) % mod;
y = (1ll * y * y) % mod;
k >>= 1;
}
return t;
}
int fac[N], ifac[N], pw[N];
int n, ans = 0, del;
int main() {
scanf("%d", &n);
fac[0] = pw[0] = 1;
for (int i = 1; i <= n; ++i)
fac[i] = (1ll * fac[i - 1] * i) % mod, pw[i] = (3ll * pw[i - 1]) % mod;
ifac[n] = power(fac[n], mod - 2);
const int pwn = power(pw[n], mod - 2);
for (int i = n - 1; ~i; --i) ifac[i] = (1ll * ifac[i + 1] * (i + 1)) % mod;
for (int i = 1; i <= n; ++i) {
del = (power(pw[n - i] - 1, n) - power(pw[n], n - i) + mod) % mod;
del =
(1ll * (((1ll * (1ll * fac[n] * ifac[i]) % mod) * ifac[n - i]) % mod) *
del) %
mod;
ans = ans + si[i & 1] * del;
if (ans < 0) ans = ans + mod;
if (ans > mod) ans = ans - mod;
}
ans = (3ll * ans) % mod;
ans = (1ll * ans + (power(pw[n] - 3, n) << 1ll)) % mod;
ans = (1ll * ans - 2ll * power(pw[n], n)) % mod;
ans = (ans + mod) % mod;
printf("%d", ((-ans) % mod + mod) % mod);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
int a = 0;
while (x <= y) {
x *= 3;
y *= 2;
a++;
}
cout << a << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string ori[100050], s[100050];
int hs1[100050], hs2[100050];
int p1 = 29, p2 = 31;
int MOD1 = 1e9 + 7, MOD2 = 1e9 + 9;
int st1[12050], st2[12050];
int longhash1[12050];
int longhash2[12050];
char lowerCase(char x) {
if (x >= 'A' && x <= 'Z') x = x - 'A' + 'a';
return x;
}
map<pair<int, int>, int> pairToInd[1050];
int reachable[10050];
void solution() {
int n, m;
string A;
cin >> n >> A;
A = A + "*";
reverse(A.begin(), A.end());
cin >> m;
st1[0] = 1;
st2[0] = 1;
for (int i = (1); i <= (12005); i++) {
st1[i] = (1ll * st1[i - 1] * p1) % MOD1;
st2[i] = (1ll * st2[i - 1] * p2) % MOD2;
}
for (int i = (1); i <= (n); i++) {
longhash1[i] = (longhash1[i - 1] + (A[i] - 'a' + 1) * 1ll * st1[i]) % MOD1;
longhash2[i] = (longhash2[i - 1] + (A[i] - 'a' + 1) * 1ll * st2[i]) % MOD2;
}
for (int i = (1); i <= (m); i++) {
cin >> ori[i];
s[i] = ori[i];
hs1[i] = 0;
hs2[i] = 0;
for (int j = (0); j < (ori[i].size()); j++) {
s[i][j] = lowerCase(ori[i][j]);
hs1[i] = (hs1[i] + (s[i][j] - 'a' + 1) * 1ll * st1[j + n]) % MOD1;
hs2[i] = (hs2[i] + (s[i][j] - 'a' + 1) * 1ll * st2[j + n]) % MOD2;
}
pairToInd[ori[i].size()][make_pair(hs1[i], hs2[i])] = i;
}
reachable[0] = 333;
for (int i = (0); i < (n); i++) {
if (reachable[i] == 0) continue;
for (int len = (1); len <= (1000); len++) {
if (i + len > n) break;
if (reachable[i + len] || pairToInd[len].size() == 0) continue;
int temphash1 = longhash1[i + len] + MOD1 - longhash1[i];
temphash1 = (1ll * temphash1 * st1[n - i - 1]) % MOD1;
int temphash2 = longhash2[i + len] + MOD2 - longhash2[i];
temphash2 = (1ll * temphash2 * st2[n - i - 1]) % MOD2;
if (pairToInd[len].find(make_pair(temphash1, temphash2)) !=
pairToInd[len].end()) {
reachable[i + len] = pairToInd[len][make_pair(temphash1, temphash2)];
}
}
}
int K = n;
vector<int> ans;
while (K > 0) {
ans.push_back(reachable[K]);
K -= s[reachable[K]].size();
}
for (int i = (0); i < (ans.size()); i++) {
if (i) cout << " ";
cout << ori[ans[i]];
}
cout << '\n';
}
int main() { solution(); }
| 5 |
#include <bits/stdc++.h>
using namespace std;
char buf1[100005];
char buf2[100005];
int sf, fs;
int main() {
cin >> buf1 >> buf2;
int ret = 0;
for (int i = 0; buf1[i]; ++i) {
if (buf1[i] == buf2[i]) {
continue;
}
if (buf1[i] == '7') {
++sf;
} else {
++fs;
}
}
ret = max(sf, fs);
cout << ret << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400005;
long long u, w, cnt = 0, x, pre[maxn][21], val[maxn], sum[maxn][21];
long long ans = 0;
int type, m;
int main() {
scanf("%d", &m);
val[++cnt] = 0;
for (int i = 0; i <= 20; i++) sum[1][i] = 1e18;
val[0] = 1e18;
for (int i = 1; i <= m; i++) {
scanf("%d %lld %lld", &type, &u, &x);
u ^= ans;
x ^= ans;
if (type == 1) {
cnt++;
val[cnt] = x;
if (val[u] >= x)
pre[cnt][0] = u;
else {
for (int i = 20; i >= 0; i--) {
if (val[pre[u][i]] < x) {
u = pre[u][i];
}
}
pre[cnt][0] = pre[u][0];
}
sum[cnt][0] = !pre[cnt][0] ? 1e18 : val[pre[cnt][0]];
for (int i = 1; i <= 20; i++) {
pre[cnt][i] = pre[pre[cnt][i - 1]][i - 1];
sum[cnt][i] =
!pre[cnt][i] ? 1e18 : sum[pre[cnt][i - 1]][i - 1] + sum[cnt][i - 1];
}
} else {
if (x < val[u]) {
printf("0\n");
ans = 0ll;
continue;
}
ans = 1ll;
x -= val[u];
for (int i = 20; i >= 0; i--) {
if (sum[u][i] <= x) {
x -= sum[u][i];
ans += (1 << i);
u = pre[u][i];
}
}
printf("%lld\n", ans);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
bool islucky = false;
cin >> n;
if (n % 4 == 0 || n % 7 == 0 || n % 44 == 0 || n % 77 == 0 || n % 74 == 0 ||
n % 47 == 0 || n % 444 == 0 || n % 777 == 0 || n % 477 == 0 ||
n % 447 == 0 || n % 474 == 0 || n % 744 == 0 || n % 747 == 0 ||
n % 774 == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000;
long long m, l, r, k;
struct matrix {
long long g[2][2];
matrix() { memset(g, 0, sizeof g); }
void print() {
int i, j;
for (i = 0; i < 2; ++i, printf("\n"))
for (j = 0; j < 2; ++j) cout << g[i][j] << " ";
}
};
matrix operator*(const matrix& a, const matrix& b) {
int i, j, k;
matrix c;
for (i = 0; i < 2; ++i)
for (j = 0; j < 2; ++j)
for (k = 0; k < 2; ++k)
c.g[i][j] = (c.g[i][j] + a.g[i][k] * b.g[k][j]) % m;
return c;
}
matrix power(matrix c, long long b) {
int i;
matrix k;
for (i = 0; i < 2; ++i) k.g[i][i] = 1;
while (b) {
if (b % 2 == 1) k = k * c;
c = c * c;
b /= 2;
}
return k;
}
long long ask(long long d) {
matrix begin, ans;
begin.g[0][0] = 0;
begin.g[0][1] = 1;
begin.g[1][0] = 1;
begin.g[1][1] = 1;
ans = power(begin, d - 1);
return (ans.g[0][0] + ans.g[0][1]) % m;
}
long long calc(long long mid) {
long long sum1 = r / mid;
long long sum2 = (l - 1) / mid;
return sum1 - sum2;
}
int main() {
cin >> m >> l >> r >> k;
long long top = min(1000050LL, r), ans = 0, i;
for (i = 1; i <= top; ++i) {
if (calc(i) >= k) ans = max(i, ans);
if (calc(r / i) >= k) ans = max(r / i, ans);
}
cout << ask(ans) << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int k;
const int maxn = 1100;
bool adj[maxn][maxn];
int main() {
cin >> k;
if (k == 1) {
cout << "YES" << endl << 2 << " " << 1 << endl << 1 << " " << 2 << endl;
return 0;
}
if (k % 2 == 0) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
cout << 2 * k + 4 << " " << ((2 * k + 4) * k) / 2 << endl;
for (int i = 0; i < k + 1; i++) {
for (int j = i + 1; j < k + 1; j++) {
adj[i][j] = adj[j][i] = 1;
}
}
for (int i = 0; i < k - 1; i++) {
if (i % 2 == 0) {
for (int j = i + 1; j < k + 1; j++) {
if (adj[i][j]) {
adj[i][j] = adj[j][i] = 0;
break;
}
}
}
adj[k + 1][i] = adj[i][k + 1] = 1;
}
for (int i = 0; i <= k + 1; i++) {
for (int j = i + 1; j <= k + 1; j++) {
if (adj[i][j]) {
cout << i + 1 << " " << j + 1 << endl;
}
}
}
cout << k + 2 << " " << 2 * k + 4 << endl;
for (int i = 0; i <= k + 1; i++) {
for (int j = i + 1; j <= k + 1; j++) {
if (adj[i][j]) {
cout << k + 2 + i + 1 << " " << k + 2 + j + 1 << endl;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m;
long double k;
cin >> n >> m >> k;
vector<pair<string, long long int> > v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
}
vector<pair<string, long long int> > x(m);
for (int i = 0; i < m; i++) {
cin >> x[i].first;
x[i].second = 0;
}
vector<pair<string, long long int> > ans;
map<string, long long int> mx;
for (int i = 0; i < n; i++) {
long double xx = v[i].second;
long long int z = xx * k + 1e-7;
if (z >= 100) {
ans.push_back(make_pair(v[i].first, z));
mx[v[i].first] = 1;
}
}
for (int i = 0; i < m; i++) {
if (mx.find(x[i].first) == mx.end()) {
mx[x[i].first] = 1;
ans.push_back(x[i]);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
vector<pair<int, int>> edges;
int vertices[100000][2], N;
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
int d, s;
cin >> d >> s;
if (d == 1) q.push(i);
vertices[i][0] = d;
vertices[i][1] = s;
}
while (!q.empty()) {
int i = q.front();
q.pop();
int to = vertices[i][1];
if (!vertices[i][0]) continue;
edges.push_back(make_pair(i, to));
vertices[to][0]--;
vertices[to][1] ^= i;
if (vertices[to][0] == 1) q.push(to);
}
cout << edges.size() << endl;
for (auto e : edges) cout << e.first << " " << e.second << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int prefix[100000];
int suffix[100000];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string a, b, s1, s2;
cin >> a >> b;
int asize = a.size();
int bsize = b.size();
fill(prefix, prefix + bsize, 1e6);
fill(suffix, suffix + bsize, 1e6);
int pos = 0;
for (int i = 0; i < asize; i++) {
if (pos < bsize && a[i] == b[pos]) {
prefix[pos++] = i + 1;
}
}
pos = bsize - 1;
for (int i = asize - 1; i >= 0; i--) {
if (pos >= 0 && a[i] == b[pos]) {
suffix[pos--] = (asize - 1) - i + 1;
}
}
int ans_px = -1;
int ans_sx = 1e6;
int max_num = 0;
for (int i = 1; i < bsize; i++) {
if (prefix[i - 1] <= asize && i > max_num) {
ans_px = i;
ans_sx = 1e6;
max_num = i;
}
}
for (int i = bsize - 1; i >= 0; i--) {
if (suffix[i] <= asize && bsize - i > max_num) {
ans_px = -1;
ans_sx = i;
max_num = bsize - i;
}
}
int px = 1, sx = 1;
while (px < bsize && prefix[px - 1] < asize) {
while (sx < bsize && prefix[px - 1] + suffix[sx] > asize) sx++;
if (prefix[px - 1] + suffix[sx] <= asize && bsize - (sx - px) > max_num) {
ans_px = px;
ans_sx = sx;
max_num = bsize - (sx - px);
}
px++;
if (sx < px) sx = px;
}
if (ans_px < 0 && bsize <= ans_sx) {
cout << "-" << endl;
return 0;
}
for (int i = 0; i < ans_px; i++) cout << b[i];
for (int i = ans_sx; i < bsize; i++) cout << b[i];
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 1e5 + 10, sz2 = 200, bl = 510;
int n, m;
int q[sz2][sz], fi[sz2][sz], la[sz2][sz], to[sz], ma[sz2], add[sz2];
int l, r;
int ar[sz];
void ins(int nu, int p, int va) {
if (q[nu][p]) {
to[va] = fi[nu][p], fi[nu][p] = va;
} else {
fi[nu][p] = va, la[nu][p] = va, to[va] = -p;
}
q[nu][p]++;
}
void merge(int nu, int f, int t) {
if (q[nu][t])
to[la[nu][t]] = fi[nu][f];
else
fi[nu][t] = fi[nu][f];
la[nu][t] = la[nu][f];
to[la[nu][t]] = -t;
q[nu][t] += q[nu][f], q[nu][f] = 0;
}
void cha(int nu, int x) {
for (int a = nu * bl + 1; a <= min(n, (nu + 1) * bl); a++) ar[a] = 0;
for (int a = nu * bl + 1; a <= min(n, (nu + 1) * bl); a++) {
if (ar[a] == 0) {
int cu = a;
while (cu > 0) cu = to[cu];
int p = -cu;
cu = fi[nu][p];
while (cu > 0) {
ar[cu] = p - add[nu];
if (ar[cu] > x and cu >= l + 1 and cu <= r + 1) ar[cu] -= x;
cu = to[cu];
}
q[nu][p] = 0;
}
}
for (int a = nu * bl + 1; a <= min(n, (nu + 1) * bl); a++) ins(nu, ar[a], a);
add[nu] = 0;
}
int que(int nu, int x) {
int re = 0;
if (x <= ma[nu]) {
x += add[nu];
if (q[nu][x]) {
int cu = fi[nu][x];
while (cu > 0) {
if (cu >= l + 1 and cu <= r + 1) re++;
cu = to[cu];
}
}
}
return re;
}
int main() {
for (int a = 0; a < sz2; a++)
for (int b = 1; b < sz; b++) q[a][b] = 0;
cin >> n >> m;
for (int a = 0; a < n; a++) {
int x;
scanf("%d", &x);
int nu = a / bl;
ma[nu] = sz - 1, add[nu] = 0;
ins(nu, x, a + 1);
}
for (int a = 0; a < m; a++) {
int ty, x;
scanf("%d%d%d%d", &ty, &l, &r, &x);
l--, r--;
int lg = l / bl, rg = r / bl;
if (ty == 1) {
cha(lg, x);
if (rg != lg) cha(rg, x);
for (int b = lg + 1; b < rg; b++) {
if (ma[b] > x) {
if (ma[b] - x < x) {
for (int c = ma[b] + add[b]; c > x + add[b]; c--) {
if (q[b][c]) merge(b, c, c - x);
}
} else {
for (int c = 1 + add[b]; c <= x + add[b]; c++) {
if (q[b][c]) merge(b, c, c + x);
}
add[b] += x;
}
ma[b] = max(ma[b] - x, x);
}
}
} else {
int an = que(lg, x);
if (lg != rg) an += que(rg, x);
for (int b = lg + 1; b < rg; b++) {
if (x <= ma[b]) an += q[b][x + add[b]];
}
printf("%d\n", an);
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, k, n, arr[200200], minhod, sum, sum1, tekhod;
cin >> t;
for (int j = 0; j < t; j++) {
sum = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
sort(arr, arr + n);
if (sum <= k)
cout << 0;
else {
minhod = sum - k;
for (int i = 1; i < n; i++) {
sum -= arr[n - i];
sum += arr[0];
if (sum <= k)
tekhod = i;
else
tekhod = i + (sum - k - 1) / (i + 1) + 1;
minhod = min(minhod, tekhod);
}
cout << minhod;
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10005;
map<int, int> qq;
int a[maxn];
int b[maxn];
int main() {
int q;
scanf("%d", &q);
while (q--) {
int n;
scanf("%d", &n);
qq.clear();
for (int i = 1; i <= n * 4; i++) {
scanf("%d", &a[i]);
qq[a[i]]++;
}
int fi = 0;
int temp = 0;
for (int i = 1; i <= n * 4; i++) {
if (qq[a[i]] & 1) {
fi = 1;
break;
} else if (qq[a[i]] != 0) {
int jishu = qq[a[i]] / 2;
while (jishu) {
b[temp++] = a[i];
jishu--;
}
qq[a[i]] = 0;
}
}
if (fi == 1) {
printf("NO\n");
} else {
sort(b, b + temp);
if (temp & 1) {
printf("NO\n");
} else {
int i = temp - 1;
int j = 0;
long long int area = 1ll * b[j] * b[i];
int fi = 0;
while (j < i) {
if (area != 1ll * b[j] * b[i]) {
fi = 1;
}
j++;
i--;
}
if (fi) {
printf("NO\n");
} else {
printf("YES\n");
}
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int n, val[MAXN];
vector<int> adj[MAXN];
bool root[MAXN];
set<int> st;
void dfs(int v, int mx = -1, int mn = 2e9) {
if (mx < val[v] && mn > val[v]) st.insert(val[v]);
if (adj[v][0] >= 0) dfs(adj[v][0], mx, min(mn, val[v]));
if (adj[v][1] >= 0) dfs(adj[v][1], max(mx, val[v]), mn);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
int l, r;
cin >> val[i] >> l >> r;
l--, r--;
adj[i].push_back(l);
adj[i].push_back(r);
if (l >= 0) root[l] = 1;
if (r >= 0) root[r] = 1;
}
int rt = -1;
for (int i = 0; i < n; i++)
if (!root[i]) rt = i;
dfs(rt);
int ans = 0;
for (int i = 0; i < n; i++)
if (st.find(val[i]) == st.end()) ans++;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, top1, top2, a[1000000], sta1[1000000], sta2[1000000];
long long ans;
struct segment_tree {
int a[4000000], b[4000000], lazy[4000000];
void pushdown(int k) {
int t = lazy[k];
a[k << 1] += t;
lazy[k << 1] += t;
a[(k << 1) | 1] += t;
lazy[(k << 1) | 1] += t;
lazy[k] = 0;
}
void build(int l, int r, int k) {
a[k] = l;
b[k] = 1;
if (l == r) return;
int mid = (l + r) >> 1;
build(l, mid, k << 1);
build(mid + 1, r, (k << 1) | 1);
}
void update(int l, int r, int k, int x, int y, int z) {
if (l >= x && r <= y) {
a[k] += z;
lazy[k] += z;
return;
}
pushdown(k);
int mid = (l + r) >> 1;
if (x <= mid) update(l, mid, k << 1, x, y, z);
if (y > mid) update(mid + 1, r, (k << 1) | 1, x, y, z);
a[k] = min(a[k << 1], a[(k << 1) | 1]);
b[k] = 0;
if (a[k] == a[k << 1]) b[k] += b[k << 1];
if (a[k] == a[(k << 1) | 1]) b[k] += b[(k << 1) | 1];
}
int find(int l, int r, int k, int x, int y) {
if (l >= x && r <= y) return (a[k]) ? 0 : b[k];
pushdown(k);
int mid = (l + r) >> 1, ans = 0;
if (x <= mid) ans += find(l, mid, k << 1, x, y);
if (y > mid) ans += find(mid + 1, r, (k << 1) | 1, x, y);
return ans;
}
} st;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x] = y;
}
st.build(1, n, 1);
for (int i = 1; i <= n; i++) {
st.update(1, n, 1, 1, n, -1);
while (top1 && a[sta1[top1]] < a[i])
st.update(1, n, 1, sta1[top1 - 1] + 1, sta1[top1], a[i] - a[sta1[top1]]),
--top1;
while (top2 && a[sta2[top2]] > a[i])
st.update(1, n, 1, sta2[top2 - 1] + 1, sta2[top2], a[sta2[top2]] - a[i]),
--top2;
sta1[++top1] = sta2[++top2] = i;
ans += st.find(1, n, 1, 1, i);
}
printf("%lld", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
char T[3];
char C1[3], C2[3];
int getval(char suit) {
if (suit == 'A') return 1000;
if (suit == 'K') return 999;
if (suit == 'Q') return 998;
if (suit == 'J') return 997;
if (suit == 'T') return 900;
return suit;
}
int main() {
cin >> T;
cin >> C1 >> C2;
if (C1[1] == C2[1]) {
if (getval(C1[0]) > getval(C2[0]))
cout << "YES" << endl;
else
cout << "NO" << endl;
} else if (C1[1] == T[0]) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[123424];
int c[123412];
map<pair<int, int>, bool> e;
bool tiitvojadjeca(int p, int i, int k) {
bool ans = 1;
for (auto x : v[i]) {
if (x == p) continue;
if (e.count(make_pair(i, x)))
ans &= e[make_pair(i, x)];
else if (c[x] == k) {
ans &= tiitvojadjeca(i, x, c[x]);
e[make_pair(i, x)] = ans;
} else
return false;
if (!ans) return false;
}
return true;
}
bool inves(int i) {
bool ans = 1;
for (auto x : v[i]) {
ans &= tiitvojadjeca(i, x, c[x]);
if (!ans) return false;
}
return true;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; ++i) {
int t, p;
scanf("%d %d", &t, &p);
v[t].push_back(p);
v[p].push_back(t);
}
for (int i = 1; i <= n; ++i) scanf("%d", c + i);
for (int i = 1; i <= n; ++i) {
if (inves(i)) {
return !printf("YES\n%d", i);
}
}
printf("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool b[2000005];
char c[2000005];
int h[2000005], q[2000005];
int i, j, k, n, H, T, t;
int main() {
scanf("%s", c + 1);
n = strlen(c + 1);
for (i = 1; i <= n; i++) t += (c[i] == '(') ? 1 : -1;
for (i = n + 1; i <= n * 2; i++) c[i] = c[i - n];
if (t < 0)
for (i = 1; i <= -t; i++) putchar('(');
for (i = 1; i <= 2 * n; i++) h[i] = h[i - 1] + ((c[i] == '(') ? 1 : -1);
H = 1;
T = 0;
for (i = 1; i <= n; i++) {
for (; T && h[i] < h[q[T]]; T--)
;
q[++T] = i;
}
for (i = 1; i <= n; i++) {
if (h[q[H]] - h[i - 1] < min(t, 0)) b[i] = 1;
for (; T >= H && h[n + i] < h[q[T]]; T--)
;
q[++T] = n + i;
if (q[H] == i) H++;
}
for (i = 1, j = 2;;) {
for (; b[i]; i++)
;
for (; b[j]; j++)
;
if (i == j)
for (j++; b[j]; j++)
;
if (i > n || j > n) break;
for (k = 0; k < n && c[i + k] == c[j + k]; k++)
;
if (c[i + k] < c[j + k])
j = j + k + 1;
else
i = i + k + 1;
}
if (j < i) i = j;
for (j = i; j < n + i; j++) putchar(c[j]);
if (t > 0)
for (i = 1; i <= t; i++) putchar(')');
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long int n, l, r;
cin >> n >> l >> r;
long long int l1 = 0, r1 = n - 1, mid, pos = -1;
while (l1 <= r1) {
mid = l1 + (r1 - l1) / 2;
if (2 * mid * n - mid * (mid + 1) < l) {
l1 = mid + 1;
pos = mid;
} else
r1 = mid - 1;
}
long long int t = r - l + 1;
l = l - (2 * pos * n - pos * (pos + 1));
if (pos == n - 1) {
cout << 1 << "\n";
continue;
}
pos++;
int i = 0;
long long int count1, c;
while (t > 0) {
if (pos == n) {
cout << 1;
break;
}
if (i == 0) {
if (l % 2 == 0) {
cout << pos + l / 2 << " ";
t--;
l++;
}
count1 = 2 * (n - pos) - (l - 1);
c = l / 2 + 1;
i++;
} else {
count1 = 2 * (n - pos);
c = 1;
}
while (count1 > 0 && t > 0) {
if (t <= 0) break;
cout << pos << " ";
t--;
if (t <= 0) break;
cout << pos + c << " ";
t--;
c++;
count1 -= 2;
}
pos++;
if (t <= 0) break;
}
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int A[100010], B[100010], n, x, cnt;
int main() {
cin >> n >> x;
for (int I = 0; I < n; ++I) cin >> A[I];
for (int I = 0; I < n; ++I) cin >> B[I];
sort(A, A + n), sort(B, B + n);
cnt = 0;
for (int I = 0, J = n - 1; I < n && J >= 0; ++I)
if (A[I] + B[J] >= x) ++cnt, --J;
cout << "1 " << cnt << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100003;
const int INF = 1000 * 1000 * 1000 + 7;
const long double EPS = 1e-9, pi = 3.1415926535897932384626433832795;
int n;
vector<int> a;
void solve() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int ans = 0;
for (int i = n - 2; i >= 0; i--) {
if (a[i] > a[i + 1]) {
printf("%d", i + 1);
exit(0);
}
}
printf("%d", ans);
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793;
const int eps = 1e-10;
const int base = 1e9;
const int N = 100005;
bool pr(int n) {
if (n == 2) return true;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
int main() {
vector<int> v;
for (int i = 2; i <= 100; i++)
if (pr(i)) {
v.push_back(i);
}
int c = 0;
for (int i = 0; i < 15; i++) {
cout << v[i] << endl;
fflush(stdout);
string s;
cin >> s;
if (s == "yes") c++;
if (v[i] == 2 || v[i] == 3 || v[i] == 5 || v[i] == 7) {
cout << v[i] * v[i] << endl;
fflush(stdout);
cin >> s;
if (s == "yes") c++;
}
}
if (c >= 2)
cout << "composite" << endl;
else
cout << "prime" << endl;
fflush(stdout);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, a, sum = 0;
cin >> n >> x;
while (n--) {
cin >> a;
sum += a;
}
cout << (int)ceil((double)(abs(sum)) / x) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int v;
cin >> v;
if (v == 2)
cout << 2;
else
cout << 1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = (int)(1e6 + 5);
int F[MAX], B[MAX];
int ARR[MAX], ANS[MAX];
int main() {
cin.tie(0), ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
for (int i = 1; i <= N; i++) {
cin >> F[i];
if (ARR[F[i]])
ARR[F[i]] = -1;
else
ARR[F[i]] = i;
}
bool ambi = false, ok = false;
for (int i = 1; i <= M; i++) {
cin >> B[i];
if (ARR[B[i]] == 0)
ok = true;
else if (ARR[B[i]] == -1)
ambi = true;
else
ANS[i] = ARR[B[i]];
}
if (ok)
cout << "Impossible" << endl;
else if (ambi)
cout << "Ambiguity" << endl;
else {
cout << "Possible" << endl;
for (int i = 1; i <= M; i++) cout << ANS[i] << ' ';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int dp[maxn], s[maxn], pre[maxn], nxt[maxn];
int dp1[maxn];
int vis[maxn];
int lft[maxn], rht[maxn], cnt;
int pos[maxn];
int qian[maxn], hou[maxn], tot[maxn];
int main() {
int n, m, i, j, k;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &j), vis[j] = 1;
for (i = 1; i <= 200000; i++)
if (vis[i]) {
for (j = i; vis[j]; j++)
;
++cnt;
lft[cnt] = i;
rht[cnt] = j - 1;
i = j;
}
for (i = 1; i <= cnt; i++) tot[i] = rht[i] - lft[i] + 1 + tot[i - 1];
for (i = 1; i <= m; i++) scanf("%d", &pos[i]);
sort(pos + 1, pos + 1 + m);
for (i = 1; i <= m; i++) {
pre[pos[i]] = nxt[pos[i]] = i;
s[pos[i]] = 1;
}
for (i = 1; i <= 200000; i++) {
s[i] += s[i - 1];
if (!pre[i]) pre[i] = pre[i - 1];
}
for (i = 200000; i >= 1; i--)
if (!nxt[i]) nxt[i] = nxt[i + 1];
for (i = 1; i <= m; i++) qian[i] = cnt, hou[i] = cnt;
for (i = 1; i <= cnt; i++) {
dp[i] = s[rht[i]] - s[lft[i] - 1] + dp1[i - 1];
for (j = pre[lft[i] - 1]; j; j--) {
while (qian[j] && tot[i - 1] - tot[qian[j] - 1] < lft[i] - pos[j])
qian[j]--;
if (qian[j])
dp[i] = max(dp[i], s[rht[i]] - s[lft[i] - 1] + pre[lft[i] - 1] - j + 1 +
dp1[qian[j] - 1]);
else
break;
}
for (j = nxt[rht[i] + 1]; j && j <= m; j++) {
while (tot[hou[j] - 1] - tot[i] >= pos[j] - rht[i]) hou[j]--;
if (tot[hou[j]] - tot[i] >= pos[j] - rht[i])
dp1[hou[j]] = max(dp1[hou[j]], dp[i] + j - nxt[rht[i] + 1] + 1);
else
break;
}
dp1[i] = max(dp1[i], dp[i]);
}
printf("%d\n", dp1[cnt]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int pw[200005];
void initial() {
pw[0] = 1;
for (long long int i = 1; i < 200005; i++) {
pw[i] = (31 * pw[i - 1]) % 1000000007;
}
}
string s1, s2;
string string1(string s1) {
if (s1.size() % 2 == 1) {
return s1;
}
string t1, t2;
t1 = "", t2 = "";
for (long long int i = 0; i < s1.size() / 2; i++) {
t1 += s1[i];
}
for (long long int i = s1.size() / 2; i < s1.size(); i++) {
t2 += s1[i];
}
t1 = string1(t1);
t2 = string1(t2);
if (t1 < t2) {
return (t1) + (t2);
} else {
return (t2) + (t1);
}
}
inline void solve() {
initial();
cin >> s1 >> s2;
if (string1(s1) == string1(s2)) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tests = 1;
while (tests--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int ask(string s) {
for (int i = 0; i < s.length(); i++) printf("%c", s[i]);
printf("\n");
fflush(stdout);
int x;
scanf("%d", &x);
if (x == 0) exit(0);
return x;
}
int main() {
int a = ask("a");
int n = a + 1;
n = min(n, 300);
string s = "";
for (int i = 0; i < n; i++) s += 'a';
int base = ask(s);
if (base == n) {
s = "";
for (int i = 0; i < n - 1; i++) s += 'b';
ask(s);
s = "";
for (int i = 0; i < n; i++) s += 'b';
ask(s);
} else {
for (int i = 0; i < n; i++) {
s[i] = 'b';
int res = ask(s);
if (res < base)
base = res;
else
s[i] = 'a';
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> E[100001];
vector<int> G[100001];
int n, m, co = 1, res;
int vis[100001], col[100001], cnt[100001], ans[100001];
void dfs1(int x, int c) {
col[x] = c;
cnt[c]++;
for (int i = 0; i < E[x].size(); i++)
if (!col[E[x][i]]) dfs1(E[x][i], c);
}
void dfs2(int x) {
vis[x] = 1;
for (int i = 0; i < G[x].size(); i++) {
if (vis[G[x][i]] == 1) ans[col[x]] = 0;
if (!vis[G[x][i]]) dfs2(G[x][i]);
}
vis[x] = 2;
}
int main() {
cin >> n >> m;
memset(ans, -1, sizeof(ans));
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
E[a].push_back(b);
E[b].push_back(a);
G[a].push_back(b);
}
for (int i = 1; i <= n; i++)
if (!col[i]) dfs1(i, co++);
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs2(i);
for (int i = 1; i < co; i++) res += cnt[i] + ans[i];
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > c;
vector<int> sort_cyclic_shifts(const string &s) {
int n = s.size();
const int alphabet = 256;
vector<int> p(n), cnt(alphabet, 0);
c.clear();
c.emplace_back();
c[0].resize(n);
for (int i = 0; i < n; i++) cnt[s[i]]++;
for (int i = 1; i < alphabet; i++) cnt[i] += cnt[i - 1];
for (int i = 0; i < n; i++) p[--cnt[s[i]]] = i;
c[0][p[0]] = 0;
int classes = 1;
for (int i = 1; i < n; i++) {
if (s[p[i]] != s[p[i - 1]]) classes++;
c[0][p[i]] = classes - 1;
}
vector<int> pn(n), cn(n);
cnt.resize(n);
for (int h = 0; (1 << h) < n; h++) {
for (int i = 0; i < n; i++) {
pn[i] = p[i] - (1 << h);
if (pn[i] < 0) pn[i] += n;
}
fill(cnt.begin(), cnt.end(), 0);
for (int i = 0; i < n; i++) cnt[c[h][pn[i]]]++;
for (int i = 1; i < classes; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) p[--cnt[c[h][pn[i]]]] = pn[i];
cn[p[0]] = 0;
classes = 1;
for (int i = 1; i < n; i++) {
pair<int, int> cur = {c[h][p[i]], c[h][(p[i] + (1 << h)) % n]};
pair<int, int> prev = {c[h][p[i - 1]], c[h][(p[i - 1] + (1 << h)) % n]};
if (cur != prev) ++classes;
cn[p[i]] = classes - 1;
}
c.push_back(cn);
}
return p;
}
vector<int> suffix_array_construction(string s) {
s += "!";
vector<int> sorted_shifts = sort_cyclic_shifts(s);
sorted_shifts.erase(sorted_shifts.begin());
return sorted_shifts;
}
int compare(int i, int j, int n, int k) {
pair<int, int> a = {c[k][i], c[k][(i + 1 - (1 << k)) % n]};
pair<int, int> b = {c[k][j], c[k][(j + 1 - (1 << k)) % n]};
return a == b ? 0 : a < b ? -1 : 1;
}
int lcp(int i, int j) {
int log_n = c.size() - 1;
int ans = 0;
for (int k = log_n; k >= 0; k--) {
if (c[k][i] == c[k][j]) {
ans += 1 << k;
i += 1 << k;
j += 1 << k;
}
}
return ans;
}
vector<int> lcp_construction(const string &s, const vector<int> &sa) {
int n = s.size();
vector<int> rank(n, 0);
vector<int> lcp(n - 1, 0);
for (int i = 0; i < n; i++) rank[sa[i]] = i;
for (int i = 0, k = 0; i < n; i++) {
if (rank[i] == n - 1) {
k = 0;
continue;
}
int j = sa[rank[i] + 1];
while (i + k < n && j + k < n && s[i + k] == s[j + k]) k++;
lcp[rank[i]] = k;
if (k) k--;
}
return lcp;
}
const int N = 1e5 + 7, K = 18;
int st[N][K];
int lg[N];
void pre() {
lg[1] = 0;
for (int i = 2; i < N; i++) lg[i] = lg[i / 2] + 1;
}
void build(const vector<int> &lcp) {
int n = lcp.size();
for (int i = 0; i < n; i++) st[i][0] = lcp[i];
for (int k = 1; k < K; k++)
for (int i = 0; i < n; i++) {
st[i][k] = st[i][k - 1];
int nxt = i + (1 << (k - 1));
if (nxt >= n) continue;
st[i][k] = min(st[i][k], st[nxt][k - 1]);
}
}
int get(int l, int r) {
int k = lg[r - l + 1];
return min(st[l][k], st[r - (1 << k) + 1][k]);
}
pair<int, int> f(int l, int r, int tar) {
int lo = l, hi = r;
while (lo < hi) {
int mid = (lo + hi + 1) / 2;
int k = get(l, mid - 1);
if (k > tar)
lo = mid;
else
hi = mid - 1;
}
if (lo == l) return pair<int, int>(l, -1);
return pair<int, int>(lo, get(l, lo - 1));
}
int main() {
pre();
string s;
cin >> s;
int n = s.size();
vector<int> sa = suffix_array_construction(s);
vector<int> lcp = lcp_construction(s, sa);
build(lcp);
long long ans = 0;
for (int i = 0; i < n; i++) {
int cur = (i ? lcp[i - 1] : 0);
int len = n - sa[i];
int hi = n - 1;
while (cur < len) {
pair<int, int> pr = f(i, hi, cur);
hi = pr.first;
if (hi == i) pr.second = len;
int nw = pr.second - cur;
int cnt = hi - i + 1;
ans += 1LL * nw * cnt * (cnt + 1) / 2;
cur = pr.second;
hi = pr.first;
}
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int c[1048576], n, m;
long long t, P, a[1048576], b[1048576];
long long mult(long long a, long long b) {
return (a * b - (long long)((long double)a * b / P) * P) % P;
}
long long power(long long x, long long v) {
long long ans = 1;
for (; v; v >>= 1, x = mult(x, x))
if (v & 1) ans = mult(ans, x);
return ans;
}
void xorDFT(long long *a, int n) {
for (int i = 1; i < n; i <<= 1)
for (int j = 0; j < n; j += i << 1)
for (int k = 0; k < i; k++) {
long long x = a[j + k], y = a[j + k + i];
a[j + k] = (x + y) % P;
a[j + k + i] = (x - y + P) % P;
}
}
int main() {
scanf("%d%I64d%I64d", &n, &t, &P), m = 1 << n, P <<= n;
for (int i = 0; i <= m - 1; ++i) scanf("%I64d", a + i);
for (int i = 0; i <= n; ++i) scanf("%d", c + i);
for (int i = 0; i <= m - 1; ++i) {
int cnt = 0, j = i;
while (j) cnt += j & 1, j >>= 1;
b[i] = c[cnt];
}
xorDFT(a, m);
xorDFT(b, m);
for (int i = 0; i <= m - 1; ++i) a[i] = mult(a[i], power(b[i], t));
xorDFT(a, m);
for (int i = 0; i <= m - 1; ++i) printf("%I64d\n", a[i] >> n);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, x, c = 0;
cin >> n >> x;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[n - i - 1];
}
for (int i = 0; i < n; i++) {
if (a[i] + b[i] > x) c++;
}
if (c != 0)
cout << "No\n";
else
cout << "Yes\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
int t, n, m, j, ans, k, a, b, c, d, e, f, sum, i, r;
char grid[1010][1010];
string s, s2, s3, s4;
vector<char> v;
int dx[] = {+1, 0, +0, -1};
int dy[] = {+0, -1, +1, +0};
int ar[(int)(1e6 + 10)], ar2[(int)(1e6 + 10)];
int level[1010][1010];
bool visited[1010][1010];
void brainfuck();
bool checker(int x, int y) {
return !(x < 0 || y < 0 || x == n || y == m || grid[x][y] == '*');
}
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
brainfuck();
return 0;
}
void brainfuck() {
cin >> n >> m >> k;
r = -1;
for (i = 0; i < n; i++) cin >> grid[i];
if (k & 1) {
cout << "IMPOSSIBLE";
return;
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (grid[i][j] == 'X') {
r = i;
e = j;
break;
}
}
if (r != -1) break;
}
queue<pair<int, int> > qu;
qu.push({r, e});
int sz = k / 2;
char ch;
visited[r][e] = 1;
while (!qu.empty()) {
a = qu.front().first;
b = qu.front().second;
qu.pop();
for (i = 0; i < 4; i++) {
c = dx[i] + a;
d = dy[i] + b;
if (checker(c, d) && !visited[c][d]) {
qu.push({c, d});
level[c][d] = level[a][b] + 1;
visited[c][d] = 1;
}
}
}
a = r;
b = e;
r = k;
while (k--) {
for (i = 0; i < 4; i++) {
c = dx[i] + a;
d = dy[i] + b;
if (checker(c, d) && level[c][d] <= k) {
if (!i)
ch = 'D';
else if (i == 1)
ch = 'L';
else if (i == 2)
ch = 'R';
else
ch = 'U';
v.push_back(ch);
a = c;
b = d;
break;
}
}
}
if (v.size() != r)
cout << "IMPOSSIBLE";
else {
for (i = 0; i < r; i++) cout << v[i];
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int A[200005];
vector<int> L[105];
int dp[400005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
L[A[i]].push_back(i);
}
int opt = 0;
int D = 0;
int N = min(n, 100);
for (int i = 1; i <= N; i++) {
if (L[i].size() > L[D].size()) D = i;
}
memset(dp, -1, sizeof(dp));
for (int V = 1; V <= N; V++) {
if (V == D) continue;
if (L[V].empty()) continue;
int bal = 0;
vector<int> T;
T.push_back(bal);
dp[bal + n] = 0;
for (int i = 1; i <= n; i++) {
if (A[i] == D)
bal++;
else if (A[i] == V)
bal--;
if (dp[bal + n] != -1) {
if (i - dp[bal + n] > opt) opt = i - dp[bal + n];
}
if (dp[bal + n] == -1) {
dp[bal + n] = i;
T.push_back(bal);
}
}
for (int v : T) {
dp[v + n] = -1;
}
}
printf("%d\n", opt);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, N = 1e5 + 10;
const int MOD = 1e9 + 7;
const double eps = 1e-6;
const double PI = acos(-1);
inline int lowbit(int x) { return x & (-x); }
inline void solve() {
int n, m;
cin >> n >> m;
string s;
cin >> s;
s = '#' + s;
vector<int> pre(n + 1, 0);
map<int, vector<int>> f;
for (int i = 1; i <= n; i++) {
int now = ((s[i] == '+') ^ (i & 1) ? -1 : 1);
pre[i] = pre[i - 1] + now;
f[pre[i] + pre[i - 1]].push_back(i);
}
while (m--) {
int ll, rr;
cin >> ll >> rr;
int val = pre[rr] - pre[ll - 1];
if (val == 0)
cout << 0 << '\n';
else {
if (val & 1) {
cout << 1 << '\n';
int now = pre[rr] + pre[ll - 1];
int l = 0, r = (int)f[now].size() - 1;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (f[now][mid] >= ll && f[now][mid] <= rr) {
l = mid;
break;
} else {
if (f[now][mid] < ll)
l = mid;
else
r = mid - 1;
}
}
cout << f[now][l] << '\n';
} else {
cout << 2 << '\n';
if (rr - ll == 1)
cout << ll << ' ' << rr << '\n';
else {
for (int i = ll; i < rr; i++) {
int now = val + pre[i] + pre[i - 1];
if (f[now].empty()) continue;
int l = 0, r = (int)f[now].size() - 1;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (f[now][mid] > i && f[now][mid] <= rr) {
l = mid;
break;
} else {
if (f[now][mid] < ll)
l = mid;
else
r = mid - 1;
}
}
if (f[now][l] > i && f[now][l] <= rr) {
cout << i << ' ' << f[now][l] << '\n';
break;
}
}
}
}
}
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
cout << fixed << setprecision(2);
int T;
cin >> T;
while (T--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 300001;
long long int B[300001], A[MaxN], C[MaxN];
int main() {
cin.tie(0), ios_base::sync_with_stdio(0);
long long int N, i, j, p, q, M, a, b, S = 0;
cin >> N >> M;
for (i = 0; i < N; i++) cin >> C[i];
sort(&(C[0]), &(C[N - 1]) + 1);
for (i = 0; i < M; i++) {
cin >> p >> q;
B[p - 1]++;
B[q]--;
}
p = 0;
for (i = 0; i < N; i++) {
p += B[i];
A[i] = p;
}
sort(&(A[0]), &(A[N - 1]) + 1);
for (i = 0; i < N; i++) S += A[i] * C[i];
cout << S;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long mult(long long a, long long b, long long p = 1000000007) {
return ((a % p) * (b % p)) % p;
}
long long add(long long a, long long b, long long p = 1000000007) {
return (a % p + b % p) % p;
}
long long fpow(long long n, long long k, long long p = 1000000007) {
long long r = 1;
for (; k; k >>= 1LL) {
if (k & 1LL) r = mult(r, n, p);
n = mult(n, n, p);
}
return r;
}
long long inv(long long a, long long p = 1000000007) {
return fpow(a, p - 2, p);
}
vector<int> v[100001];
vector<pair<int, int> > edges;
int col[100001];
bool cyc;
bool al[100001];
bool curr[100001];
bool cycle(int s) {
curr[s] = true;
for (int i : v[s]) {
if (curr[i]) {
return true;
} else if (!al[i] && cycle(i)) {
return true;
}
}
curr[s] = false;
al[s] = true;
return false;
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
edges.push_back(make_pair(a, b));
}
for (int i = 1; i < n + 1; i++) {
if (!al[i] && cycle(i)) {
cyc = true;
break;
}
}
if (cyc) {
cout << 2 << '\n';
for (int i = 0; i < m; i++) {
if (edges[i].first > edges[i].second)
cout << 1 << " ";
else
cout << 2 << " ";
}
cout << '\n';
} else {
cout << 1 << '\n';
for (int i = 0; i < m; i++) cout << 1 << " ";
cout << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6;
int n, ans;
int dp[maxn];
int a[maxn];
int main() {
ios_base::sync_with_stdio(false);
int ins;
cin >> ins;
n = (1 << (ins + 1)) - 1;
for (int i = 2; i <= n; i++) cin >> a[i];
for (int i = n / 2 + 1; i <= n; i++) {
int p = i;
while (p != 1) {
dp[i] += a[p];
p = p / 2;
}
}
int maxx = 0;
for (int i = n / 2 + 1; i <= n; i++) maxx = max(maxx, dp[i]);
for (int i = n / 2 + 1; i <= n; i++) dp[i] = maxx - dp[i];
for (int i = n; i >= 1; i--) {
int minn = min(dp[2 * i], dp[2 * i + 1]);
dp[2 * i] -= minn;
dp[2 * i + 1] -= minn;
dp[i] += minn;
}
for (int i = 1; i <= n; i++) ans += dp[i];
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int bound = 40;
const double eps = 1e-9, eps2 = 1e-9, inf = 1e9 + 9, pi = acos(-1.0);
double ans, r, h, xa, ya, za, xb, yb, zb, la, ra, mxa, mya, lb, rb, mxb, myb,
lv, rv, lz, rz;
double dtheta;
double dist(double x1, double y1, double z1, double x2, double y2, double z2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) +
(z1 - z2) * (z1 - z2));
}
void norm(double &theta) {
while (theta < -eps) theta += 2 * pi;
while (theta > 2 * pi - eps) theta -= 2 * pi;
}
double solve(double x1, double y1, double z1, double x2, double y2, double z2) {
double l1, l2, l, cj, alpha, dj, theta, res;
if (fabs(z1) < eps && fabs(z2) < eps) return dist(x1, y1, z1, x2, y2, z2);
l1 = dist(x1, y1, z1, 0, 0, h);
l2 = dist(x2, y2, z2, 0, 0, h);
alpha = atan2(y2, x2) - atan2(y1, x1);
norm(alpha);
if (alpha > pi) alpha = 2 * pi - alpha;
l = alpha * r;
cj = sqrt(r * r + h * h);
theta = l / cj;
double u1, v1, u2, v2;
u1 = 0;
v1 = l1;
u2 = l2 * sin(theta);
v2 = l2 * cos(theta);
res = sqrt((u1 - u2) * (u1 - u2) + (v1 - v2) * (v1 - v2));
theta = 2 * pi - theta;
u1 = 0;
v1 = l1;
u2 = l2 * sin(theta);
v2 = l2 * cos(theta);
res = min(res, sqrt((u1 - u2) * (u1 - u2) + (v1 - v2) * (v1 - v2)));
return res;
}
double compute(double alpha, double beta) {
return solve(xa, ya, za, r * cos(alpha), r * sin(alpha), 0) +
solve(xb, yb, zb, r * cos(beta), r * sin(beta), 0) +
dist(r * cos(alpha), r * sin(alpha), 0, r * cos(beta), r * sin(beta),
0);
}
double compute(double alpha) {
double theta, vl, ch, ret = inf;
for (theta = 0; theta < 2 * pi; theta += dtheta) {
vl = compute(alpha, theta);
if (ret > vl) {
ret = vl;
ch = theta;
}
}
lb = max(0., ch - dtheta);
rb = min(2 * pi, ch + dtheta);
while (lb < rb) {
mxb = 0.5 * (lb + rb);
myb = mxb + eps2;
if (compute(alpha, mxb) > compute(alpha, myb))
lb = mxb + eps;
else
rb = mxb - eps;
}
vl = compute(alpha, 0.5 * (lb + rb));
if (ret > vl) ret = vl;
return ret;
}
int main() {
int i, j, s, p, q, it1, it2;
scanf("%lf%lf", &r, &h);
scanf("%lf%lf%lf%lf%lf%lf", &xa, &ya, &za, &xb, &yb, &zb);
ans = inf;
if (fabs(za) > eps && fabs(zb) > eps)
ans = min(ans, solve(xa, ya, za, xb, yb, zb));
if (fabs(za) < eps && fabs(zb) < eps)
ans = min(ans, dist(xa, ya, za, xb, yb, zb));
if (fabs(zb) < eps) {
swap(xa, xb);
swap(ya, yb);
swap(za, zb);
}
double theta, vl, ch, mi = inf;
dtheta = 2 * pi / bound;
mi = inf;
for (theta = 0; theta < 2 * pi; theta += dtheta) {
vl = solve(xa, ya, za, r * cos(theta), r * sin(theta), 0) +
solve(xb, yb, zb, r * cos(theta), r * sin(theta), 0);
if (mi > vl) {
mi = vl;
ch = theta;
}
if (ans > vl) ans = vl;
}
la = max(0., ch - dtheta);
ra = min(2 * pi, ch + dtheta);
while (la < ra) {
mxa = 0.5 * (la + ra);
mya = mxa + eps2;
lv = solve(xa, ya, za, r * cos(mxa), r * sin(mxa), 0) +
solve(xb, yb, zb, r * cos(mxa), r * sin(mxa), 0);
rv = solve(xa, ya, za, r * cos(mya), r * sin(mya), 0) +
solve(xb, yb, zb, r * cos(mya), r * sin(mya), 0);
if (lv > rv)
la = mxa + eps;
else
ra = mxa - eps;
}
vl =
solve(xa, ya, za, r * cos(0.5 * (la + ra)), r * sin(0.5 * (la + ra)), 0) +
solve(xb, yb, zb, r * cos(0.5 * (la + ra)), r * sin(0.5 * (la + ra)), 0);
if (ans > vl) ans = vl;
mi = inf;
for (theta = 0; theta < 2 * pi; theta += dtheta) {
vl = compute(theta);
if (mi > vl) {
mi = vl;
ch = theta;
}
if (ans > vl) ans = vl;
}
la = max(0., ch - dtheta);
ra = min(2 * pi, ch + dtheta);
while (la < ra) {
mxa = 0.5 * (la + ra);
mya = mxa + eps2;
if (compute(mxa) > compute(mya))
la = mxa + eps;
else
ra = mxa - eps;
}
vl = compute(0.5 * (la + ra));
if (ans > vl) ans = vl;
printf("%.20f\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void setmax(T& x, T y) {
x = max(x, y);
}
template <typename T>
void setmin(T& x, T y) {
x = min(x, y);
}
const double PI = acos(-1.0);
const long long INF = 1e9 + 47;
const long long LINF = INF * INF;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = (0); i < (n); ++i) cin >> a[i], a[i]--;
vector<int> pos(n);
for (int i = (0); i < (n); ++i) pos[a[i]] = i;
bool ok = true;
int lst = 0;
while ((int)((a).size())) {
int p = pos[lst];
for (int i = (p); i < ((int)((a).size()) - 1); ++i)
ok &= a[i] + 1 == a[i + 1];
if (!ok) break;
lst += (int)((a).size()) - p;
a.resize(p);
}
cout << (ok ? "Yes\n" : "No\n");
}
cerr << "Time elapsed: " << clock() / (double)CLOCKS_PER_SEC << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char str[2005];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
cin >> str;
int ans = 0;
int l = strlen(str);
for (int i = 0; i < l; i++) {
if (i % n != 0 && i != 0) continue;
if (i < 4) continue;
if (str[i - 1] == str[i - 2] && str[i - 2] == str[i - 3] &&
str[i - 1] == str[i - 3])
ans++;
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long j, k, a[11111], b[11111], s, ss, l, m, n, t, d;
long long e, i, c[221];
string p, q[111], r, v;
char w;
map<long long, long long> y, z;
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] < 0) a[i] = -a[i];
b[i] = a[i];
}
sort(b, b + n);
m = 0;
while (b[m] == 0) m++;
for (i = n - 1; i >= m; i--) {
t = 0;
k = 0;
j = n - 1;
while (b[i] != a[j]) {
if (b[i] > a[j]) t++;
j--;
}
a[j]++;
for (l = 0; l < j; l++)
if (a[l] < b[i]) k++;
s += min(k, t);
}
cout << s;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long solve(long long now) {
if (now == 1) return 1;
if (now % 2 == 0) {
return 2LL * solve(now / 2LL) + now / 2LL;
} else {
return 2LL * solve(now / 2LL) + now / 2LL + 1LL;
}
}
int main() {
long long n;
cin >> n;
n--;
cout << solve(n) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = 1e6 + 5;
const int MOD = 1e9 + 7;
const int CM = 998244353;
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;
template <typename T>
T MAX(T a, T b) {
return a > b ? a : b;
}
template <typename T>
T MIN(T a, T b) {
return a > b ? b : a;
}
template <typename T>
T GCD(T a, T b) {
return b == 0 ? a : GCD(b, a % b);
}
template <typename T>
T LCM(T a, T b) {
return a / GCD(a, b) * b;
}
template <typename T>
T ABS(T a) {
return a > 0 ? a : -a;
}
template <typename T>
T ADD(T a, T b, T MOD) {
return (a + b) % MOD;
}
template <typename T>
T DEL(T a, T b, T MOD) {
return ((a - b) % MOD + MOD) % MOD;
}
template <typename T>
T getmod(T a, T mod) {
return (a % mod + mod) % mod;
}
template <typename T>
void debug(T a, char x) {
return;
}
int rand(int a, int b) { return rand() % (b - a + 1) + a; }
string a, b;
bool divi(string a, string b) {
if (a == b) return 1;
int n = a.length();
if (n & 1) return 0;
string a1 = a.substr(0, n / 2), a2 = a.substr(n / 2, n / 2);
string b1 = b.substr(0, n / 2), b2 = b.substr(n / 2, n / 2);
if (divi(a1, b2) && divi(a2, b1)) return 1;
if (divi(a1, b1) && divi(a2, b2)) return 1;
return 0;
}
void solve(int kase) {
cin >> a >> b;
if (divi(a, b))
printf("YES\n");
else
printf("NO\n");
}
const bool DUO = 0;
void TIME() {
clock_t start, finish;
double totaltime;
start = clock();
if (DUO) {
int Kase = 0;
cin >> Kase;
for (int kase = 1; kase <= Kase; kase++) solve(kase);
} else
solve(1);
finish = clock();
totaltime = (double)(finish - start) / CLOCKS_PER_SEC;
printf("\nTime:%lfms\n", totaltime * 1000);
}
int main() {
if (DUO) {
int Kase = 0;
cin >> Kase;
for (int kase = 1; kase <= Kase; kase++) solve(kase);
} else
solve(1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int X, Y, Number;
};
Point O;
bool Cross(Point A, Point B, Point C) {
long long P =
(long long)A.X * B.Y + (long long)B.X * C.Y + (long long)C.X * A.Y;
long long Q =
(long long)A.Y * B.X + (long long)B.Y * C.X + (long long)C.Y * A.X;
return P > Q;
}
bool operator<(Point A, Point B) { return Cross(A, O, B); }
vector<int> G[1500];
Point P[1500];
int Size[1500], Ans[1500];
bool Flag[1500];
void Calc_Size(int V) {
Size[V] = 1;
for (int i = 0; i < G[V].size(); i++)
if (!Size[G[V][i]]) {
Calc_Size(G[V][i]);
Size[V] += Size[G[V][i]];
}
}
void Solve(int V, int L, int R) {
Flag[V] = true;
for (int i = L + 1; i <= R; i++)
if (P[i].X < P[L].X) swap(P[i], P[L]);
Ans[P[L].Number] = V + 1;
O = P[L];
sort(P + L + 1, P + R + 1);
for (int i = 0; i < G[V].size(); i++) {
int U = G[V][i];
if (Flag[U]) continue;
Solve(U, L + 1, L + Size[U]);
L += Size[U];
}
}
int main() {
int N;
scanf("%d", &N);
for (int i = 1; i < N; i++) {
int X, Y;
scanf("%d%d", &X, &Y);
X--;
Y--;
G[X].push_back(Y);
G[Y].push_back(X);
}
for (int i = 0; i < N; i++) {
scanf("%d%d", &P[i].X, &P[i].Y);
P[i].Number = i;
}
memset(Size, 0, sizeof(Size));
Calc_Size(0);
memset(Flag, 0, sizeof(Flag));
Solve(0, 0, N - 1);
for (int i = 0; i < N; i++) {
printf("%d", Ans[i]);
putchar((i == N - 1) ? '\n' : ' ');
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int m, x, y, a[100005], p[100005];
long long n, ans, s[100005];
vector<pair<int, pair<int, int>>> edgeList;
int findSet(int i) { return (p[i] == i ? i : p[i] = findSet(p[i])); }
void unionSet(int i, int j, long long w) {
x = findSet(i);
y = findSet(j);
if (x != y) {
ans += (s[x] * s[y] * w);
s[x] += s[y];
p[y] = x;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
p[i] = i;
s[i] = 1;
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> x >> y;
edgeList.push_back({min(a[x], a[y]), {x, y}});
}
sort(edgeList.begin(), edgeList.end(), greater<pair<int, pair<int, int>>>());
for (int i = 0; i < edgeList.size(); i++) {
unionSet(edgeList[i].second.first, edgeList[i].second.second,
edgeList[i].first);
}
cout << setprecision(6) << fixed << (2 * ans) / (long double)(n * (n - 1))
<< '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace ::std;
vector<int> G[105];
int dx[4] = {0, -1, 1, 0};
int dy[4] = {-1, 0, 0, 1};
int main(void) {
int n, m, c = 0;
bool f;
string s[105];
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] == 'W') {
f = true;
for (int k = 0; k < 4 && f; k++)
if (i + dx[k] >= 0 && i + dx[k] < n && j + dy[k] >= 0 &&
j + dy[k] < m && s[i + dx[k]][j + dy[k]] == 'P') {
f = false;
c++;
}
}
cout << c << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long zero = 0, one = 0;
for (char c : s) {
if (c == '0')
zero++;
else
one++;
}
if (one == 0 || zero == 0) {
cout << s << '\n';
} else {
bool cur = (s[0] == '0') ? 0 : 1;
long long ptr = 0;
while (one > 0 || zero > 0) {
cout << (int)cur;
if (cur && s[ptr] == '1') {
one--;
ptr++;
} else if (!cur && s[ptr] == '0') {
zero--;
ptr++;
}
cur = !cur;
}
cout << '\n';
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
int a[MAXN];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
int p = n - 1;
for (int i = n / 2 - 1; i >= 0; i--)
if (a[p] >= 2 * a[i]) p--;
printf("%d\n", p + 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << n / 7 * 2 + n % 7 / 6 << ' ' << n / 7 * 2 + (n % 7 > 1 ? 2 : n % 7);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int idx = 1;
map<int, int> id;
vector<int> A, pos(100011, 1000000000);
long long tree[4 * 100011];
void build_tree(int node, int a, int b) {
if (a == b) {
tree[node] = pos[a];
return;
}
build_tree(2 * node, a, (a + b) / 2);
build_tree(2 * node + 1, (a + b) / 2 + 1, b);
tree[node] = min(tree[2 * node], tree[2 * node + 1]);
}
int query(int node, int a, int b, int i, int j) {
if (a > j or b < i) return 1000000000;
if (a >= i and b <= j) return tree[node];
return min(query(2 * node, a, (a + b) / 2, i, j),
query(2 * node + 1, (a + b) / 2 + 1, b, i, j));
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
A.resize(n);
set<pair<int, int> > st;
for (int i = 0; i < n; ++i) {
cin >> A[i];
st.insert(make_pair(A[i], n - i - 1));
}
for (set<pair<int, int> >::iterator itr = st.begin(); itr != st.end();
++itr) {
int ele = (*itr).first, ind = (*itr).second;
if (id.find(ele) == id.end()) {
id[ele] = idx++;
}
pos[id[ele]] = min(pos[id[ele]], ind);
}
idx--;
build_tree(1, 1, idx);
for (int i = 0; i < n; ++i) {
int q = query(1, 1, idx, 1, id[A[i]] - 1);
if (q >= n - i - 1) {
cout << -1 << " ";
} else {
cout << (n - i - 1 - q - 1) << " ";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int vis[100006];
vector<int> graph[100004];
int cnt;
int a[100006];
void dfsvisit(int x) {
vis[x] = 1;
cnt = min(cnt, a[x]);
for (int i = 0; i < graph[x].size(); i++) {
int temp = graph[x][i];
if (!vis[temp]) dfsvisit(temp);
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
int p, q;
for (int i = 0; i < m; i++) {
cin >> p >> q;
graph[p].push_back(q);
graph[q].push_back(p);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
cnt = a[i];
dfsvisit(i);
ans += cnt;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int NMax = 110000;
int N;
bool cmp1(pair<double, double> a, pair<double, double> b) {
return a.first < b.first;
}
bool cmp2(pair<double, double> a, pair<double, double> b) {
return a.second < b.second;
}
pair<double, double> A[NMax];
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%lf%lf", &A[i].first, &A[i].second);
A[i].first += i / 1000000.0;
A[i].second += i / 1000000.0;
}
int mid = N / 2 + 1, a = 0, b = 0;
double midx, midy;
if (N % 2) {
sort(A + 1, A + N + 1, cmp1);
midx = A[mid].first;
sort(A + 1, A + N + 1, cmp2);
midy = A[mid].second;
} else {
sort(A + 1, A + N + 1, cmp1);
midx = (A[mid].first + A[mid - 1].first) / 2;
sort(A + 1, A + N + 1, cmp2);
midy = (A[mid].second + A[mid - 1].second) / 2;
}
long long ret = 0;
int flag = 0;
for (int i = 1; i <= N; i++) {
if ((A[i].first < midx && A[i].second < midy) ||
(A[i].first > midx && A[i].second > midy))
a++;
else if ((A[i].first < midx && A[i].second > midy) ||
(A[i].first > midx && A[i].second < midy))
b++;
if (A[i].first < midx)
ret -= floor(A[i].first);
else if (A[i].first > midx)
ret += floor(A[i].first);
if (A[i].second < midy)
ret -= floor(A[i].second);
else if (A[i].second > midy)
ret += floor(A[i].second);
if (A[i].first == midx && A[i].second == midy) flag = 1;
}
ret *= 2;
if (N % 2) {
if (a == 0 || b == 0 || !flag)
printf("%lld\n", ret);
else {
sort(A + 1, A + N + 1, cmp1);
long long a =
max(ret + 2 * floor(A[mid].first) - 2 * floor(A[mid + 1].first),
ret - 2 * floor(A[mid].first) + 2 * floor(A[mid - 1].first));
sort(A + 1, A + N + 1, cmp2);
a = max(a, (long long)max(ret + 2 * floor(A[mid].second) -
2 * floor(A[mid + 1].second),
ret - 2 * floor(A[mid].second) +
2 * floor(A[mid - 1].second)));
printf("%lld\n", a);
}
} else {
if (a == 0 || b == 0)
printf("%lld\n", ret);
else {
sort(A + 1, A + N + 1, cmp1);
long long a = ret - 2 * floor(A[mid].first) + 2 * floor(A[mid - 1].first);
sort(A + 1, A + N + 1, cmp2);
a = max((double)a,
ret - 2 * floor(A[mid].second) + 2 * floor(A[mid - 1].second));
printf("%lld\n", a);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, m, n, t, k;
cin >> n >> k >> m >> t;
while (t--) {
cin >> a >> b;
if (a == 0) {
if (b < k)
k -= b, n -= b;
else
n = b;
} else {
if (b <= k)
k++, n++;
else
n++;
}
n = min(n, m);
cout << n << " " << k << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char x[16][10010], x1[16][10010];
pair<int, int> a[10000];
int main() {
int n, m, k, ans = 10000000;
cin >> n >> m;
int c = 0, r = 0, r1 = 0;
bool f = false, f1 = false;
for (int i = 0; i < n; i++) {
f = false;
for (int j = 0; j < m + 2; j++) {
cin >> x1[i][j];
if (x1[i][j] == '1') {
f = true;
f1 = true;
}
}
if (f == true) {
for (int j = 0; j < m + 2; j++) {
x[c][j] = x1[i][j];
}
c++;
} else {
r1++;
r++;
if (f1 == false) r--;
}
}
if (r1 == n) {
cout << 0;
return 0;
}
n -= r1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m + 2; j++) {
if (x[i][j] == '1') a[i].second = j;
}
}
for (int i = 0; i < n; i++) {
for (int j = m + 1; j >= 0; j--) {
if (x[i][j] == '1') a[i].first = j;
}
}
k = (1 << (n - 1));
for (int i1 = 0; i1 < k; i1++) {
int res = 0;
res += a[n - 1].second;
int p = i1, prev = 0, pR = a[n - 1].second, pL = a[n - 1].first, now,
i = n - 2;
for (int j = 0; j < n - 1; j++) {
if (p % 2 == 0)
now = 0;
else
now = 1;
if (now == 0 && prev == 0) {
res += pR + 1 + a[i].second;
} else if (now == 0 && prev == 1) {
res += pL + 1 + a[i].second;
} else if (now == 1 && prev == 0) {
res += (m + 1 - pR) + 1 + (m + 1 - a[i].first);
} else if (now == 1 && prev == 1) {
res += (m + 1 - pL) + 1 + (m + 1 - a[i].first);
}
pR = a[i].second;
pL = a[i].first;
i--;
prev = now;
p /= 2;
}
ans = min(ans, res);
}
cout << ans + r;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
int t;
cin >> t;
for (int z = 1; z <= t; z++) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int res = n;
for (int i = 1; i < n; i++) {
if (a[i] != a[i + 1]) {
res = 1;
break;
}
}
cout << res << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
using namespace std;
int n, m, tree[500010 << 2], a[500010], b[500010], lef[500010], last[500010],
ans[500010], size;
struct Q {
int l, r, id;
} q[500010];
inline void read(int &x) {
char s = getchar();
int f = 1;
x = 0;
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') x = (x << 3) + (x << 1) + s - '0', s = getchar();
x *= f;
}
inline bool cmp1(const Q &x, const Q &y) { return x.r < y.r; }
inline void modify(int x, int val, int l, int r, int o) {
int mid = (l + r) >> 1;
if (l == r) {
tree[o] = val;
return;
}
if (x <= mid)
modify(x, val, l, mid, o << 1);
else
modify(x, val, mid + 1, r, o << 1 | 1);
tree[o] = min(tree[o << 1], tree[o << 1 | 1]);
}
inline int query(int x, int y, int l, int r, int o) {
int mid = (l + r) >> 1, ans = 0x7fffffff;
if (x <= l && r <= y) return tree[o];
if (x <= mid) ans = min(ans, query(x, y, l, mid, o << 1));
if (y > mid) ans = min(ans, query(x, y, mid + 1, r, o << 1 | 1));
return ans;
}
int main() {
read(n);
read(m);
for (int i = 1; i <= n; i++) read(a[i]), b[i] = a[i];
sort(b + 1, b + n + 1);
size = unique(b + 1, b + n + 1) - b - 1;
for (int i = 1; i <= n; i++) {
a[i] = lower_bound(b + 1, b + size + 1, a[i]) - b;
lef[i] = last[a[i]];
last[a[i]] = i;
}
for (int i = 1; i <= m; i++) read(q[i].l), read(q[i].r), q[i].id = i;
sort(q + 1, q + m + 1, cmp1);
memset(tree, 0x7f, sizeof(tree));
int i = 1, j = 1;
while (i <= n && j <= m) {
if (lef[i]) modify(lef[i], i - lef[i], 1, n, 1);
while (i == q[j].r && j <= m)
ans[q[j].id] = query(q[j].l, q[j].r, 1, n, 1), j++;
i++;
}
for (int i = 1; i <= m; i++)
ans[i] == 2139062143 ? printf("-1\n") : printf("%d\n", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int mod = 1e9 + 7;
long long a, b, c, d, n, m, x, y, z, k;
vector<int> v, g;
int arr[3];
long long calc(long long num) {
if (num == 1) return 0;
long long res = 9e18;
if (num % k == 0 && k != 1 && (num - num / k) * a >= b)
res = min(res, calc(num / k) + b);
else if (num <= k)
res = min(res, calc(1) + a * (num - 1));
else if (num % k != 0)
res = min(res, calc(num / k * k) + a * (num - (num / k * k)));
else
res = min(res, calc(num / k * (k - 1)) + a * (num - (num / k * (k - 1))));
return res;
}
int main() {
cin >> n >> k >> a >> b;
cout << calc(n) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
string s, t;
cin >> s >> t;
int max_strings = 1;
long long rs = 0;
for (int i = 0; i < n; ++i) {
max_strings <<= 1;
max_strings -= s[i] - 'a';
max_strings -= 'b' - t[i];
if (max_strings >= k) {
for (int j = i; j < n; ++j) rs += k;
break;
}
rs += max_strings;
}
cout << rs << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100005;
int n, m;
vector<int> has, res;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
has.push_back(a);
}
sort(has.begin(), has.end());
has.erase(unique(has.begin(), has.end()), has.end());
int pnt = 0;
for (int i = 1; i <= m; i++)
if (pnt < has.size() && has[pnt] == i)
pnt++;
else {
res.push_back(i);
m -= i;
}
printf("%d\n", res.size());
for (int i = 0; i < res.size(); i++)
printf("%d%c", res[i], i + 1 < res.size() ? ' ' : '\n');
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100 + 5;
const int MAX_M = 100000 + 5;
const int INF = 0x7fffffff;
const int inf = 1000000000;
const double EPS = 1e-6;
const unsigned long long base = 123;
const long long mod = 1e4 + 7;
const double pi = 4 * atan(1.0);
vector<int> v;
int vis[1000000];
int main() {
int t;
cin >> t;
for (int i = 2; i * i <= 1000000000; i++) {
if (!vis[i]) {
v.push_back(i);
for (int j = i * 2; j <= 100000; j += i) {
vis[j] = 1;
}
}
}
while (t--) {
long long p, q;
map<long long, int> m1, m2;
scanf("%lld%lld", &p, &q);
if (p % q != 0) {
cout << p << endl;
continue;
} else {
for (int i = 0; i < v.size();) {
if (q % v[i] == 0) {
q /= v[i];
m2[v[i]]++;
} else {
i++;
}
}
if (q != 1) {
m2[q]++;
}
long long mx = 0;
for (auto i : m2) {
long long u = 1;
long long x = p;
for (int j = 1; j <= i.second; j++) {
u *= i.first;
}
while (x % u == 0) {
x /= i.first;
}
mx = max(mx, x);
}
cout << mx << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, b;
cin >> t;
while (t--) {
cin >> a >> b;
int res = (a ^ b);
cout << res << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
s[0] = toupper(s[0]);
cout << s;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int const lim = 1e5 + 3;
int const Msq = 320;
int inp[lim + 3], mx_con;
vector<int> cur[320];
int sq, cnt[Msq][lim + 3], n;
void build() {
vector<int> tem;
for (int i = 0; i <= sq; i++) {
for (int j = 0; j < cur[i].size(); j++)
tem.push_back(cur[i][j]), cnt[i][cur[i][j]]--;
cur[i].clear();
}
for (int i = 0; i < tem.size(); i++)
cur[i / sq].push_back(tem[i]), cnt[i / sq][tem[i]]++;
}
void update(int l, int r) {
int con_a = 0, con_b = 0, pre_a = 0, pre_b = 0;
while (pre_a + cur[con_a].size() - 1 < l) pre_a += cur[con_a].size(), con_a++;
con_b = con_a, pre_b = pre_a;
while (pre_b + cur[con_b].size() - 1 < r) pre_b += cur[con_b].size(), con_b++;
int val = cur[con_b][r - pre_b];
int ind_b = r - pre_b;
cur[con_b].erase(cur[con_b].begin() + ind_b);
cur[con_a].insert(cur[con_a].begin() + (l - pre_a), val);
cnt[con_a][val]++;
cnt[con_b][val]--;
}
int query(int l, int r, int x) {
int ret = 0;
int con_a = 0, con_b = 0, pre_a = 0, pre_b = 0;
while (pre_a + cur[con_a].size() - 1 < l) pre_a += cur[con_a].size(), con_a++;
con_b = con_a, pre_b = pre_a;
while (pre_b + cur[con_b].size() - 1 < r) pre_b += cur[con_b].size(), con_b++;
int ind_l = l - pre_a, ind_r = r - pre_b;
if (con_a == con_b) {
for (int i = ind_l; i <= ind_r; i++)
if (cur[con_a][i] == x) ret++;
return ret;
}
for (int i = ind_l; i < cur[con_a].size(); i++)
if (cur[con_a][i] == x) ret++;
for (int i = 0; i <= ind_r; i++)
if (cur[con_b][i] == x) ret++;
for (int i = con_a + 1; i < con_b; i++) ret += cnt[i][x];
return ret;
}
int main() {
cin >> n;
sq = sqrt(n) + 1;
for (int i = 0; i < n; i++)
scanf("%d", &inp[i]), cur[i / sq].push_back(inp[i]), cnt[i / sq][inp[i]]++;
int last_ans = 0, m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
if (i && i % sq == 0) build();
int t;
scanf("%d", &t);
int b, e;
scanf("%d%d", &b, &e);
b = (b + last_ans - 1 + n) % n;
e = (e + last_ans - 1 + n) % n;
if (b > e) swap(e, b);
if (t == 1)
update(b, e);
else {
int x;
scanf("%d", &x);
x = (x + last_ans - 1 + n) % n;
x++;
last_ans = query(b, e, x);
printf("%d\n", last_ans);
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int m[N], c[N];
vector<int> ans[N];
multiset<int> S;
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &m[i]);
S.insert(m[i]);
}
for (int i = 1; i <= k; i++) scanf("%d", &c[i]);
int cnt = 0;
while (!S.empty()) {
cnt++;
ans[cnt].clear();
while (true) {
int sz = ans[cnt].size();
int l = 1, r = k;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (c[mid] >= sz + 1)
l = mid;
else
r = mid - 1;
}
if (c[l] < sz + 1) break;
auto it = S.upper_bound(l);
if (it == S.begin()) break;
it--;
int val = *it;
S.erase(it);
ans[cnt].push_back(val);
}
}
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) {
printf("%d ", ans[i].size());
for (int& j : ans[i]) printf("%d ", j);
printf("\n");
}
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.