solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 5;
struct SAM {
int Go[26], fail, Len;
long long Val;
} A[MAXN * 2];
char S[MAXN], T[MAXN];
int N, tot, Start[MAXN], Root, p, Val, Ord[MAXN * 2];
void Add(int ch) {
int np = ++tot;
A[np].Len = A[p].Len + 1;
for (; p && !A[p].Go[ch]; p = A[p].fail) A[p].Go[ch] = np;
if (!p)
A[np].fail = Root;
else {
int q = A[p].Go[ch];
if (A[p].Len + 1 == A[q].Len)
A[np].fail = q;
else {
int nq = ++tot;
A[nq] = A[q];
A[q].fail = A[np].fail = nq;
A[nq].Len = A[p].Len + 1;
for (; p && A[p].Go[ch] == q; p = A[p].fail) A[p].Go[ch] = nq;
}
}
p = np;
}
bool Cmp(int x, int y) { return A[x].Len > A[y].Len; }
void Solve() {
for (int i = 1; i <= N; i++) {
scanf("%d", &Val);
p = 1;
for (int j = Start[i]; j < Start[i + 1]; j++) {
p = A[p].Go[T[j] - 'a'];
A[p].Val += Val;
}
}
for (int i = 1; i <= tot; i++) Ord[i] = i;
sort(Ord + 1, Ord + 1 + tot, Cmp);
for (int i = 1; i <= tot; i++) {
int Now = Ord[i];
A[A[Now].fail].Val += A[Now].Val;
}
long long Ans = 0;
for (int i = 1; i <= tot; i++) Ans = max(Ans, A[i].Val * A[i].Len);
printf("%I64d", Ans);
}
int main() {
scanf("%d", &N);
tot = 0;
for (int i = 1; i <= N; i++) {
Start[i] = tot + 1;
char ch = getchar();
while (ch < 'a' || ch > 'z') ch = getchar();
while (ch >= 'a' && ch <= 'z') T[++tot] = ch, ch = getchar();
}
Start[N + 1] = tot + 1;
Root = tot = 1;
for (int i = 1; i <= N; i++) {
p = 1;
for (int j = Start[i]; j < Start[i + 1]; j++) Add(T[j] - 'a');
}
Solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 22;
const int MOD = int(1e9) + 7;
const int oo = int(1e7);
int n, m;
int adj[22];
int dp[1 << 22], prv[1 << 22], ans[1 << 22];
int main() {
while (scanf("%d%d", &n, &m) == 2) {
memset(adj, 0, sizeof(adj));
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
adj[u] |= (1 << v);
adj[v] |= (1 << u);
}
for (int i = 0; i < n; ++i) adj[i] |= (1 << i);
for (int i = 1; i < (1 << n); ++i) {
int mask = -1;
bool ok = true;
for (int j = i; j > 0; j -= j & -j) {
int k = 31 - __builtin_clz(j & -j);
if (mask == -1)
mask = adj[k];
else
ok &= adj[k] == mask;
}
prv[i] = ans[i] = -1;
if (ok)
dp[i] = 0;
else
dp[i] = oo;
}
dp[0] = 0;
for (int i = 1; i < (1 << n); ++i) {
for (int j = i; j > 0; j -= j & -j) {
int k = 31 - __builtin_clz(j & -j);
if (dp[i] + 1 < dp[i | adj[k]]) {
prv[i | adj[k]] = i;
ans[i | adj[k]] = k;
dp[i | adj[k]] = dp[i] + 1;
}
}
}
printf("%d\n", dp[(1 << n) - 1]);
int mask = (1 << n) - 1;
while (prv[mask] != -1) {
printf("%d ", ans[mask] + 1);
mask = prv[mask];
}
printf("\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d%d", &n, &k);
long long pa = min(n / 2, k);
long long res1 = (n - 2 * pa) * pa;
long long res2 = (pa - 1) * pa / 2 + (2 * n - 1 - pa) * pa / 2;
cout << res1 + res2 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
const long long int inf = 9e18;
const long double pi = 2 * acos(0.0);
const int N = 1000005;
long long int tes, n, q;
vector<long long int> sieve(N, 0);
void si() {
sieve[1] = 1;
for (int i = 2; i < N; i++) {
if (sieve[i] == 0) {
for (int j = i; j < N; j += i) {
sieve[j] = i;
}
}
}
}
long long int power(long long int x, long long int y) {
long long int res = 1ll;
while (y > 0) {
if (y & 1) res = res * x;
y >>= 1;
x = x * x;
}
return res;
}
struct node {
long long int val = 0;
node() : val(0){};
};
struct SegTree {
long long int N;
vector<node> st;
vector<bool> cLazy;
vector<long long int> lazy;
void init(long long int n) {
N = n;
st.resize(4 * N + 5);
cLazy.assign(4 * N + 5, false);
lazy.assign(4 * N + 5, 0);
}
void merge(node &cur, node &l, node &r) { cur.val = l.val + r.val; }
void propagate(long long int ver, long long int L, long long int R) {
if (L != R) {
cLazy[ver * 2] = cLazy[ver * 2 + 1] = 1;
lazy[ver * 2] += lazy[ver], lazy[ver * 2 + 1] += lazy[ver];
}
st[ver].val += lazy[ver];
cLazy[ver] = lazy[ver] = 0;
}
void build(long long int ver, long long int L, long long int R,
vector<long long int> &a) {
if (L == R) {
st[ver].val = a[L - 1];
return;
}
long long int M = (L + R) / 2;
build(ver * 2, L, M, a), build(ver * 2 + 1, M + 1, R, a);
merge(st[ver], st[ver * 2], st[ver * 2 + 1]);
}
node Query(long long int ver, long long int L, long long int R,
long long int i, long long int j) {
if (cLazy[ver]) propagate(ver, L, R);
if (j < L || i > R) return node();
if (i <= L && R <= j) return st[ver];
long long int M = (L + R) / 2;
node left = Query(ver * 2, L, M, i, j),
right = Query(ver * 2 + 1, M + 1, R, i, j), cur;
merge(cur, left, right);
return cur;
}
node pQuery(long long int ver, long long int L, long long int R,
long long int pos) {
if (cLazy[ver]) propagate(ver, L, R);
if (L == R) return st[ver];
long long int M = (L + R) / 2;
if (pos <= M)
return pQuery(ver * 2, L, M, pos);
else
return pQuery(ver * 2 + 1, M + 1, R, pos);
}
void Update(long long int ver, long long int L, long long int R,
long long int i, long long int j, long long int val) {
if (cLazy[ver]) propagate(ver, L, R);
if (j < L || i > R) return;
if (i <= L && R <= j) {
cLazy[ver] = 1, lazy[ver] += val;
propagate(ver, L, R);
return;
}
long long int M = (L + R) / 2;
Update(ver * 2, L, M, i, j, val), Update(ver * 2 + 1, M + 1, R, i, j, val);
merge(st[ver], st[ver * 2], st[ver * 2 + 1]);
}
void pUpdate(long long int ver, long long int L, long long int R,
long long int pos, long long int val) {
if (cLazy[ver]) propagate(ver, L, R);
if (L == R) {
st[ver].val += val;
return;
}
long long int M = (L + R) / 2;
if (pos <= M)
pUpdate(ver * 2, L, M, pos, val);
else
pUpdate(ver * 2 + 1, M + 1, R, pos, val);
merge(st[ver], st[ver * 2], st[ver * 2 + 1]);
}
node query(long long int pos) { return pQuery(1, 1, N, pos); }
node query(long long int l, long long int r) { return Query(1, 1, N, l, r); }
void update(long long int pos, long long int val) {
pUpdate(1, 1, N, pos, val);
}
void update(long long int l, long long int r, long long int val) {
Update(1, 1, N, l, r, val);
}
node sum(long long int ver, long long int L, long long int R, long long int i,
long long int j, long long int mask, long long int lev) {
if (j < L || i > R) return node();
if (i <= L && R <= j) return st[ver];
long long int M = (L + R) / 2;
long long int chg;
if (((mask >> lev) & 1) >= 1)
chg = 1;
else
chg = 0;
node left = sum(ver * 2 + chg, L, M, i, j, mask, lev - 1),
right = sum(ver * 2 + 1 - chg, M + 1, R, i, j, mask, lev - 1), curr;
merge(curr, left, right);
return curr;
}
};
void solve() {
cin >> n >> q;
long long int siz = power(2, n), mask = 0;
vector<long long int> arr(siz);
;
for (int i = 0; i < siz; i++) cin >> arr[i];
SegTree st;
st.init(siz);
st.build(1, 1, siz, arr);
;
for (int i = 0; i < q; i++) {
long long int t, x, k, l, r;
cin >> t;
if (t == 1) {
cin >> x >> k;
x--;
x ^= mask;
st.update(x + 1, k - arr[x]);
arr[x] = k;
} else if (t == 2) {
cin >> k;
mask ^= power(2, k) - 1;
} else if (t == 3) {
cin >> k;
mask ^= power(2, k);
} else {
cin >> l >> r;
cout << st.sum(1, 1, siz, l, r, mask, n - 1).val << "\n";
}
}
}
int32_t main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
tes = 1;
while (tes--) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long a[200005];
long long b[200005];
vector<pair<long long, long long> > req[200005];
bool func(long long mid) {
int i, j;
if (n == 1) {
long long bat = a[0];
long long drn = b[0];
for (i = 0; i < k; i++) {
if (bat < 0) return false;
bat = (bat + mid - drn);
}
return true;
}
for (i = 1; i <= k; i++) req[i].clear();
for (i = 0; i < n; i++) {
long long nxt = floor(((double)a[i] + (double)b[i]) / ((double)b[i]));
if (nxt >= k) continue;
req[nxt].push_back(make_pair(a[i] - ((nxt - 1) * b[i]), b[i]));
}
int free = 0;
for (i = 1; i <= k; i++) {
free++;
for (j = 0; j < req[i].size(); j++) {
}
if (req[i].size() == 0) {
continue;
}
j = 0;
while (free && (j < req[i].size())) {
pair<long long, long long> temp;
temp = req[i][j];
temp.first = temp.first - temp.second;
while (free && (temp.first < 0)) {
free--;
temp.first = temp.first + mid;
}
if (temp.first < 0) return false;
long long nxt = floor(((double)temp.first + (double)temp.second) /
((double)temp.second));
nxt = nxt + (long long)i;
if (nxt < k)
req[nxt].push_back(
make_pair(temp.first - ((nxt - i - 1) * temp.second), temp.second));
j++;
}
if (j < req[i].size()) return false;
}
return true;
}
int main() {
int i, j;
scanf("%d", &n);
scanf("%d", &k);
for (i = 0; i < n; i++) scanf("%lld", &a[i]);
for (i = 0; i < n; i++) scanf("%lld", &b[i]);
long long low = 0, up = 100000000000000;
long long mid;
while (low <= up) {
mid = (low + up) / 2;
int ff = func(mid);
if (ff == 1)
up = mid - 1;
else
low = mid + 1;
}
if (up == 100000000000000) low = -1;
printf("%lld\n", low);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int colour[1010][1010], n, k, mx;
int group[1010];
void solve(vector<int> &v, int c) {
if (v.size() <= 1) return;
mx = max(mx, c);
vector<vector<int> > groups;
for (int i = 0; i < k; i++) {
groups.push_back(vector<int>());
}
int amPerGroup = ((int)v.size() + k - 1) / k;
int currGroup = 0;
int numInGroup = 0;
for (auto a : v) {
groups[currGroup].push_back(a);
group[a] = currGroup;
numInGroup++;
if (numInGroup == amPerGroup) {
numInGroup = 0;
currGroup++;
}
}
for (auto a : v) {
for (auto b : v) {
if (group[a] != group[b]) {
colour[a][b] = c;
}
}
}
for (auto &v2 : groups) {
solve(v2, c + 1);
}
}
int main() {
scanf("%d%d", &n, &k);
vector<int> v;
for (int i = 0; i < n; i++) v.push_back(i);
solve(v, 1);
printf("%d\n", mx);
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
printf("%d ", colour[i][j]);
}
}
printf("\n");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int maxi;
int n, arr[2005];
void func(int a, int b) {
int i, j;
int pre[2005];
memset(pre, 0, sizeof(pre));
pre[0] = 0;
for (i = 1; i <= n; i++) {
if (arr[i] == b)
pre[i] = pre[i - 1] + 1;
else
pre[i] = pre[i - 1];
}
int s = 0;
int e = n + 1;
int coun = 0;
while (s < e) {
for (i = s + 1; i <= e; i++)
if (arr[i] == a) break;
for (j = e - 1; j >= s; j--)
if (arr[j] == a) break;
if (i >= j)
break;
else {
coun = coun + 2;
maxi = max(maxi, coun + pre[j] - pre[i - 1]);
s = i;
e = j;
}
}
}
int main() {
int t;
cin >> t;
while (t--) {
int i, j;
cin >> n;
for (i = 1; i <= n; i++) cin >> arr[i];
int freq[27] = {};
for (i = 1; i <= n; i++) freq[arr[i]]++;
maxi = 0;
for (i = 1; i <= 26; i++)
for (i = 1; i <= 26; i++) maxi = max(maxi, freq[i]);
for (i = 1; i <= 25; i++)
for (j = i + 1; j <= 26; j++) {
if (freq[i] != 0 && freq[j] != 0) {
func(i, j);
func(j, i);
}
}
cout << maxi << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > q;
int main(void) {
long long n, i, tmp;
scanf("%lld", &n);
for (i = 1;; i++) {
tmp = i * (i + 1) * (2 * i + 1) / 6;
if (tmp > n) break;
long long now = n - tmp;
long long x = i * (i + 1) / 2;
if (now % x == 0) {
long long j = now / x;
q.push_back(make_pair(i, i + j));
if (j > 0) q.push_back(make_pair(i + j, i));
}
}
printf("%d\n", q.size());
sort(q.begin(), q.end());
for (i = 0; i < q.size(); i++) printf("%lld %lld\n", q[i].first, q[i].second);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
const int mod = 1e9 + 7;
const int inf = 1e9;
const int N = 2e6 + 10;
int n, maxL;
char second[N], ans[N];
int main() {
scanf("%d", &n);
while (n--) {
int k;
scanf("%s%d", second, &k);
int len = strlen(second);
int p, start = 0;
for (int i = 0; i < k; i++) {
scanf("%d", &p);
start = max(start, p);
for (int j = start; j < p + len; j++) ans[j] = second[j - p];
start = p + len;
}
maxL = max(maxL, p + len - 1);
}
for (int i = 1; i <= maxL; i++) {
if (ans[i])
printf("%c", ans[i]);
else
printf("a");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Vec {
double x, y;
Vec(double nx = 0, int ny = 0) {
x = nx;
y = ny;
}
Vec operator-(Vec r) { return Vec(x - r.x, y - r.y); }
bool operator==(Vec r) { return x == r.x && y == r.y; }
};
bool operator<(Vec l, Vec r) {
if (l.x < r.x) return true;
if (l.x > r.x) return false;
return l.y < r.y;
}
double len(Vec v) { return hypot(v.x, v.y); }
int main() {
int n, k;
cin >> n >> k;
vector<Vec> pts(n);
for (int i = 0; i < n; i++) cin >> pts[i].x;
Vec up, start;
cin >> up.x >> up.y;
if (k <= n)
start = pts[k - 1];
else
start = up;
sort(pts.begin(), pts.end());
double result = 1e18;
if (k == n + 1) {
result = min(len(pts[0] - up), len(pts.back() - up));
result += len(pts.back() - pts[0]);
cout << fixed << setprecision(7) << result << '\n';
return 0;
}
int lb = lower_bound(pts.begin(), pts.end(), start) - pts.begin();
for (int i = lb; i + 1 < (int)pts.size(); i++) {
double cur = len(pts[i] - pts[0]);
cur += min(len(pts[i] - start) + len(up - pts[0]),
len(pts[0] - start) + len(up - pts[i]));
cur += len(pts.back() - pts[i + 1]);
cur += min(len(pts[i + 1] - up), len(pts.back() - up));
result = min(result, cur);
}
for (int i = lb; i > 0; i--) {
double cur = len(pts.back() - pts[i]);
cur += min(len(pts[i] - start) + len(up - pts.back()),
len(pts.back() - start) + len(up - pts[i]));
cur += len(pts[i - 1] - pts[0]);
cur += min(len(pts[i - 1] - up), len(pts[0] - up));
result = min(result, cur);
}
{
double cur = len(pts.back() - pts[0]);
cur += min(len(pts.back() - start) + len(up - pts[0]),
len(pts[0] - start) + len(up - pts.back()));
result = min(result, cur);
}
cout << fixed << setprecision(7) << result << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
const int maxn = 200010;
int a[2][maxn];
int K[2] = {};
vector<pair<int, int> > ans;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int ki, ai1, xi, yi, mi;
scanf("%d%d%d%d%d", &ki, &ai1, &xi, &yi, &mi);
K[i] = ki;
a[i][0] = ai1;
for (int j = 1; j < ki; ++j) {
a[i][j] = ((long long)a[i][j - 1] * xi + yi) % mi;
}
}
int l = 0;
int r = 0;
while (l < K[0] && r < K[1]) {
int pred = 0;
if (int((ans).size())) pred = ans.back().first;
int lval = a[0][l];
int rval = a[1][r];
bool lll = false;
if (lval < pred && rval < pred) {
if (lval <= rval) lll = true;
} else if (lval >= pred && rval < pred) {
lll = true;
} else if (lval >= pred && rval >= pred) {
if (lval <= rval) lll = true;
}
if (lll)
ans.push_back(make_pair(lval, 1)), l++;
else
ans.push_back(make_pair(rval, 2)), r++;
}
while (l < K[0]) ans.push_back(make_pair(a[0][l++], 1));
while (r < K[1]) ans.push_back(make_pair(a[1][r++], 2));
int anscnt = 0;
for (int i = 1; i < int((ans).size()); ++i)
if (ans[i].first < ans[i - 1].first) anscnt++;
printf("%d\n", anscnt);
if (K[0] + K[1] <= 200000) {
for (int i = 0; i < int((ans).size()); ++i)
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, n, i, sum, x;
cin >> t;
for (i = 0; i < t; i++) {
sum = 0;
cin >> n;
while (n >= 10) {
x = n % 10;
n = n - x;
sum = sum + n;
n = n / 10;
n = n + x;
}
cout << sum + n << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
char _inp[4097], *_pinp = _inp;
char _;
using namespace std;
int N, M;
vector<pair<int, int>> edges;
int stfu[1000001];
int main() {
do {
while ((N = (*_pinp ? *_pinp++
: (_inp[fread(_pinp = _inp, 1, 4096, stdin)] = '\0',
*_pinp++))) < '0')
;
for (N -= '0';
'0' <=
(_ = (*_pinp ? *_pinp++
: (_inp[fread(_pinp = _inp, 1, 4096, stdin)] = '\0',
*_pinp++)));
N = (N << 3) + (N << 1) + _ - '0')
;
} while (0);
do {
while ((M = (*_pinp ? *_pinp++
: (_inp[fread(_pinp = _inp, 1, 4096, stdin)] = '\0',
*_pinp++))) < '0')
;
for (M -= '0';
'0' <=
(_ = (*_pinp ? *_pinp++
: (_inp[fread(_pinp = _inp, 1, 4096, stdin)] = '\0',
*_pinp++)));
M = (M << 3) + (M << 1) + _ - '0')
;
} while (0);
int a, b;
for (int i = 0; i < M; i++) {
do {
while ((a = (*_pinp ? *_pinp++
: (_inp[fread(_pinp = _inp, 1, 4096, stdin)] = '\0',
*_pinp++))) < '0')
;
for (a -= '0';
'0' <=
(_ = (*_pinp ? *_pinp++
: (_inp[fread(_pinp = _inp, 1, 4096, stdin)] = '\0',
*_pinp++)));
a = (a << 3) + (a << 1) + _ - '0')
;
} while (0);
do {
while ((b = (*_pinp ? *_pinp++
: (_inp[fread(_pinp = _inp, 1, 4096, stdin)] = '\0',
*_pinp++))) < '0')
;
for (b -= '0';
'0' <=
(_ = (*_pinp ? *_pinp++
: (_inp[fread(_pinp = _inp, 1, 4096, stdin)] = '\0',
*_pinp++)));
b = (b << 3) + (b << 1) + _ - '0')
;
} while (0);
stfu[a]++;
stfu[b]++;
edges.push_back({a, b});
}
long long ans = 1LL * N * (N - 1) * (N - 2) / 6, sum = 0;
for (auto& it : edges) {
int u = it.first, v = it.second;
sum += N * 2 - stfu[u] - stfu[v] - 2;
}
printf("%lld\n", ans - sum / 2);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
point(int _x, int _y) : x(_x), y(_y) {}
point operator+(point const& other) const {
return point(x + other.x, y + other.y);
}
point operator-(point const& other) const {
return point(x - other.x, y - other.y);
}
bool operator<(point const& other) const {
return x < other.x || (x == other.x && y < other.y);
}
bool operator==(point const& other) const {
return x == other.x && y == other.y;
}
bool operator!=(point const& other) const {
return x != other.x || y != other.y;
}
};
long long cross(point const& p1, point const& p2) {
return (long long)p1.x * p2.y - (long long)p1.y * p2.x;
}
long long dot(point const& p1, point const& p2) {
return (long long)p1.x * p2.x + (long long)p1.y * p2.y;
}
bool compare(point p1, point p2) {
return p1.x < p2.x || (p1.x == p2.x && p1.y < p2.y);
}
vector<point> convex_hull(vector<point> P) {
int n = P.size(), k = 0;
vector<point> H;
sort(P.begin(), P.end(), compare);
for (int i = 0; i < n; ++i) {
while (k >= 2 && cross(H[k - 2] - P[i], H[k - 1] - P[i]) <= 0) k--;
if (k == (int)(H).size())
H.emplace_back(P[i]), k++;
else
H[k++] = P[i];
}
for (int i = n - 2, t = k + 1; i >= 0; i--) {
while (k >= t && cross(H[k - 2] - P[i], H[k - 1] - P[i]) <= 0) k--;
if (k == (int)(H).size())
H.emplace_back(P[i]), k++;
else
H[k++] = P[i];
}
while ((int)(H).size() > k - 1) H.pop_back();
return H;
}
long long area(point a, point b, point c) {
long long res = (b.x - a.x) * 1ll * (b.y + a.y);
res += (c.x - b.x) * 1ll * (c.y + b.y);
res += (a.x - c.x) * 1ll * (a.y + c.y);
return abs(res);
}
vector<point> C;
int main() {
int n;
long long s;
scanf("%d%lld", &n, &s);
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
point p(x, y);
C.emplace_back(p);
}
long long mx = 0;
point x(0, 0), y(0, 0), z(0, 0);
C = convex_hull(C);
for (int i = 0; i < (int)(C).size(); i++) {
for (int j = i + 1, k = j + 1; j < (int)(C).size() - 1; j++) {
while (k < (int)(C).size() - 1 &&
area(C[i], C[j], C[k + 1]) >= area(C[i], C[j], C[k]))
k++;
long long A = area(C[i], C[j], C[k]);
if (mx < A) {
mx = A;
x = C[i];
y = C[j];
z = C[k];
}
}
}
printf("%d %d\n", (x - (z - y)).x, (x - (z - y)).y);
printf("%d %d\n", (x + (z - y)).x, (x + (z - y)).y);
printf("%d %d\n", (y + (z - x)).x, (y + (z - x)).y);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long mult(long long a, long long b, long long p = (long long)(998244353)) {
return ((a % p) * (b % p)) % p;
}
long long add(long long a, long long b, long long p = (long long)(998244353)) {
return (a % p + b % p) % p;
}
long long fpow(long long n, long long k, long long p = (long long)(998244353)) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
long long inv(long long a, long long p = (long long)(998244353)) {
return fpow(a, p - 2, p);
}
bool sa(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
bool fd(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
bool sd(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second > b.second);
}
const long long N = 100005;
long long dx[4] = {0, 0, 1, -1};
long long dy[4] = {1, -1, 0, 0};
vector<long long> v[N];
double dp[N];
bool valid(long long x, long long y, long long n, long long m) {
if (x < 0 || y < 0) {
return false;
} else if (x >= n || y >= m) {
return false;
} else
return true;
}
long long hor[505][505];
long long ver[505][505];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, r2, c2, r1, c1, q, ans1 = 0, ans2 = 0;
cin >> n >> m;
string s[n + 5];
for (long long i = 1; i < n + 1; i++) {
cin >> s[i];
}
long long hor[n + 5][m + 5];
long long ver[n + 5][m + 5];
for (long long i = 1; i < n + 1; i++) {
for (long long j = 1; j < m + 1; j++) {
hor[i][j] = hor[i - 1][j] + hor[i][j - 1] - hor[i - 1][j - 1];
ver[i][j] = ver[i - 1][j] + ver[i][j - 1] - ver[i - 1][j - 1];
if (s[i][j - 1] == '.' && s[i][j - 2] == '.') hor[i][j]++;
if (s[i][j - 1] == '.' && s[i - 1][j - 1] == '.') ver[i][j]++;
}
}
cin >> q;
while (q--) {
cin >> r1 >> c1 >> r2 >> c2;
ans1 = hor[r2][c2] - hor[r1 - 1][c2] - hor[r2][c1] + hor[r1 - 1][c1];
ans2 = ver[r2][c2] - ver[r2][c1 - 1] - ver[r1][c2] + ver[r1][c1 - 1];
cout << (ans1 + ans2) << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> Map;
set<int> Set, Sec;
int ans;
int main() {
int N, K;
int num;
cin >> N >> K;
for (int i = 0; i < N; i++) {
scanf("%d", &num);
Set.insert(num);
if (Map.find(num) == Map.end()) {
Map.insert(make_pair(num, 1));
} else {
Map[num] = Map[num] + 1;
}
}
set<int>::iterator iter = Set.begin();
set<int>::iterator lst = iter;
iter++;
for (; iter != Set.end(); iter++) {
if (*lst + K >= *iter) {
Sec.insert(*lst);
}
lst++;
}
for (iter = Sec.begin(); iter != Sec.end(); iter++) {
ans += Map[*iter];
}
cout << N - ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
long long mod = 1000000007;
using namespace std;
long long power(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) {
ans = (ans * a) % mod;
}
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
long long max(long long a, long long b) { return a > b ? a : b; }
bool r(pair<long long, long long> p1, pair<long long, long long> p2) {
return (p2.first < p1.first);
}
long long min(long long a, long long b) { return a < b ? a : b; }
const int N = 100099;
long long n, a[N], x, ans, k, h1, h2, P = 9013, q;
void solve() {
cin >> n >> k;
vector<pair<long long, long long> > p;
map<pair<long long, long long>, long long> make_pair;
for (int i = 0; i < n; ++i) {
cin >> a[i];
x = a[i];
for (long long j = 2; j * j <= x; ++j) {
if (x % j == 0) {
p.push_back({j, 0LL});
while (x % j == 0) {
x /= j;
++p.back().second;
}
p.back().second %= k;
}
}
if (x != 1) {
p.push_back({x, 1LL});
}
q = 1;
h1 = h2 = 0;
for (int j = 0; j < p.size(); ++j) {
if (p[j].second == 0) {
continue;
}
h1 += q * p[j].first;
h2 += q * (k - p[j].second);
q *= P;
}
ans += make_pair[{h1, h2}];
q = 1;
h1 = h2 = 0;
for (int j = 0; j < p.size(); ++j) {
if (p[j].second == 0) {
continue;
}
h1 += q * p[j].first;
h2 += q * p[j].second;
q *= P;
}
++make_pair[{h1, h2}];
p.clear();
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int diri[] = {-1, 0, 1, 0, -1, 1, 1, -1};
int dirj[] = {0, 1, 0, -1, 1, 1, -1, -1};
int compare(double d1, double d2) {
if (fabs(d1 - d2) < 1e-9) return 0;
if (d1 < d2) return -1;
return 1;
}
int arr[100001];
int mn[100001];
int main() {
int n;
cin >> n;
for (int i = 0; i < (int)n; i++) cin >> arr[i];
mn[n - 1] = arr[n - 1];
for (int i = n - 2; i >= (int)0; i--) mn[i] = min(arr[i], mn[i + 1]);
for (int i = 0; i < (int)n; i++) {
int ind = lower_bound(mn, mn + n, arr[i]) - mn;
ind--;
if (ind == n || ind <= i)
cout << -1;
else
cout << ind - i - 1;
cout << " \n"[i == n - 1];
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400100, M = 15001000, MX = 1e9;
int ls[M], rs[M], ok[M], tot, root;
int newnode() {
ok[tot] = ls[tot] = rs[tot] = 0;
return tot++;
}
void build() {
tot = 1;
root = newnode();
}
void up(int rt) {
if (ok[ls[rt]] == 2 && ok[rs[rt]] == 2)
ok[rt] = 2;
else
ok[rt] = ok[ls[rt]] || ok[rs[rt]];
}
void updata(int &rt, int l, int r, int tl, int tr) {
if (rt == 0) rt = newnode();
if (ok[rt] == 2) return;
if (tl <= l && r <= tr) {
ok[rt] = 2;
return;
}
int m = l + r >> 1;
if (tl <= m) updata(ls[rt], l, m, tl, tr);
if (m < tr) updata(rs[rt], m + 1, r, tl, tr);
up(rt);
}
vector<pair<int, int> > g;
void query(int rt, int l, int r, int tl, int tr) {
if (rt == 0) return;
if (ok[rt] == 2) {
g.push_back(pair<int, int>(max(tl, l), min(tr, r)));
return;
}
if (ok[rt] == 0) return;
int m = l + r >> 1;
if (tl <= m) query(ls[rt], l, m, tl, tr);
if (m < tr) query(rs[rt], m + 1, r, tl, tr);
}
struct line {
int l, r, t;
line(int l = 0, int r = 0, int t = 0) : l(l), r(r), t(t) {}
} a[N], c[N];
bool cmp(line a, line b) { return a.t < b.t; }
map<int, vector<int> > mp;
set<int> st;
map<int, vector<int> >::iterator it;
void up(vector<int> &a, int c) {
if (a.size() == 0)
a.push_back(c);
else
a[0] += c;
}
int res[N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &c[i].l, &c[i].r, &c[i].t);
c[i].r--;
}
sort(c + 1, c + 1 + m, cmp);
build();
int an = 0;
for (int i = 1; i <= m; i++) {
int tl = c[i].l;
int tr = c[i].r;
g.clear();
query(root, 0, MX, tl, tr);
int now = tl;
for (int j = 0; j < (int)g.size(); j++) {
if (g[j].first != now) {
a[++an] = line(now, g[j].first - 1, c[i].t);
}
now = g[j].second + 1;
}
if (now <= tr) a[++an] = line(now, tr, c[i].t);
updata(root, 0, MX, tl, tr);
}
m = an;
for (int i = 1; i <= m; i++) {
up(mp[a[i].t - a[i].r], 1);
st.insert(a[i].t - a[i].r);
up(mp[a[i].t - a[i].l + 1], -1);
st.insert(a[i].t - a[i].l + 1);
}
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
mp[x].push_back(i);
}
int now = 0, pre = 0, sum = 0;
for (it = mp.begin(); it != mp.end(); it++) {
int pos = (*it).first;
vector<int> &a = (*it).second;
sum += now * (pos - pre);
int f = 0;
if (st.find(pos) != st.end()) now += a[0], sum += a[0], f++;
for (int i = f; i < (int)a.size(); i++) {
res[a[i]] = sum;
}
pre = pos;
}
for (int i = 1; i <= n; i++) printf("%d\n", res[i]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, k, i, b;
string ans;
cin >> n >> k;
if (k > n || (k == 1) && n > 1)
cout << -1;
else {
if (n == 1)
ans = "a";
else {
k -= 2;
ans = "";
n -= k;
for (i = b = 0; i < n; i++, b = !b) ans += char('a' + b);
for (i = 0; i < k; i++) ans += char('c' + i);
}
cout << ans;
}
return EXIT_SUCCESS;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10000;
long long dp[N][5][2], pos[N], pw[5] = {1};
long long solve(long long l, int tim, bool ask = false) {
if (tim == 0) {
return l + 1;
}
if (l >= N) {
if (ask) {
cout << N;
for (int i = 1; i <= N; i++) {
cout << " " << l + pw[tim - 1] * i;
}
cout << endl;
int ret;
cin >> ret;
assert(ret != -2);
if (ret == -1) {
exit(0);
}
solve(l + ret * pw[tim - 1], tim - 1, true);
}
return l + pw[tim];
}
if (dp[l][tim - 1][ask] > 0) {
return dp[l][tim - 1][ask];
}
if (ask) {
cout << l + 1;
pos[0] = l;
}
long long cur = solve(l, tim - 1);
for (int i = 0; i <= l; i++) {
if (ask) {
pos[i + 1] = cur;
cout << " " << cur;
}
cur = solve(cur, tim - 1);
}
if (ask) {
cout << endl;
int ret;
cin >> ret;
assert(ret != -2);
if (ret == -1) {
exit(0);
}
solve(pos[ret], tim - 1, true);
}
return dp[l][tim - 1][ask] = cur;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
for (int i = 1; i < 5; i++) {
pw[i] = pw[i - 1] * 10001;
}
solve(0, 5, true);
}
| 11 |
#include <bits/stdc++.h>
int main() {
char sign[102];
int size, r, b, y, g, counts[100], j = 0;
int color[4] = {0, 0, 0, 0};
gets(sign);
size = strlen(sign);
for (int i = 1; i <= size; i++) {
if (sign[i - 1] == 'R') {
r = i % 4;
}
if (sign[i - 1] == 'B') {
b = i % 4;
}
if (sign[i - 1] == 'Y') {
y = i % 4;
}
if (sign[i - 1] == 'G') {
g = i % 4;
}
if (sign[i - 1] == '!') {
counts[j] = i;
j++;
}
}
for (int i = 0; i < j; i++) {
if (counts[i] % 4 == r) {
color[0]++;
}
if (counts[i] % 4 == b) {
color[1]++;
}
if (counts[i] % 4 == y) {
color[2]++;
}
if (counts[i] % 4 == g) {
color[3]++;
}
}
printf("%d %d %d %d", color[0], color[1], color[2], color[3]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
string s;
int main() {
cin >> s;
int i = 0, cnt = 0;
int len = s.size();
while ((i = s.find("VK")) != -1) {
s[i] = s[i + 1] = '.';
cnt++;
}
if (s.find("VV") != -1 || s.find("KK") != -1) cnt++;
printf("%d\n", cnt);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') positive = 0;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
int N, size[105], visit[105];
char opp[105];
string a[105], b[105], c[105];
int main() {
N = read();
for (int i = 1; i <= N; ++i) cin >> a[i];
for (int i = 1; i <= N; ++i) cin >> b[i], ++size[b[i][0]];
sort(a + 1, a + N + 1);
sort(b + 1, b + N + 1);
for (int i = 1; i <= N; ++i)
if (size[a[i][0]]) --size[a[i][0]], opp[i] = a[i][0];
for (int i = 1; i <= N; ++i) {
if (opp[i]) {
for (int j = 1; j <= N; ++j)
if (!visit[j] && a[i][0] == b[j][0]) {
c[i] = b[j];
visit[j] = 1;
break;
}
} else {
for (int j = 1; j <= N; ++j)
if (!visit[j] && size[b[j][0]]) {
c[i] = b[j];
size[b[j][0]]--;
visit[j] = 1;
break;
}
}
}
int last = 1;
for (int i = 2; i <= N + 1; ++i)
if (i > N || a[i][0] != a[i - 1][0]) {
sort(c + last, c + i);
last = i;
}
for (int i = 1; i <= N; ++i) {
cout << a[i] << " " << c[i];
if (i < N) cout << ", ";
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int T = 1;
while (T--) {
long long int n, k;
cin >> n >> k;
long long int i, a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
i = n / 2;
long long int cnt = 1, ans = a[n / 2], v;
while (k > 0 && i + 1 < n) {
v = min(k / cnt, a[i + 1] - ans);
ans += v;
k = k - v * cnt;
cnt++;
i++;
}
if (k > 0) {
ans += k / cnt;
}
cout << ans;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 200005;
int n, m, f[N], s[N], tim, pos[N], bel[N], sz, top, rev[N * 2], ans[N];
std::pair<int, int> stack[N];
std::map<std::pair<int, int>, int> ma;
std::vector<std::pair<int, int> > tag[N * 4];
std::vector<int> vec[N * 2];
struct data {
int op, x, y;
} p[N];
struct edge {
int x, y;
} e[N * 2];
void ins(int d, int l, int r, int x, int y, int z, int op) {
if (x <= l && r <= y) {
tag[d].push_back(std::make_pair(z, op));
return;
}
int mid = (l + r) / 2;
if (x <= mid) ins(d << 1, l, mid, x, y, z, op);
if (y > mid) ins(d << 1 | 1, mid + 1, r, x, y, z, op);
}
int find(int x) {
if (f[x] == x)
return x;
else
return find(f[x]);
}
void add(int w) {
int x = find(e[w].x), y = find(e[w].y);
if (x == y) return;
if (s[x] > s[y]) std::swap(x, y);
f[x] = y;
s[y] += s[x];
stack[++top] = std::make_pair(x, y);
}
void back(int now) {
while (top > now) {
int x = stack[top].first, y = stack[top].second;
top--;
s[y] -= s[x];
f[x] = x;
}
}
void solve(int d, int l, int r) {
if (l == r) {
int tmp = top;
for (int i = 0; i < tag[d].size(); i++)
if (tag[d][i].second == rev[tag[d][i].first]) add(tag[d][i].first);
ans[l] = find(p[bel[l]].x) == find(p[bel[l]].y);
back(tmp);
if (l == tim) return;
p[bel[l + 1]].x = (p[bel[l + 1]].x + ans[l] - 1) % n + 1;
p[bel[l + 1]].y = (p[bel[l + 1]].y + ans[l] - 1) % n + 1;
for (int i = bel[l] + 1; i < bel[l + 1]; i++) {
int x = (p[i].x + (ans[l] ^ 1) - 1) % n + 1,
y = (p[i].y + (ans[l] ^ 1) - 1) % n + 1;
if (x > y) std::swap(x, y);
rev[ma[std::make_pair(x, y)]] ^= 1;
}
return;
}
int mid = (l + r) / 2, tmp = top;
for (int i = 0; i < tag[d].size(); i++)
if (tag[d][i].second == rev[tag[d][i].first]) add(tag[d][i].first);
solve(d << 1, l, mid);
back(tmp);
for (int i = 0; i < tag[d].size(); i++)
if (tag[d][i].second == rev[tag[d][i].first]) add(tag[d][i].first);
solve(d << 1 | 1, mid + 1, r);
back(tmp);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &p[i].op, &p[i].x, &p[i].y);
if (p[i].op == 1) {
int x = (p[i].x - 1) % n + 1, y = (p[i].y - 1) % n + 1;
if (x > y) std::swap(x, y);
if (!ma[std::make_pair(x, y)])
ma[std::make_pair(x, y)] = ++sz, e[sz].x = x, e[sz].y = y;
vec[ma[std::make_pair(x, y)]].push_back(i);
if (!tim) continue;
x = p[i].x % n + 1;
y = p[i].y % n + 1;
if (x > y) std::swap(x, y);
if (!ma[std::make_pair(x, y)])
ma[std::make_pair(x, y)] = ++sz, e[sz].x = x, e[sz].y = y;
pos[i] = tim;
vec[ma[std::make_pair(x, y)]].push_back(i);
} else {
pos[i] = ++tim;
bel[tim] = i;
}
}
for (int i = 1; i <= sz; i++) {
for (int j = 0; j < vec[i].size() - 1; j++)
if (pos[vec[i][j]] < pos[vec[i][j + 1]])
ins(1, 1, tim, pos[vec[i][j]] + 1, pos[vec[i][j + 1]], i, j & 1);
int t = vec[i].back();
if (pos[t] < tim)
ins(1, 1, tim, pos[t] + 1, tim, i, (vec[i].size() & 1) ^ 1);
}
for (int i = 1; i <= n; i++) f[i] = i, s[i] = 1;
solve(1, 1, tim);
for (int i = 1; i <= tim; i++) putchar(ans[i] + '0');
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long a[(int)1e5 + 30], b[(int)1e5 + 30], dp[(int)1e5 + 30],
dp2[(int)1e5 + 30];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
b[i] = abs(a[i] - a[i - 1]);
}
long long ans = -1, res = 0;
for (int i = 1; i < n; i++) {
if (i % 2)
res += b[i];
else
res -= b[i];
if (res < 0) res = 0;
ans = max(ans, res);
}
res = 0;
for (int i = 2; i < n; i++) {
if (i % 2)
res -= b[i];
else
res += b[i];
if (res < 0) res = 0;
ans = max(ans, res);
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long TESTS = 1;
while (TESTS--) {
long long n;
cin >> n;
set<long long> k;
for (long long i = 1; i < sqrt(n) + 1; i++)
if (n % i == 0) k.insert(i), k.insert(n / i);
cout << (long long)k.size();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s[30000];
char sc[30000][21];
int main() {
int n;
bool f = true;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%s", &sc[i]);
s[i] = sc[i];
}
int i;
for (i = 0; i < s[0].size() && f; i++)
for (int j = 1; j < n; j++) {
if (sc[j - 1][i] != sc[j][i]) {
f = false;
break;
}
}
cout << i - 1;
}
| 0 |
#include <bits/stdc++.h>
int n, m;
int ans;
;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
int h, g;
scanf("%d %d", &h, &g);
ans += g - h + 1;
}
printf("%d", (m - (ans % m)) % m);
getchar();
getchar();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string sir;
int lungimeSir;
int pozitiePutere = -1;
int pozitiePunct = -1;
int FormeazaNumar() {
int numar = 0;
for (int i = 0, p = 10; i < lungimeSir; ++i) {
if (pozitiePutere != -1) {
switch (sir[i]) {
case 48: {
numar = numar * p + 0;
break;
}
case 49: {
numar = numar * p + 1;
break;
}
case 50: {
numar = numar * p + 2;
break;
}
case 51: {
numar = numar * p + 3;
break;
}
case 52: {
numar = numar * p + 4;
break;
}
case 53: {
numar = numar * p + 5;
break;
}
case 54: {
numar = numar * p + 6;
break;
}
case 55: {
numar = numar * p + 7;
break;
}
case 56: {
numar = numar * p + 8;
break;
}
case 57: {
numar = numar * p + 9;
break;
}
}
}
if (sir[i] == 'e') {
pozitiePutere = i - 1;
}
}
return numar;
}
int main() {
int putere;
int i;
int aux;
cin >> sir;
lungimeSir = sir.size();
putere = FormeazaNumar();
for (i = 0; sir[i] != '.' && sir[i] != 'e'; ++i) {
cout << sir[i];
}
if (sir[i] == '.') {
++i;
for (; sir[i] != 'e' && putere > 0; ++i, --putere) {
cout << sir[i];
}
if (putere == 0 && sir[i] != 'e') {
int aux = i;
bool ok = true;
for (; sir[aux] != 'e'; ++aux) {
if (sir[aux] != '0') {
ok = false;
}
}
if (ok == false) {
cout << '.';
for (; sir[i] != 'e'; ++i) {
cout << sir[i];
}
}
} else {
while (putere-- > 0) {
cout << 0;
}
}
} else if (sir[0] != 0 && putere != 0) {
while (putere--) {
cout << 0;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100025;
int n, m, i, j, t, k, s, a[maxn << 1], N, head[maxn], dfn[maxn << 1], low[maxn],
ti;
int stk[maxn], tpp, Head_yf[maxn << 1], b[maxn << 1];
int siz[maxn << 1], son[maxn << 1], tp[maxn << 1], fa[maxn << 1],
dep[maxn << 1];
int seg[maxn << 3], nowfang, dn;
multiset<int> S[maxn << 1];
struct Edge {
int nxt, aim;
} edge[maxn * 6];
inline void add_edge(int x, int y) {
edge[++N] = (Edge){head[x], y};
head[x] = N;
}
inline void yf_add_edge(int x, int y) {
edge[++N] = (Edge){Head_yf[x], y};
Head_yf[x] = N;
}
inline int get_mn(int x) { return *S[x].begin(); }
void tarjan(int x, int y) {
low[x] = dfn[x] = ++ti;
stk[++tpp] = x;
for (int i = head[x]; i; i = edge[i].nxt) {
int des = edge[i].aim;
if (des == y) continue;
if (!dfn[des]) {
tarjan(des, x), low[x] = min(low[x], low[des]);
if (low[des] >= dfn[x]) {
++nowfang;
a[nowfang] = (1e9) + 7;
while (stk[tpp] != des) {
yf_add_edge(stk[tpp], nowfang);
yf_add_edge(nowfang, stk[tpp]);
a[nowfang] = min(a[nowfang], a[stk[tpp]]);
--tpp;
}
--tpp;
yf_add_edge(x, nowfang);
yf_add_edge(nowfang, x);
yf_add_edge(des, nowfang);
yf_add_edge(nowfang, des);
a[nowfang] = min(a[nowfang], min(a[x], a[des]));
}
} else
low[x] = min(low[x], dfn[des]);
}
}
void dfs1(int x, int y) {
siz[x] = 1;
dep[x] = dep[y] + 1;
for (int i = Head_yf[x]; i; i = edge[i].nxt) {
int des = edge[i].aim;
if (des == y) continue;
dfs1(des, x);
fa[des] = x;
if (x > n) S[x].insert(a[des]);
siz[x] += siz[des];
if (siz[des] > siz[son[x]]) son[x] = des;
}
}
void dfs2(int x, int y) {
dfn[x] = ++ti;
b[ti] = x;
if (son[x]) {
tp[son[x]] = tp[x];
dfs2(son[x], x);
}
for (int i = Head_yf[x]; i; i = edge[i].nxt) {
int des = edge[i].aim;
if (des == y || des == son[x]) continue;
tp[des] = des;
dfs2(des, x);
}
}
void build(int rt, int l, int r) {
if (l == r) {
if (b[l] <= n)
seg[rt] = a[b[l]];
else
seg[rt] = get_mn(b[l]);
return;
}
int mid = (l + r) / 2;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
seg[rt] = min(seg[rt << 1], seg[rt << 1 | 1]);
}
void upd(int rt, int l, int r, int pl, int x) {
if (l == r) {
seg[rt] = x;
return;
}
int mid = (l + r) / 2;
if (pl <= mid)
upd(rt << 1, l, mid, pl, x);
else
upd(rt << 1 | 1, mid + 1, r, pl, x);
seg[rt] = min(seg[rt << 1], seg[rt << 1 | 1]);
}
int query(int rt, int l, int r, int L, int R) {
if (l >= L && r <= R) return seg[rt];
int mid = (l + r) / 2;
if (R <= mid) return query(rt << 1, l, mid, L, R);
if (L > mid) return query(rt << 1 | 1, mid + 1, r, L, R);
return min(query(rt << 1, l, mid, L, R),
query(rt << 1 | 1, mid + 1, r, L, R));
}
int Query(int x, int y) {
int ret = (1e9) + 16;
while (1) {
if (tp[x] == tp[y]) {
if (dep[x] > dep[y]) swap(x, y);
ret =
min(ret, query(1, 1, dn, (x == tp[x] || x <= n ? dfn[x] : dfn[x] - 1),
dfn[y]));
if (x == tp[x] && x > n) ret = min(ret, a[fa[x]]);
return ret;
}
if (dep[tp[x]] < dep[tp[y]]) swap(x, y);
ret = min(ret, query(1, 1, dn, dfn[tp[x]], dfn[x]));
x = fa[tp[x]];
}
}
int main() {
int T;
scanf("%d%d%d", &n, &m, &T);
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (i = 1; i <= m; ++i) {
scanf("%d%d", &t, &k);
add_edge(t, k);
add_edge(k, t);
}
nowfang = n;
tarjan(1, 0);
dn = nowfang;
dfs1(1, 0);
ti = 0;
tp[1] = 1;
fa[1] = 1;
dfs2(1, 0);
build(1, 1, dn);
while (T--) {
char op[2];
int x, y;
scanf("%s", op);
scanf("%d%d", &x, &y);
if (op[0] == 'C') {
upd(1, 1, dn, dfn[x], y);
if (fa[x] > n) {
S[fa[x]].erase(S[fa[x]].find(a[x]));
S[fa[x]].insert(y);
upd(1, 1, dn, dfn[fa[x]], get_mn(fa[x]));
}
a[x] = y;
} else {
printf("%d\n", Query(x, y));
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
int n, m, k, s;
cin >> n;
cin >> m;
cin >> k;
cin >> s;
vector<int> townProds(n);
for (int i = 0; i < n; ++i) {
cin >> townProds[i];
townProds[i] -= 1;
}
vector<vector<int> > adjMat(n);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a;
cin >> b;
adjMat[a - 1].push_back(b - 1);
adjMat[b - 1].push_back(a - 1);
}
vector<vector<int> > prodMat(n, vector<int>(k, 100 * n));
for (int i = 0; i < n; ++i) prodMat[i][townProds[i]] = 0;
for (int i = 0; i < k; ++i) {
deque<int> queue;
for (int t = 0; t < n; ++t)
if (prodMat[t][i] == 0) queue.push_back(t);
while (queue.size() > 0) {
int cur = queue.front();
queue.pop_front();
for (auto next : adjMat[cur]) {
if (prodMat[cur][i] + 1 >= prodMat[next][i]) continue;
prodMat[next][i] = prodMat[cur][i] + 1;
queue.push_back(next);
}
}
}
for (int j = 0; j < n; ++j) {
nth_element(prodMat[j].begin(), prodMat[j].begin() + s, prodMat[j].end());
int total = accumulate(prodMat[j].begin(), prodMat[j].begin() + s, 0);
if (j < n - 1)
cout << total << " ";
else
cout << total << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
int x[n];
for (int i = 0; i < n; i++) {
cin >> x[i];
}
int a;
cin >> a;
int c[n];
priority_queue<int> p;
for (int i = 0; i < n; i++) {
cin >> c[i];
}
long long int sum = 0, cap = k;
for (int i = 0; i < n; i++) {
p.push(-c[i]);
if (cap < x[i]) {
while (!p.empty()) {
sum += p.top();
p.pop();
cap += a;
if (cap >= x[i]) {
break;
}
}
if (cap < x[i] && p.empty()) {
cout << -1;
return 0;
}
}
}
cout << (-1) * sum;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long t, n, z, x, c, s;
int main() {
cin >> t;
while (t--) {
cin >> n;
long long f = 0;
for (int i = 2; i * i <= n; i++) {
for (int j = i + 1; j * j <= (n / i); j++) {
z = i * j;
x = n / z;
s = i * j * x;
if (s == n) {
if (i != j && i != x && j != x) {
f = 1;
cout << "YES"
<< "\n";
cout << i << " " << j << " " << x << "\n";
break;
} else
continue;
}
}
if (f == 1) break;
}
if (f == 0)
cout << "NO"
<< "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " , ";
__f(comma + 1, args...);
}
const int maxn = 2e5 + 10;
long long ans1, ans2;
vector<pair<int, int>> g[maxn];
vector<int> siz;
int n;
void dfs(int u, int par) {
siz[u] = 1;
for (auto v : g[u])
if (v.first != par) {
dfs(v.first, u);
siz[u] += siz[v.first];
if (siz[v.first] & 1) ans1 += v.second;
ans2 += min(siz[v.first], n - siz[v.first]) * 1LL * v.second;
}
}
int main() {
ios::sync_with_stdio(0);
int i, j, k, tt;
cin >> tt;
while (tt--) {
cin >> n;
n <<= 1;
siz.resize(n, 0);
for (i = 0; i < n; ++i) g[i].clear();
vector<pair<pair<int, int>, int>> ed;
for (i = 0; i < n - 1; ++i) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
g[u].push_back({v, w});
g[v].push_back({u, w});
ed.push_back({{u, v}, w});
}
ans1 = ans2 = 0;
dfs(0, -1);
cout << ans1 << " " << ans2 << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double range[100000 + 2];
int count(long long l, long long r, long long p) {
int lc = l / p;
if (l % p == 0) lc--;
int rc = r / p;
return rc - lc;
}
int main() {
ios::sync_with_stdio(false);
int n;
long long p;
cin >> n >> p;
for (int i = 0; i < n; i++) {
long long l, r;
cin >> l >> r;
range[i] = double(count(l, r, p)) / (r - l + 1);
}
double sum = 0;
for (int i = 0; i < n; i++) {
sum += 2000 * (1 - (1 - range[i]) * (1 - range[(i + 1) % n]));
}
cout << fixed << sum << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 100;
const int NN = 1272727;
struct Node {
int sz, val, flag, mx;
Node *ls, *rs, *fa;
} buf[NN];
int used, ans, cnt, F;
struct Splay_Tree {
Node *root, *NIL;
Node *create_node(int first) {
Node *node = &buf[used++];
node->sz = 1;
node->val = first;
node->flag = 0;
node->mx = first;
node->ls = node->rs = node->fa = NIL;
return node;
}
void init() {
used = 0;
NIL = create_node(0);
NIL->sz = 0;
NIL->mx = NIL->val = 0;
NIL->flag = 0;
Node *first = create_node(0);
Node *second = create_node(inf);
first->rs = second;
second->fa = first;
root = first;
update(first);
}
void update(Node *first) {
first->sz = first->ls->sz + first->rs->sz + 1;
first->mx = first->val;
if (first->rs != NIL) first->mx = max(first->mx, first->rs->mx);
}
void zig(Node *first) {
Node *second = first->rs, *p = first->fa;
first->rs = second->ls;
second->ls->fa = first;
second->ls = first;
first->fa = second;
second->fa = p;
if (p == NIL)
root = second;
else if (p->ls == first)
p->ls = second;
else
p->rs = second;
update(first);
}
void zag(Node *first) {
Node *second = first->ls, *p = first->fa;
first->ls = second->rs;
second->rs->fa = first;
second->rs = first;
first->fa = second;
second->fa = p;
if (p == NIL)
root = second;
else if (p->rs == first)
p->rs = second;
else
p->ls = second;
update(first);
}
void splay(Node *first, Node *g) {
Node *second, *z;
while (first->fa != g) {
second = first->fa;
z = second->fa;
if (z == g) {
if (first == second->rs)
zig(second);
else
zag(second);
} else if (second == z->rs) {
if (first == second->rs)
zig(z), zig(second);
else
zag(second), zig(z);
} else {
if (first == second->rs)
zig(second), zag(z);
else
zag(z), zag(second);
}
}
update(first);
}
void push_down(Node *u) {
if (!(u->flag)) return;
u->ls->val += u->flag;
u->rs->val += u->flag;
u->ls->mx += u->flag;
u->rs->mx += u->flag;
u->ls->flag += u->flag;
u->rs->flag += u->flag;
u->flag = 0;
}
Node *find(Node *first, int k) {
push_down(first);
if (k <= first->ls->sz) return find(first->ls, k);
if (k == first->ls->sz + 1) return first;
return find(first->rs, k - first->ls->sz - 1);
}
void insert(int k, int val) {
Node *first = create_node(val);
Node *z = find(root, k);
Node *second = find(root, k + 1);
splay(z, NIL);
splay(second, z);
second->ls = first;
first->fa = second;
update(second);
update(z);
}
void remove(int k) {
Node *z = find(root, k), *second = find(root, k + 2);
splay(z, NIL);
splay(second, z);
second->ls = NIL;
update(second);
update(z);
}
void add(int l, int r) {
Node *z = find(root, l);
Node *second = find(root, r + 2);
splay(z, NIL);
splay(second, z);
Node *first = second->ls;
first->flag++;
first->val++;
first->mx++;
}
int FF(Node *u, int V) {
push_down(u);
if (u->ls->sz and u->ls->mx >= V) return FF(u->ls, V);
cnt += u->ls->sz;
if (u->val >= V) {
return cnt;
}
cnt++;
return FF(u->rs, V);
}
int FIND(int P) {
cnt = 0;
return FF(root, P);
}
} Splay;
int main() {
Splay.init();
int n;
scanf("%d", &n);
int ans = 0, fl = 1;
for (int i = 1; i <= n; i++) {
if (fl) Splay.insert(ans + 1, inf);
fl = 0;
int l, r;
scanf("%d%d", &l, &r);
int st = Splay.FIND(l);
int ed = Splay.FIND(r);
if (ed > ans) {
ans++;
fl = 1;
}
Splay.remove(ed);
if (ed > st) Splay.add(st, ed - 1);
Splay.insert(st, l);
}
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int num[36];
vector<long long> temp1;
vector<long long> temp2;
void solveFirst(int idx, long long sum) {
if (idx == n / 2) {
temp1.push_back(sum % m);
return;
}
solveFirst(idx + 1, (sum + num[idx]) % m);
solveFirst(idx + 1, sum);
return;
}
void solveSecond(int idx, long long sum) {
if (idx == n) {
temp2.push_back(sum % m);
return;
}
solveSecond(idx + 1, (sum + num[idx]) % m);
solveSecond(idx + 1, sum);
return;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) scanf("%d", &num[i]), num[i] %= m;
solveFirst(0, 0);
solveSecond(n / 2, 0);
long long maxSum = 0;
sort(temp2.begin(), temp2.end());
for (int i = 0; i < temp1.size(); i++) {
vector<long long>::iterator it =
lower_bound(temp2.begin(), temp2.end(), m - temp1[i] - 1);
if (it == temp2.end()) it--;
maxSum = max(maxSum, (temp1[i] + *it) % m);
it--;
maxSum = max(maxSum, (temp1[i] + *it) % m);
}
cout << maxSum;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int s1;
int s2;
vector<long long int> v;
long long int p[2];
set<long long int> vv[2];
bool contain(pair<long long int, long long int> a, long long int x) {
return a.first <= x && x <= a.second;
}
inline bool ok(long long int dist) {
vv[0].clear();
vv[1].clear();
p[0] = s1;
p[1] = s2;
vv[0].insert(s2);
vv[1].insert(s1);
for (int i = 0; i < v.size(); i++) {
vector<long long int> add[2];
for (int j = 0; j < 2; j++) {
if (abs(v[i] - p[j]) <= dist) {
if (vv[j].size()) {
add[j ^ true].push_back(p[j]);
}
}
pair<long long int, long long int> nxt_valid_range =
make_pair(v[i] - dist, v[i] + dist);
while (vv[j].size() &&
contain(nxt_valid_range, (*vv[j].begin())) == false) {
vv[j].erase(vv[j].begin());
}
while (vv[j].size() &&
contain(nxt_valid_range, (*vv[j].rbegin())) == false) {
vv[j].erase(*vv[j].rbegin());
}
}
for (int j = 0; j < 2; j++) {
for (auto el : add[j]) {
vv[j].insert(el);
}
}
p[0] = p[1] = v[i];
}
if (vv[0].size() || vv[1].size()) {
return true;
}
return false;
}
int main() {
cin >> n >> s1 >> s2;
for (int i = 0; i < n; i++) {
long long int x;
scanf("%lld", &x);
v.push_back(x);
}
long long int mint = max(s2 - s1, s1 - s2);
long long int maxt = 1000000000LL;
while (mint + 1LL < maxt) {
long long int mid = (mint + maxt) / 2LL;
if (ok(mid)) {
maxt = mid;
} else {
mint = mid;
}
}
if (ok(mint)) {
printf("%lld\n", mint);
} else {
printf("%lld\n", maxt);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
int ans;
if (n & 1) {
ans = n / 2;
cout << ans << endl;
int turn = 1;
int i = 0, j = n / 2;
while (i < n / 2 || j < n) {
if (turn == 1) {
cout << a[j] << " ";
turn = 0;
j++;
} else {
cout << a[i] << " ";
turn = 1;
i++;
}
}
} else {
cout << n / 2 - 1 << endl;
int turn = 1, i = 0, j = n / 2 - 1;
while (i < n / 2 - 1 && j < n) {
if (turn == 1) {
cout << a[j] << " ";
turn = 0;
j++;
} else {
cout << a[i] << " ";
turn = 1;
i++;
}
}
for (int i = j; i < n; i++) cout << a[i] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, k, l, c, d, p, nl, np;
cin >> n >> k >> l >> c >> d >> p >> nl >> np;
long long a = (k * l) / nl;
long long b = c * d;
long long e = p / np;
long long ans = min(a, b);
ans = min(ans, e);
cout << (long long)(ans / n);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 305;
struct node {
int x, y;
} a[N], e[N * N];
int n, i, j, k, cnt;
long long f[N][N][10], ans;
node operator-(node a, node b) { return (node){a.x - b.x, a.y - b.y}; }
long long mult(node a, node b) { return 1ll * a.x * b.y - 1ll * a.y * b.x; }
int xx(node a) {
if (a.x > 0) {
if (a.y > 0)
return 1;
else
return 4;
} else {
if (a.y > 0)
return 2;
else
return 3;
}
}
bool cmp(node p, node q) {
node g = a[p.y] - a[p.x], h = a[q.y] - a[q.x];
int xx1 = xx(g), xx2 = xx(h);
if (xx1 != xx2) return xx1 < xx2;
return mult(g, h) > 0;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d%d", &a[i].x, &a[i].y);
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j)
if (i != j) e[++cnt] = (node){i, j};
sort(e + 1, e + 1 + cnt, cmp);
for (i = 1; i <= cnt; ++i) {
f[e[i].x][e[i].y][1]++;
for (j = 1; j <= n; ++j)
for (k = 1; k <= 4; ++k) {
f[j][e[i].y][k + 1] += f[j][e[i].x][k] * f[e[i].x][e[i].y][1];
}
}
for (i = 1; i <= n; ++i) ans += f[i][i][5];
printf("%lld", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t = 1;
while (t--) solve();
}
void solve() {
long long n, a = 0, b = 0, x;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> x;
long long l = x / 2, r = x / 2;
if (x % 2 == 1) l++;
if (i % 2 == 0)
a += l, b += r;
else
a += r, b += l;
}
cout << min(a, b) << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
long long int a[100005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
bool pani = 0;
long long int shakti = 0;
long long int ghaas = 0;
long long int waqt = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
cin >> s;
int i = 1;
for (auto j : s) {
if (j == 'L') {
waqt += a[i];
if (shakti - a[i] < 0) {
if (pani)
waqt += (a[i] - shakti) * 3;
else
waqt += (a[i] - shakti) * 5;
}
shakti -= a[i];
shakti = max(shakti, 0ll);
} else if (j == 'W') {
pani = 1;
shakti += a[i];
waqt += a[i] * 3;
} else {
ghaas += 2 * a[i];
shakti += a[i];
waqt += a[i] * 5;
}
ghaas = min(ghaas, shakti);
i++;
}
if (shakti) {
waqt -= 4 * ghaas / 2;
waqt -= 2 * (shakti - ghaas) / 2;
}
cout << waqt << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
int x1, x2, y1, y2, z = abs(x) + abs(y);
if (x > 0) {
x1 = z;
y1 = 0;
} else {
x1 = -z;
y1 = 0;
}
if (y > 0) {
x2 = 0;
y2 = z;
} else {
x2 = 0;
y2 = -z;
}
if (x1 < x2)
cout << x1 << " " << y1 << " " << x2 << " " << y2 << endl;
else
cout << x2 << " " << y2 << " " << x1 << " " << y1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Li = 1e7;
int y[Li];
int main() {
int n, r = 0, a, b, c, d = 1;
int x[3];
cin >> n >> x[0] >> x[1] >> x[2];
sort(x, x + 3);
a = x[0];
b = x[1];
c = x[2];
for (int i = 0; i <= n / a; i++) {
for (int j = 0; j <= n / b; j++) {
r = n - (i * a) - (j * b);
if (r % c == 0 && r >= 0) d = max(d, i + j + (r / c));
}
}
cout << d;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, M, Q, P;
vector<string> cityMatrix;
vector<vector<int>> noiseMatrix;
void bfs(int x, int y, int noise) {
queue<pair<pair<int, int>, int>> q;
vector<vector<bool>> used(N, vector<bool>(M, false));
q.push({{x, y}, noise});
while (!q.empty()) {
auto curr = q.front();
q.pop();
int x_c = curr.first.first;
int y_c = curr.first.second;
int noise_c = curr.second;
if (used[x_c][y_c] || noise_c == 0 || cityMatrix[x_c][y_c] == '*') continue;
used[x_c][y_c] = true;
noiseMatrix[x_c][y_c] += noise_c;
noise_c /= 2;
if (x_c - 1 >= 0) q.push({{x_c - 1, y_c}, noise_c});
if (x_c + 1 < N) q.push({{x_c + 1, y_c}, noise_c});
if (y_c - 1 >= 0) q.push({{x_c, y_c - 1}, noise_c});
if (y_c + 1 < M) q.push({{x_c, y_c + 1}, noise_c});
}
}
int main() {
cin >> N >> M >> Q >> P;
cityMatrix.resize(N);
noiseMatrix.resize(N, vector<int>(M));
for (int i = 0; i < N; ++i) {
getline(cin >> ws, cityMatrix[i]);
}
for (int x = 0; x < N; ++x)
for (int y = 0; y < M; ++y)
if ('A' <= cityMatrix[x][y] && cityMatrix[x][y] <= 'Z')
bfs(x, y, (cityMatrix[x][y] - 'A' + 1) * Q);
int res = 0;
for (int x = 0; x < N; ++x) {
for (int y = 0; y < M; ++y) {
if (noiseMatrix[x][y] > P) ++res;
}
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[100];
int main() {
int n, p, q = 0, ans = 0, i;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
p = n - 1;
for (i = n - 1; i >= 0; i--) {
if (a[i] >= a[p]) {
p = i;
}
}
ans += (p - 0);
for (i = 0; i < n; i++) {
if (a[i] <= a[q]) {
q = i;
}
}
if (q < p) {
q++;
}
ans += (n - 1 - q);
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, ans = 0;
int numa[26] = {0}, numb[26] = {0};
char a[1010], b[1010];
cin >> a >> b;
int la = strlen(a), lb = strlen(b);
for (i = 0; i < la; i++)
if ((a[i] >= 97) && (a[i] <= 97 + 25)) numa[a[i] - 97]++;
for (i = 0; i < lb; i++)
if ((b[i] >= 97) && (b[i] <= 97 + 25)) numb[b[i] - 97]++;
for (i = 0; i < 26; i++)
if ((numa[i] == 0) && (numb[i] != 0)) {
ans = -1;
break;
} else
ans += min(numa[i], numb[i]);
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, flag = 0;
char ch[100001];
cin >> ch;
int len = strlen(ch);
for (i = 0; i < len; i++) {
if (ch[i] != 'a') {
flag = 1;
ch[i]--;
} else {
if (flag == 1) break;
}
}
if (flag == 0) ch[len - 1] = 'z';
cout << ch;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s[200005];
namespace FastIO {
const int L = 1 << 20;
char buf[L], *S, *T;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
void reads(int id) {
s[id] = "";
char c = getchar();
while (c < 'a' || 'z' < c) c = getchar();
while ('a' <= c && c <= 'z') s[id] += c, c = getchar();
}
} // namespace FastIO
using FastIO::read;
using FastIO::reads;
int n, m, all, etot, qtot, h[200005], loc[200005];
struct Edge {
int to, next;
} a[200005];
struct query {
int type, r, k, id;
} g[500005 << 1];
bool cmp(const query &x, const query &y) { return x.r < y.r; }
void Add(int x, int y) {
etot++;
a[etot].to = y;
a[etot].next = h[x];
h[x] = etot;
}
inline int Newnode() { return ++all; }
struct Trie {
int bj, fail, ch[26];
} tr[200005];
void Insert(int id) {
int len = s[id].length(), now = 1;
for (int i = 0; i < len; ++i) {
int &v = tr[now].ch[s[id][i] - 'a'];
if (!v) v = Newnode();
now = v;
}
tr[now].bj++;
loc[id] = now;
}
void Build() {
queue<int> q;
for (int i = 0; i < 26; ++i) tr[0].ch[i] = 1;
q.push(1);
while (!q.empty()) {
int x = q.front(), fail = tr[x].fail;
q.pop();
Add(fail, x);
for (int i = 0; i <= 25; ++i) {
int &y = tr[x].ch[i];
if (!y)
y = tr[fail].ch[i];
else
tr[y].fail = tr[fail].ch[i], q.push(y);
}
}
}
int step, dfn[200005], siz[200005];
long long ans[500005 << 1], c[200005];
void dfs(int x) {
dfn[x] = ++step;
siz[x] = 1;
for (int i = h[x]; i; i = a[i].next) dfs(a[i].to), siz[x] += siz[a[i].to];
}
void add(int x) {
for (; x <= all; x += x & -x) c[x]++;
}
long long sum(int x) {
long long s = 0;
for (; x; x -= x & -x) s += c[x];
return s;
}
void Modify(int id) {
int len = s[id].length(), now = 1;
for (int i = 0; i < len; ++i) {
now = tr[now].ch[s[id][i] - 'a'];
add(dfn[now]);
}
}
int main() {
n = read();
m = read();
all = 1;
for (int i = 1; i <= n; ++i) reads(i), Insert(i);
Build();
dfs(1);
for (int i = 1; i <= m; ++i) {
int l = read(), r = read(), k = read();
g[++qtot] = (query){1, r, k, i};
if (l > 1) g[++qtot] = (query){-1, l - 1, k, i};
}
sort(g + 1, g + qtot + 1, cmp);
int o = 0;
for (int i = 1; i <= qtot; ++i) {
int x = loc[g[i].k];
while (o + 1 <= g[i].r) Modify(o + 1), o++;
ans[g[i].id] += g[i].type * (sum(dfn[x] + siz[x] - 1) - sum(dfn[x] - 1));
}
for (int i = 1; i <= m; ++i) cout << ans[i] << '\n';
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int ch[26];
int main() {
int n, k;
string str, str2;
cin >> n >> k;
cin >> str;
getchar();
char ans[n - k];
str2 = str;
if (k == n) {
return 0;
}
sort(str2.begin(), str2.end());
for (int i = k; i < n; i++) {
ch[str2[i]]++;
}
int cnt = n - k - 1;
for (int i = n; i >= 0; i--) {
if (ch[str[i]] > 0) {
ans[cnt--] = str[i];
ch[str[i]]--;
}
}
for (int i = 0; i < n - k; i++) cout << ans[i];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
vector<int> stck;
int main() {
ios_base::sync_with_stdio(false);
int n, a;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
stck.push_back(a);
}
int curr = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> a;
ans = 0;
if (mp[a] > 0) {
cout << "0 ";
continue;
}
while (curr < n) {
mp[stck[curr]] = 1;
if (stck[curr] == a) {
ans++;
curr++;
break;
} else {
curr++;
ans++;
}
}
cout << ans << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<long long> arr(n);
set<long long> check;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
check.insert(arr[i]);
}
if (check.size() == n) {
cout << 0 << endl;
return 0;
} else if (check.size() == 1) {
cout << n - 1 << endl;
return 0;
}
set<long long> a;
long long mi = n;
for (long long i = 0; i < n; i++) {
set<long long> s;
if (i > 0) {
s = a;
}
for (long long j = n - 1; j >= i; j--) {
if (j != (n - 1)) {
s.insert(arr[j + 1]);
if (s.size() == (n - (j - i + 1))) {
mi = min(mi, j - i + 1);
}
} else {
if (s.size() == (n - (j - i + 1))) {
mi = min(mi, (j - i + 1));
}
}
}
a.insert(arr[i]);
}
cout << mi << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
string s, t;
cin >> s >> t;
if (accumulate(begin(s), end(s), 0) != accumulate(begin(t), end(t), 0)) {
cout << -1 << '\n';
return 0;
}
{
string ns, nt;
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) {
ns.push_back(s[i]);
nt.push_back(t[i]);
}
}
s = ns;
t = nt;
n = s.size();
}
if (n == 0) {
cout << "0\n";
return 0;
}
vector<int> arr = {1};
for (int i = 1; i < n; i++) {
if (s[i] == s[i - 1])
arr.back()++;
else
arr.push_back(1);
}
if (arr.size() > 2 && s[0] == s.back()) {
arr[0] += arr.back();
arr.pop_back();
}
int ans = 0;
while (arr.size()) {
ans++;
n = arr.size();
for (int& val : arr) val--;
vector<int> nxt;
for (int i = 0; i < n; i++) {
if (i + 1 == n) {
if (arr[i]) {
nxt.push_back(arr[i]);
}
} else {
if (arr[i] == 0 && arr[i + 1] == 0) {
i++;
} else if (arr[i] > 0 && arr[i + 1] > 0) {
nxt.push_back(arr[i]);
nxt.push_back(arr[i + 1]);
i++;
} else if (arr[i] == 0) {
if (nxt.size()) {
nxt.back() += arr[i + 1];
} else {
nxt.push_back(arr[i + 1]);
}
i++;
} else {
nxt.push_back(arr[i]);
}
}
}
if (nxt.size() & 1) {
nxt[0] += nxt.back();
nxt.pop_back();
}
arr = nxt;
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 3e5 + 10;
int main() {
vector<vector<pair<int, int> > > arr(4);
vector<int> a, b, c;
map<int, int> visit;
int n, m, x, d[5] = {0, 0, 0, 0};
scanf("%d", &n);
for (int j = 0; j < 3; j++) {
for (int i = 0; i < n; i++) {
scanf("%d", &x);
if (j == 0) a.push_back(x);
if (j == 1) b.push_back(x);
if (j == 2) c.push_back(x);
}
}
for (int i = 0; i < n; i++) {
arr[b[i] - 1].push_back(make_pair(a[i], i));
if (b[i] != c[i]) arr[c[i] - 1].push_back(make_pair(a[i], i));
}
for (int i = 0; i < 3; i++) {
if (arr[i].size() > 1) sort(arr[i].begin(), arr[i].end());
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &x);
x--;
if (d[x] < arr[x].size()) {
while (visit[arr[x][d[x]].second]) {
d[x]++;
if (d[x] >= arr[x].size()) break;
}
visit[arr[x][d[x]].second]++;
}
if (d[x] >= arr[x].size())
cout << "-1";
else
cout << arr[x][d[x]].first;
if (i != m - 1) cout << " ";
d[x]++;
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int a, b;
cin >> a >> b;
cout << min(a, b) << " " << (max(a, b) - min(a, b)) / 2;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j + 1 < m; j++)
if (s[i][j] != s[i][j + 1]) {
cout << "NO\n";
return 0;
}
}
for (int i = 0; i + 1 < n; i++)
if (s[i][0] == s[i + 1][0]) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long qpow(long long a, long long b, long long m) {
long long r = 1;
a %= m;
for (; b; b >>= 1) {
if (b & 1) r = r * a % m;
a = a * a % m;
}
return r;
}
const int inf = 0x7fffffff;
queue<string> que;
set<string> s;
int n, k;
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
string a;
cin >> a;
que.push(a);
s.insert(a);
int ans = 0;
while (!que.empty()) {
string b = que.front();
que.pop();
for (int i = 0; i < (int)(b).size(); i++) {
string c = b;
c.erase(i, 1);
if (!s.count(c) && (int)(s).size() < k) {
ans += n - (int)c.length();
s.insert(c);
que.push(c);
}
}
}
if ((int)(s).size() < k) {
cout << -1 << endl;
return 0;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
long long int a[100];
long long int c[100];
vector<long long int> l;
long long int lcm(long long int n, long long int m) {
long long int s = n * m;
while (m > 0) {
long long int tmp = m;
m = n % m;
n = tmp;
}
return s / n;
}
int main() {
scanf("%lld", &n);
for (long long int i = 0; i < n; i++) {
scanf("%lld", &c[i]);
c[i]--;
}
for (long long int i = 0; i < n; i++)
if (a[i] == 0) {
long long int p = i;
long long int tmp = 0;
do {
if (a[p] != 0) {
printf("-1\n");
return 0;
}
a[p] = l.size() + 1;
tmp++;
p = c[p];
} while (p != i);
l.push_back(tmp);
}
long long int t = 1;
for (int i = 0; i < l.size(); i++)
if ((l[i] & 1) == 0)
t = lcm(t, l[i] >> 1);
else
t = lcm(t, l[i]);
printf("%lld\n", t);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
const double EPS = 1e-9;
const int MOD = 100000007;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, -1, 0, 1};
int n, d;
int dp[30010][510];
int gem[30010];
int main() {
scanf("%d %d", &n, &d);
for (int i = 0; i < 30010; i++) {
for (int j = 0; j < 510; j++) {
dp[i][j] = -1;
}
}
for (int i = 0; i < n; i++) {
int c;
scanf("%d", &c);
gem[c]++;
}
dp[d][250] = gem[d];
for (int i = d; i < 30000; i++) {
for (int j = 0; j <= 500; j++) {
if (dp[i][j] != -1) {
for (int k = -1; k <= 1; k++) {
int jump = d + j - 250 + k;
if (jump > 0 && i + jump <= 30000) {
dp[i + jump][j + k] =
max(dp[i + jump][j + k], dp[i][j] + gem[i + jump]);
}
}
}
}
}
int res = 0;
for (int i = d; i <= 30000; i++) {
for (int j = 0; j <= 500; j++) {
res = max(res, dp[i][j]);
}
}
cout << res << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 5;
string s = "@";
long long n, a[MAXN], dp[MAXN][5];
inline long long Min(long long w, long long x, long long y, long long z) {
return min(min(w, x), min(y, z));
}
inline long long mIn(long long x, long long y, long long z) {
return min(x, min(y, z));
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
string tmp;
cin >> tmp;
s += tmp;
for (long long i = 1; i <= n; i++) cin >> a[i];
long long lastd = -1;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j <= 4; j++) dp[i + 1][j] = dp[i][j];
if (s[i] == 'h') {
dp[i + 1][0] = dp[i][0] + a[i];
dp[i + 1][1] = min(dp[i][0], dp[i][1]);
}
if (s[i] == 'a') {
dp[i + 1][1] = dp[i][1] + a[i];
dp[i + 1][2] = min(dp[i][1], dp[i][2]);
}
if (s[i] == 'r') {
dp[i + 1][2] = dp[i][2] + a[i];
dp[i + 1][3] = min(dp[i][2], dp[i][3]);
}
if (s[i] == 'd') {
lastd = i;
dp[i + 1][3] = dp[i][3] + a[i];
dp[i + 1][4] = min(dp[i][3], dp[i][4]);
}
}
if (lastd == -1) {
cout << 0 << endl;
return 0;
}
cout << Min(dp[lastd + 1][0], dp[lastd + 1][1], dp[lastd + 1][2],
dp[lastd + 1][3]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const int N = 6e5 + 7;
const long long INF = 1e18 + 7;
pair<long long, long long> a[N], b[N];
int n, m, us[N];
long long solve(int x) {
long long s = 0;
for (int i = 1; i <= n; i++) s += abs(a[i + x].first - b[i].first);
return s;
}
int main() {
cin >> m >> n;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i].first);
a[i].second = i;
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &b[i].first);
b[i].second = i;
}
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
for (int i = 1; i <= 3 * n; i++) {
if (i <= n)
a[i].first -= m;
else {
a[i] = a[i - n];
a[i].first += m;
}
}
int l = 0, r = 2 * n;
while (l < r) {
int mid = (l + r) >> 1;
if (solve(mid) < solve(mid + 1))
r = mid;
else
l = mid + 1;
}
cout << solve(l) << endl;
for (int i = 1; i <= n; i++) us[a[i + l].second] = b[i].second;
for (int i = 1; i <= n; i++) cout << us[i] << ' ';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
int n, m, a[MAXN], l[310], r[310];
int ans, wh;
vector<int> t, be[MAXN], ed[MAXN];
struct node {
int l, r, MAX, MIN, sum, lazy;
} sh[MAXN * 4];
void pushup(int x) {
sh[x].sum = sh[x + x].sum + sh[x + x + 1].sum;
sh[x].MAX = max(sh[x + x].MAX, sh[x + x + 1].MAX);
sh[x].MIN = min(sh[x + x].MIN, sh[x + x + 1].MIN);
}
void pushdown(int x) {
if (sh[x].lazy != 0) {
sh[x + x].lazy += sh[x].lazy;
sh[x + x + 1].lazy += sh[x].lazy;
sh[x + x].sum += sh[x].lazy;
sh[x + x].MAX += sh[x].lazy;
sh[x + x].MIN += sh[x].lazy;
sh[x + x + 1].sum += sh[x].lazy;
sh[x + x + 1].MAX += sh[x].lazy;
sh[x + x + 1].MIN += sh[x].lazy;
sh[x].lazy = 0;
}
}
void build(int x, int ll, int rr) {
sh[x].l = ll;
sh[x].r = rr;
if (ll == rr) {
sh[x].MAX = sh[x].MIN = sh[x].sum = a[ll];
return;
}
int mid;
mid = (ll + rr) >> 1;
build(x + x, ll, mid);
build(x + x + 1, mid + 1, rr);
pushup(x);
}
void change(int x, int ll, int rr, int k) {
if (sh[x].l >= ll && sh[x].r <= rr) {
sh[x].sum += k;
sh[x].MIN += k;
sh[x].MAX += k;
sh[x].lazy += k;
return;
}
pushdown(x);
int mid;
mid = (sh[x].l + sh[x].r) >> 1;
if (ll <= mid) change(x + x, ll, rr, k);
if (rr > mid) change(x + x + 1, ll, rr, k);
pushup(x);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) scanf("%d%d", &l[i], &r[i]);
build(1, 1, n);
if (n == 1) {
printf("0\n0\n");
return 0;
}
for (int i = 1; i <= m; i++) {
be[l[i]].push_back(i);
ed[r[i]].push_back(i);
}
ans = sh[1].MAX - sh[1].MIN;
wh = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (int)ed[i - 1].size(); j++) {
int u;
u = ed[i - 1][j];
change(1, l[u], r[u], 1);
}
for (int j = 0; j < (int)be[i].size(); j++) {
int u;
u = be[i][j];
change(1, l[u], r[u], -1);
}
pushdown(1);
pushup(1);
if (sh[1].MAX - sh[1].MIN > ans) {
ans = sh[1].MAX - sh[1].MIN;
wh = i;
}
}
for (int i = 1; i <= m; i++) {
if (l[i] <= wh && r[i] >= wh) t.push_back(i);
}
printf("%d\n%d\n", ans, (int)t.size());
for (int i = 0; i < (int)t.size(); i++) printf("%d ", t[i]);
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
int t;
cin >> t;
for (int tt = 0; tt < (t); ++tt) {
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = 0; i < (n); ++i) cin >> a[i];
for (int i = 0; i < (n); ++i) cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
for (int i = 0; i < (n); ++i) cout << a[i] << " ";
cout << '\n';
for (int i = 0; i < (n); ++i) cout << b[i] << " ";
cout << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t = 1;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n], b[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < n; i++) {
cin >> b[i];
}
sort(a, a + n);
sort(b, b + n);
for (long long i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
for (long long i = 0; i < n; i++) {
cout << b[i] << " ";
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, MOD = 1000000007;
int a[N];
struct mat {
long long f[2][2];
mat() { memset(f, 0, sizeof f); }
mat(int _q, int _w, int _e, int _r) {
f[0][0] = _q;
f[0][1] = _w;
f[1][0] = _e;
f[1][1] = _r;
}
mat operator+(mat a) {
mat c;
for (int i = (0); i < (2); i++)
for (int j = (0); j < (2); j++) c.f[i][j] = (f[i][j] + a.f[i][j]) % MOD;
return c;
}
mat operator*(mat a) {
mat c;
for (int i = (0); i < (2); i++)
for (int j = (0); j < (2); j++)
for (int k = (0); k < (2); k++)
c.f[i][j] = (c.f[i][j] + f[i][k] * a.f[k][j]) % MOD;
return c;
}
mat operator^(long long n) {
if (n == 0) return mat(1, 1, 1, 0);
if (n == 1) return (*this);
mat c = (*this) ^ (n / 2);
c = c * c;
return (n & 1) ? c * (*this) : c;
}
};
struct stree {
struct {
mat c, lz = mat(1, 0, 0, 1);
} t[N * 4];
void lz_upd(int node) {
mat v = t[node].lz;
t[(node << 1)].lz = t[(node << 1)].lz * v;
t[(node << 1)].c = t[(node << 1)].c * v;
t[((node << 1) | 1)].lz = t[((node << 1) | 1)].lz * v;
t[((node << 1) | 1)].c = t[((node << 1) | 1)].c * v;
t[node].lz = mat(1, 0, 0, 1);
}
void build(int node, int l, int r) {
if (l == r) {
t[node].c = mat(1, 1, 1, 0) ^ a[l];
return;
}
build((node << 1), l, ((l + r) >> 1));
build(((node << 1) | 1), ((l + r) >> 1) + 1, r);
t[node].c = t[(node << 1)].c + t[((node << 1) | 1)].c;
}
void update(int node, int l, int r, int u, int v, mat x) {
if (u > r || v < l) return;
if (l >= u && r <= v) {
t[node].lz = t[node].lz * x;
t[node].c = t[node].c * x;
return;
}
lz_upd(node);
update((node << 1), l, ((l + r) >> 1), u, v, x);
update(((node << 1) | 1), ((l + r) >> 1) + 1, r, u, v, x);
t[node].c = t[(node << 1)].c + t[((node << 1) | 1)].c;
}
int ask(int node, int l, int r, int u, int v) {
if (u > r || v < l) return 0;
if (l >= u && r <= v) return t[node].c.f[0][1];
lz_upd(node);
return (ask((node << 1), l, ((l + r) >> 1), u, v) +
ask(((node << 1) | 1), ((l + r) >> 1) + 1, r, u, v)) %
MOD;
}
};
stree it;
int main() {
int n, m, t, x, y, v;
scanf("%d%d", &n, &m);
for (int i = (1); i < (n + 1); i++) scanf("%d", &a[i]);
it.build(1, 1, n);
while (m--) {
scanf("%d%d%d", &t, &x, &y);
if (t == 1) {
scanf("%d", &v);
it.update(1, 1, n, x, y, mat(1, 1, 1, 0) ^ v);
} else {
printf("%d\n", it.ask(1, 1, n, x, y));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
long long n, d;
cin >> n >> d;
long long x[100000][2];
for (int i = 0; i < n; i++) {
cin >> x[i][0] >> x[i][1];
}
qsort(x, n, sizeof(*x), [](const void *arg1, const void *arg2) -> int {
int const *lhs = static_cast<int const *>(arg1);
int const *rhs = static_cast<int const *>(arg2);
return (lhs[0] < rhs[0])
? -1
: ((rhs[0] < lhs[0])
? 1
: (lhs[1] < rhs[1] ? -1 : ((rhs[1] < lhs[1] ? 1 : 0))));
});
int j = 1;
long long f = x[0][1], ans = 0;
for (int i = 0; i < n; i++) {
while (j < n && x[j][0] - x[i][0] < d) {
f += x[j][1];
j++;
}
if (ans < f) ans = f;
f -= x[i][1];
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int md = (int)1e9 + 7;
long long dp[2][51][51];
long long step[2][51][51];
long long c[55][55];
int num50 = 0, num100 = 0;
struct node {
int side;
int cnt50;
int cnt100;
node(int i, int j, int k) {
side = i;
cnt50 = j;
cnt100 = k;
}
};
queue<node> que;
int main() {
for (int i = 0; i <= 50; i++) {
c[i][0] = 1;
}
for (int i = 1; i <= 50; i++) {
for (int j = 1; j <= 50; j++) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % md;
}
}
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
int tmp;
scanf("%d", &tmp);
if (tmp == 50)
num50++;
else if (tmp == 100)
num100++;
}
step[1][num50][num100] = 0;
dp[1][num50][num100] = 1;
que.push(node(1, num50, num100));
while (!que.empty()) {
node q = que.front();
que.pop();
int side_now = q.side;
int cnt50_now = q.cnt50;
int cnt100_now = q.cnt100;
int side_next = 1 - side_now;
for (int i = 0; i <= cnt50_now; i++) {
for (int j = 0; j <= cnt100_now; j++) {
if (i == 0 && j == 0 || i * 50 + j * 100 > k) continue;
int cnt50_next = num50 - (cnt50_now - i);
int cnt100_next = num100 - (cnt100_now - j);
if (step[side_next][cnt50_next][cnt100_next] == 0) {
step[side_next][cnt50_next][cnt100_next] =
step[side_now][cnt50_now][cnt100_now] + 1;
dp[side_next][cnt50_next][cnt100_next] +=
(c[cnt50_now][i] * c[cnt100_now][j] % md *
dp[side_now][cnt50_now][cnt100_now] % md);
dp[side_next][cnt50_next][cnt100_next] %= md;
que.push(node(side_next, cnt50_next, cnt100_next));
} else if (step[side_next][cnt50_next][cnt100_next] ==
step[side_now][cnt50_now][cnt100_now] + 1) {
dp[side_next][cnt50_next][cnt100_next] +=
(c[cnt50_now][i] * c[cnt100_now][j] % md *
dp[side_now][cnt50_now][cnt100_now] % md);
dp[side_next][cnt50_next][cnt100_next] %= md;
}
}
}
}
if (step[0][num50][num100] == 0) {
printf("-1\n0\n");
} else {
printf("%lld\n%lld\n", step[0][num50][num100], dp[0][num50][num100]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int A[2 * n + 5];
for (int i = 0; i < 2 * n; i++) cin >> A[i];
sort(A, A + 2 * n);
int cnt = 0;
int mid = 2 * n / 2;
for (int i = 0, k = (2 * n) - 1; i < mid; i++, k--) {
if (A[i] >= A[k]) {
cnt = 1;
break;
}
}
if (cnt == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
long long a = 0, b = 0;
vector<int> vec1(1, 0), vec2(1, 0);
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
vec1.push_back(x);
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
vec2.push_back(x);
}
sort(vec1.begin(), vec1.end());
sort(vec2.begin(), vec2.end());
for (int i = 0; i < n * 2; i++) {
if (i % 2 == 0) {
if (vec1[vec1.size() - 1] > vec2[vec2.size() - 1]) {
a += vec1[vec1.size() - 1];
vec1.pop_back();
} else {
vec2.pop_back();
}
} else {
if (vec2[vec2.size() - 1] > vec1[vec1.size() - 1]) {
b += vec2[vec2.size() - 1];
vec2.pop_back();
} else {
vec1.pop_back();
}
}
}
cout << a - b << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d, sum, rank = 1;
cin >> n;
cin >> a >> b >> c >> d;
sum = a + b + c + d;
for (int i = 1; i < n; i++) {
cin >> a >> b >> c >> d;
if ((a + b + c + d) > sum) rank++;
}
cout << rank << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
string second, a[4], b[4], an;
int p[N], n;
void ask(int i) {
cout << "? " << a[i] << endl;
fflush(stdout);
cin >> b[i];
}
void guess() {
cout << "! " << an << endl;
fflush(stdout);
}
int main() {
cin >> second;
n = second.size();
for (int i = 1; i <= 3; i++) a[i].resize(n);
an.resize(n);
for (int i = 0; i <= n - 1; i++) {
a[1][i] = 'a' + i % 26;
a[2][i] = 'a' + (i / 26) % 26;
a[3][i] = 'a' + (i / (26 * 26)) % 26;
}
ask(1);
ask(2);
ask(3);
for (int i = 0; i <= n - 1; i++) {
p[i] = (b[1][i] - 'a') + (b[2][i] - 'a') * 26 + (b[3][i] - 'a') * 26 * 26;
}
for (int i = 0; i <= n - 1; i++) {
an[p[i]] = second[i];
}
guess();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<string> pos;
int main() {
string str;
while (cin >> str) {
pos.clear();
for (int i = 0; i < str.size(); i++) {
string flag = str.substr(i, 5);
if (flag == "heavy") {
pos.push_back("h");
i += 4;
} else if (flag == "metal") {
pos.push_back("m");
i += 4;
}
}
long long count = 0;
long long ans = 0;
for (int i = pos.size() - 1; i >= 0; i--) {
if (pos[i] == "m")
count++;
else
ans += count;
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
const double inf = ~0u >> 2;
char s[112];
int a[550];
int main() {
int i, j, k;
gets(s);
k = strlen(s);
int ans = 0;
int kt = 0;
for (i = 0; i < k; i++) {
int x = s[i];
int y = kt;
int g = 0;
kt = 0;
memset(a, 0, sizeof(a));
while (y) {
a[g++] = y % 2;
y /= 2;
}
for (j = 0; j < 8; j++) kt += pow(2, 8 - j - 1) * a[j];
memset(a, 0, sizeof(a));
g = 0;
while (x) {
a[g++] = x % 2;
x /= 2;
}
int ans = 0;
for (j = 0; j < 8; j++) ans += pow(2, 8 - j - 1) * a[j];
kt = (kt - ans + 256) % 256;
cout << kt << endl;
kt = s[i];
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
vector<long long> threes;
long long cnt = 1;
threes.push_back(1);
while (cnt <= 38) {
long long x = pow(3, cnt);
cnt++;
threes.push_back(x + threes[threes.size() - 1]);
}
while (q--) {
long long x;
cin >> x;
long long ans = 0;
while (x != 0) {
for (int i = 0; i < threes.size(); i++) {
if (x >= pow(3, i) && x <= threes[i]) {
ans += pow(3, i);
x -= pow(3, i);
break;
}
if (pow(3, i) >= x) {
ans += pow(3, i);
x = 0;
break;
}
}
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename T, typename U>
inline void amin(T &a, U b) {
a = (a > b ? b : a);
}
template <typename T, typename U>
inline void amax(T &a, U b) {
a = (a > b ? a : b);
}
map<int, int> res;
void solve() {
int n, k;
cin >> n >> k;
vector<int64_t> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
int q;
cin >> q;
while (q--) {
int z, s = -1;
cin >> z;
for (int i = 0; i < n; ++i) {
if (z % a[i] == 0 && z / a[i] <= k) {
if (s == -1)
s = z / a[i];
else
amin(s, z / a[i]);
do {
} while (0);
}
}
for (int i = 0; i < n; ++i) {
int y = z;
for (int x = 1; x <= k; ++x) {
y -= a[i];
do {
} while (0);
if (y < 0) continue;
if (y == 0) {
if (s == -1)
s = x;
else
amin(s, x);
continue;
}
for (int j = 1; j + x <= k; ++j) {
if (y % j) continue;
int rem = (y / j);
auto it = lower_bound(a.begin(), a.end(), rem);
if (it == a.end()) continue;
if (*it == rem) {
if (s == -1)
s = j + x;
else
amin(s, j + x);
}
}
}
}
cout << s << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tests = 1;
while (tests--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using namespace std;
int main() {
ll n;
cin >> n;
set<ll> funvs;
for (ll d = 1; d * d <= n; d++) {
if (n % d != 0) continue;
ll m = n / d;
funvs.insert(d * (m * (m - 1)) / 2 + m);
m = n / (n / d);
if (d * d != n) funvs.insert((n / d) * (m * (m - 1)) / 2 + m);
}
vector<ll> v(funvs.begin(), funvs.end());
for (ll& x : v) cout << x << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; };
void check_max(int &a, int b) { a = max(a, b); }
void check_min(int &a, int b) { a = min(a, b); }
const int maxn = 3e5 + 10;
int t;
vector<int> v[maxn];
int ans[maxn];
void solve() {
int n;
scanf("%d", &n);
for (int i = 0; i <= maxn; ++i) {
ans[i] = 0x3f3f3f3f, v[i].clear();
}
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
v[x].push_back(i);
}
for (int i = 1; i <= n; ++i) {
if (v[i].empty()) continue;
int dis = max(n - v[i].back() + 1, v[i].front());
for (int j = 1; j < v[i].size(); j++) check_max(dis, v[i][j] - v[i][j - 1]);
check_min(ans[dis], i);
}
for (int i = 2; i <= n; ++i) check_min(ans[i], ans[i - 1]);
for (int i = 1; i <= n; ++i) {
if (ans[i] == 0x3f3f3f3f)
printf("-1 ");
else
printf("%d ", ans[i]);
}
printf("\n");
}
int main() {
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int m, n, j, k, l, i, o, p;
long long up[10000], need[1000];
struct q {
long long tot, price;
} A[1000];
bool cmp(q a, q b) { return a.price < b.price; }
char ch;
void read(int &a) {
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
;
for (a = ch - '0', ch = getchar(); ch >= '0' && ch <= '9'; ch = getchar())
a = a * 10 + ch - '0';
}
long long min2(long long a, long long b) { return (a < b) ? (a) : (b); }
int main() {
scanf("%d", &m);
for (int i = 1; i <= m; i++) cin >> A[i].tot >> A[i].price;
sort(A + 1, A + 1 + m, cmp);
cin >> n;
for (int i = 1; i <= n; i++) cin >> up[i], need[i] = up[i] - up[i - 1];
n++;
up[n] = 1000000000000000LL;
need[n] = up[n] - up[n - 1];
long long ret = 0;
for (int i = 1, j = 1; i <= m; i++) {
for (; A[i].tot > 0;) {
long long res = min2(need[j], A[i].tot);
A[i].tot -= res;
ret += ((long long)j) * res * A[i].price;
need[j] -= res;
if (need[j] == 0) j++;
}
}
cout << ret << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 11;
map<string, int> ID;
int a[maxn], b[maxn], n, m;
int main() {
ios::sync_with_stdio(0);
while (cin >> n >> m) {
memset(b, 0, sizeof b);
ID.clear();
int cnt = 0;
string str;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) {
cin >> str;
if (ID.count(str) == 0) ID[str] = ++cnt;
b[ID[str]]++;
}
sort(b + 1, b + 1 + cnt, greater<int>());
sort(a + 1, a + 1 + n);
long long ans1 = 0;
for (int i = 1; i <= cnt; i++) ans1 += 1ll * b[i] * a[i];
long long ans2 = 0;
sort(a + 1, a + 1 + n, greater<int>());
for (int i = 1; i <= cnt; i++) ans2 += 1ll * b[i] * a[i];
cout << ans1 << " " << ans2 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 9;
const int inf = 0x3f3f3f3f;
string s;
int solve(char x, char y) {
string now = s;
int l = now.size();
int a = now.rfind(y);
if (a != -1) now.erase(a, 1);
int b = now.rfind(x);
if (b != -1) now.erase(b, 1);
if (a == -1 || b == -1) return inf;
int cnt = 0;
for (int i = 0; i < l; i++) {
if (now[i] == '0')
cnt++;
else
break;
}
return l - 2 - a + l - 1 - b + cnt;
}
int main() {
cin >> s;
int l = s.size();
int _50 = solve('5', '0');
int _00 = solve('0', '0');
int _25 = solve('2', '5');
int _75 = solve('7', '5');
int ans = min(min(min(_50, _00), _25), _75);
if (ans == inf)
printf("-1\n");
else
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, pair<pair<int, int>, double> > > data;
double e[1024];
double func() {
for (unsigned i = 0; i < data.size(); ++i) {
double hoge = 0;
for (unsigned j = 0; j < i; ++j) {
long long dt = data[i].first - data[j].first;
long long dx = data[i].second.first.first - data[j].second.first.first;
long long dy = data[i].second.first.second - data[j].second.first.second;
if (dx * dx + dy * dy <= dt * dt) {
hoge = max(hoge, e[j]);
}
}
e[i] = hoge + data[i].second.second;
}
double r = 0;
for (unsigned i = 0; i < data.size(); ++i) {
r = max(r, e[i]);
}
return r;
}
int main() {
int n;
cin >> n;
data.resize(n);
for (int i = 0; i < n; ++i) {
cin >> data[i].second.first.first >> data[i].second.first.second >>
data[i].first >> data[i].second.second;
}
sort(data.begin(), data.end());
printf("%.10f\n", func());
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
bool Finish_read;
template <class T>
inline void read(T &x) {
Finish_read = 0;
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
if (ch == EOF) return;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
Finish_read = 1;
}
template <class T>
inline void print(T x) {
if (x / 10 != 0) print(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void writeln(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
putchar('\n');
}
template <class T>
inline void write(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
}
int n, tot, tmp, num[205], num2;
int cutk[1505];
char st[400005];
struct pa {
char ch;
int num;
} xx, rem[400005];
queue<pa> cnt1, cnt2;
inline void works(int len) {
tmp = n / len;
writeln(tmp);
for (int k = 1; k <= tmp; k++) {
int t = 0, tk = len / 2;
while (tk) {
xx = cnt2.front(), cnt2.pop();
if (xx.num > tk) {
xx.num -= tk;
rem[++t].ch = xx.ch, rem[t].num = tk;
tk = 0, cnt2.push(xx);
} else {
tk -= xx.num;
rem[++t].ch = xx.ch, rem[t].num = xx.num;
}
}
for (int i = 1; i <= t; i++)
for (int j = 1; j <= rem[i].num; j++) putchar(rem[i].ch);
if (len % 2) {
if (!cnt1.empty())
xx = cnt1.front(), cnt1.pop(), putchar(xx.ch);
else {
xx = cnt2.front(), cnt2.pop(), putchar(xx.ch), xx.num--;
cnt1.push(xx);
if (xx.num) cnt2.push(xx);
}
}
for (int i = t; i >= 1; i--)
for (int j = 1; j <= rem[i].num; j++) putchar(rem[i].ch);
if (k != tmp) putchar(' ');
}
}
int main() {
read(n);
scanf("%s", st);
tmp = sqrt(n) + 1;
for (int i = 1; i <= tmp; i++)
if (n % i == 0) {
cutk[++tot] = i;
cutk[++tot] = n / i;
}
sort(cutk + 1, cutk + tot + 1);
for (int i = 0; i < n; i++) num[(int)st[i]]++;
for (int i = 0; i <= 150; i++)
if (num[i]) {
if (num[i] / 2) {
xx.ch = i;
xx.num = num[i] / 2;
cnt2.push(xx);
num2 += xx.num;
}
if (num[i] % 2) {
xx.ch = i;
xx.num = 1;
cnt1.push(xx);
}
}
for (int i = tot; i >= 1; i--)
if ((cutk[i] / 2) * (n / cutk[i]) <= num2) {
works(cutk[i]);
break;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111111;
const double EPS = 1e-8;
struct Point {
int x, y;
Point(int a = 0, int b = 0) : x(a), y(b) {}
void read() { scanf("%d%d", &x, &y); }
};
Point operator-(const Point &a, const Point &b) {
return Point(a.x - b.x, a.y - b.y);
}
long long det(const Point &a, const Point &b) {
return (long long)a.x * b.y - (long long)a.y * b.x;
}
long long dot(const Point &a, const Point &b) {
return (long long)a.x * b.x + (long long)a.y * b.y;
}
double ang(const Point &a, const Point &b) {
return atan2(det(a, b), dot(a, b));
}
int n;
Point p[N];
bool isInside(const Point &o) {
double tmp = 0;
for (int i = 0; i < n; ++i) {
tmp += ang(p[i] - o, p[(i + 1) % n] - o);
}
return abs(tmp) > EPS;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
p[i].read();
}
int t;
scanf("%d", &t);
while (t--) {
Point o;
o.read();
if (isInside(o)) {
long long result = (long long)n * (n - 1) * (n - 2) / 6;
int j = 1;
for (int i = 0; i < n; ++i) {
while (det(p[j] - p[i], o - p[i]) < 0) {
j = (j + 1) % n;
}
int total = j - i;
if (total < 0) {
total += n;
}
result -= (long long)(total - 1) * (total - 2) / 2;
}
cout << result << endl;
} else {
cout << 0 << endl;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int quick(long long int a, long long int k) {
long long int ans = 1;
while (k) {
if (k & 1) ans = ans * a % 1000000007;
a = a * a % 1000000007;
k >>= 1;
}
return ans;
}
int main() {
long long int k, p, q;
cin >> k >> p >> q;
long long int dp[k + 1][k + 1];
for (long long int i = k; i >= 0; i--) {
for (long long int j = k; j >= 0; j--) {
if (i == k)
dp[i][j] = k;
else if ((i + j) >= k) {
long long int x = quick(q, 1000000007 - 2);
long long int a = (x * p) % 1000000007;
dp[i][j] = (i + j + a) % 1000000007;
} else {
long long int x = (p * dp[i][j + 1] + q * dp[i + j][j]) % 1000000007;
long long int y = quick(p + q, 1000000007 - 2);
x = (x * y) % 1000000007;
dp[i][j] = x;
}
}
}
cout << dp[0][1];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int suff[1000010], x[200010], y[200010];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> x[i];
suff[x[i]]++;
}
for (int i = 200000; i > 0; --i) suff[i] += suff[i + 1];
long long ans = 0;
for (int i = 0; i < n; ++i) {
long long sum = 0;
if (!y[x[i]]) {
for (int j = x[i]; j <= 200000; j += x[i]) {
sum += (long long)j * (suff[j] - suff[j + x[i]]);
}
ans = max(ans, sum);
y[x[i]] = sum;
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
int ch = 0, f = 0;
x = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
if (f) x = -x;
}
const int N = 1000005;
vector<int> g[N], e[N];
int f[N][26], s[N][26], c[N], sum[N], id[N], fa[N], dep[N], n, q, lover;
inline void dfs(int u) {
int tot = 0;
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i];
dfs(v), tot++, id[u] = id[v];
if (dep[u] == -1)
dep[u] = dep[v] + 1;
else if (dep[u] != dep[v] + 1) {
while (q--) puts("Fou");
exit(0);
}
}
if (dep[u] == -1) dep[u] = 0;
if (tot != 1) {
id[u] = u;
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i];
e[id[u]].push_back(id[v]), fa[id[v]] = u;
}
}
}
inline void gao(int u, int c) {
lover -= sum[u] > dep[u];
sum[u] -= f[u][c];
f[u][c] = 0;
for (int i = 0; i < (int)e[u].size(); i++)
f[u][c] = max(f[u][c], f[e[u][i]][c] + s[e[u][i]][c]);
sum[u] += f[u][c];
lover += sum[u] > dep[u];
if (u) gao(fa[u], c);
}
int main() {
memset(dep, -1, sizeof(dep));
read(n), read(q);
for (int i = 2, x; i <= n; i++) {
read(x), c[i] = getchar();
g[x].push_back(i);
}
dfs(1);
e[0].push_back(id[1]), fa[id[1]] = 0;
for (int i = 2; i <= n; i++)
if (c[i] != '?') {
s[id[i]][c[i] - 'a']++;
gao(fa[id[i]], c[i] - 'a');
}
while (q--) {
int x;
read(x);
if (c[x] != '?') s[id[x]][c[x] - 'a']--, gao(fa[id[x]], c[x] - 'a');
c[x] = getchar();
if (c[x] != '?') s[id[x]][c[x] - 'a']++, gao(fa[id[x]], c[x] - 'a');
if (lover)
puts("Fou");
else {
int res = 0;
for (int i = 0; i < 26; i++) res += (i + 1) * (f[0][i] + dep[1] - sum[0]);
printf("Shi %d\n", res);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int t, nrm, w;
string s;
char a;
int main() {
cin >> s;
for (int i = 0; i < s.size(); ++i) {
a = s[i];
if (a == 'F') {
if (nrm && nrm + w > t) t = nrm + w;
if (nrm) ++w;
} else {
if (w > 0) --w;
++nrm;
}
}
cout << t;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, r, l, c, typ;
char s[100005];
int main() {
scanf("%d%d%d", &n, &m, &k);
m += k;
scanf(" %s", s + 1);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d%d", &typ, &l, &r, &c);
if (typ == 1)
memset(s + l, c + 48, r - l + 1);
else {
if (memcmp(s + l, s + l + c, r - l - c + 1) == 0)
printf("YES\n");
else
printf("NO\n");
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int k = 0;
int n;
cin >> n;
int A[n];
for (int i = 0; i < n; i++) cin >> A[i];
for (int i = 0; i < 12; i++) {
bool a = true;
k = 0;
for (int j = 0, ii = i; j < n; j++, ii++) {
if (A[j] == 29 && m[ii] == 28) {
if (!k) {
k = 1;
continue;
} else {
a = false;
break;
}
}
if (ii == 12) ii = 0;
if (A[j] != m[ii]) {
a = false;
break;
}
}
if (a) return cout << "Yes", 0;
}
cout << "No";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, team = 0;
cin >> a >> b;
while (a != 0 && b != 0 && max(a, b) > 1) {
if (a >= b) {
a -= 2;
b -= 1;
team++;
} else if (b > a) {
b -= 2;
a -= 1;
team++;
}
}
cout << team << endl;
}
| 2 |
#include <bits/stdc++.h>
const int MAXN = 1e5 + 5;
struct SegmentTree {
int sm[MAXN << 2], tag[MAXN << 2];
inline void cover(int x, int l, int r, int d) {
sm[x] |= d;
tag[x] |= d;
}
inline void pushdown(int x, int l, int r) {
if (tag[x]) {
int mid = (l + r) >> 1;
cover(((x) << 1), l, mid, tag[x]);
cover(((x) << 1 | 1), mid + 1, r, tag[x]);
tag[x] = 0;
}
}
inline void modify(int x, int l, int r, int L, int R, int d) {
if (l == L && r == R) {
cover(x, l, r, d);
return;
}
int mid = (l + r) >> 1;
pushdown(x, l, r);
if (R <= mid)
modify(((x) << 1), l, mid, L, R, d);
else if (L > mid)
modify(((x) << 1 | 1), mid + 1, r, L, R, d);
else
modify(((x) << 1), l, mid, L, mid, d),
modify(((x) << 1 | 1), mid + 1, r, mid + 1, R, d);
}
inline int calc(int x, int l, int r, int p) {
if (l == r) return sm[x];
int mid = (l + r) >> 1;
pushdown(x, l, r);
return p <= mid ? calc(((x) << 1), l, mid, p)
: calc(((x) << 1 | 1), mid + 1, r, p);
}
} seg;
int n, m;
int ans[MAXN];
int ad[MAXN << 2];
inline void build(int x, int l, int r) {
if (l == r) {
ad[x] = ans[l];
return;
}
int mid = (l + r) >> 1;
build(((x) << 1), l, mid);
build(((x) << 1 | 1), mid + 1, r);
ad[x] = ad[((x) << 1)] & ad[((x) << 1 | 1)];
}
inline int query(int x, int l, int r, int L, int R) {
if (l == L && r == R) return ad[x];
int mid = (l + r) >> 1;
if (R <= mid)
return query(((x) << 1), l, mid, L, R);
else if (L > mid)
return query(((x) << 1 | 1), mid + 1, r, L, R);
else
return query(((x) << 1), l, mid, L, mid) &
query(((x) << 1 | 1), mid + 1, r, mid + 1, R);
}
int ll[MAXN], rr[MAXN], xx[MAXN];
int main() {
scanf("%d%d", &n, &m);
for (register int i = 1; i <= m; ++i) {
int l, r, x;
scanf("%d%d%d", &l, &r, &x);
ll[i] = l;
rr[i] = r;
xx[i] = x;
seg.modify(1, 1, n, l, r, x);
}
for (register int i = 1; i <= n; ++i) {
int t = seg.calc(1, 1, n, i);
ans[i] = t;
}
build(1, 1, n);
for (register int i = 1; i <= m; ++i) {
if (query(1, 1, n, ll[i], rr[i]) != xx[i]) {
puts("NO");
return 0;
}
}
puts("YES");
for (register int i = 1; i <= n; ++i) printf("%d ", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e18;
const long long mod = (long long)1e9 + 7;
const double eps = (double)1e-9;
const double pi = acos(-1.0);
const int dx[] = {0, 0, 1, 0, -1};
const int dy[] = {0, 1, 0, -1, 0};
const int N = 300500;
int n, k, sdv;
string second;
int main() {
cin >> n >> k;
cin >> second;
if (n % 2 == 0) {
bool ok = 1;
for (int i = 1; i < n; ++i)
if (second[i] == second[i - 1]) ok = 0;
if (ok) {
if (k % 2 == 1) {
for (int i = 0; i < n; ++i)
if (second[i] == 'W')
second[i] = 'B';
else
second[i] = 'W';
}
cout << second << endl;
return 0;
}
}
if (second[0] != second[n - 1]) {
int r = 1;
while (second[r] != second[r - 1]) r++;
sdv = r;
second = second.substr(r, second.size() - r) + second.substr(0, r);
}
for (int i = 1; i + 1 < n; ++i) {
if (second[i] == second[i - 1]) continue;
int r = i;
while (r + 1 < n && second[r] != second[r - 1]) r++;
for (int L = i, R = r - 1, j = 0; L <= R && j < k; j++, L++, R--) {
second[L] = second[i - 1], second[R] = second[r];
}
if (k % 2 == 1) {
for (int j = i + k; j <= r - 1 - k; ++j)
if (second[j] == 'W')
second[j] = 'B';
else
second[j] = 'W';
}
i = r;
}
if (sdv)
second = second.substr(second.size() - sdv, sdv) +
second.substr(0, second.size() - sdv);
cout << second << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, r;
cin >> n >> k;
queue<pair<int, int>> q;
for (int i = 0; i < n; i++) {
cin >> r;
q.push({r, i + 1});
}
int a[k], b[k], in[n + 1], ans = 0, np = 0, sc = 0, c[k];
memset(in, 0, sizeof(in));
for (int i = 0; i < k && !q.empty(); i++) {
b[i] = q.front().first;
a[i] = 0;
c[i] = q.front().second;
q.pop();
}
while (sc < n) {
for (int i = 0; i < k; i++) {
a[i]++;
if (a[i] == b[i]) {
if (!q.empty()) {
b[i] = q.front().first;
a[i] = 0;
c[i] = q.front().second;
q.pop();
sc++;
np = int(100.0 * sc / n + 0.5);
} else {
a[i] = 1;
b[i] = 0;
c[i] = 0;
sc++;
np = int(100.0 * sc / n + 0.5);
}
}
}
for (int i = 0; i < k; i++) {
if (np == a[i] + 1 && np != 0) {
in[c[i]] = 1;
}
}
}
for (int i = 1; i <= n; i++)
if (in[i] == 1) ans++;
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
bool first_comparator(const std::pair<int64_t, size_t>& left,
const std::pair<int64_t, size_t>& right) {
return left.first < right.first;
}
int main() {
std::ios_base::sync_with_stdio(false);
int64_t m;
size_t n;
std::cin >> m >> n;
std::vector<std::pair<int64_t, size_t>> data[2];
for (auto& item : data) {
item.resize(n);
for (size_t j = 0; j < n; ++j) {
std::cin >> item[j].first;
item[j].second = j;
}
std::sort(item.begin(), item.end());
}
std::vector<int64_t> score(2 * n + 1);
for (size_t i = 0; i < n; ++i) {
score[0] += m - data[0][i].first + data[1][i].first;
score[i + 1] -= m;
score[i + n + 1] += m;
auto a_wait = n - static_cast<size_t>(std::distance(
data[1].begin(),
std::lower_bound(data[1].begin(), data[1].end(),
data[0][i], first_comparator)));
score[i + 1 + a_wait] += 2 * data[0][i].first;
auto b_wait = static_cast<size_t>(std::distance(
data[0].begin(), std::upper_bound(data[0].begin(), data[0].end(),
data[1][i], first_comparator)));
score[((n - 1) - i) + 1 + b_wait] -= 2 * data[1][i].first;
}
int64_t min_score = score[0], curr_score = score[0];
size_t min_i = 0;
for (size_t i = 1; i < score.size(); ++i) {
curr_score += score[i];
if (curr_score < min_score) {
min_score = curr_score;
min_i = i;
}
}
std::vector<size_t> mapping(n);
for (size_t i = 0; i < n; ++i) {
mapping[data[0][i].second] = data[1][(i + 3 * n - min_i) % n].second;
}
std::cout << min_score << "\n";
for (size_t i = 0; i < n; ++i) {
std::cout << (mapping[i] + 1) << " ";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
double y1, y2, yw, xb, yb, r;
cin >> y1 >> y2 >> yw >> xb >> yb >> r;
double x = xb * (yw - 2 * r - y1) / (2 * yw - 3 * r - yb - y1);
cout.precision(20);
if ((y2 - y1 - r) * sin(atan(x / (yw - 2 * r - y1))) > r)
cout << x << endl;
else
cout << -1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, num[3];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num[0] >> num[1] >> num[2];
sort(num, num + 3);
if (num[2] > num[0] + 1) {
num[2]--;
num[0]++;
} else if (num[2] == num[0] + 1)
num[2]--;
cout << 2 * (num[2] - num[0]) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
set<int> st;
vector<int> vec;
map<int, int> mp;
map<int, int>::iterator it;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int val;
cin >> val;
st.insert(val);
vec.push_back(val);
mp[val]++;
}
if (st.size() == n) {
cout << "1"
<< " " << n << endl;
return 0;
}
int m = 0;
for (it = mp.begin(); it != mp.end(); ++it) {
m = max(m, it->second);
}
cout << m << " " << mp.size() << endl;
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.