solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, n, p = 0;
cin >> a >> b >> n;
while (a <= n && b <= n) {
if (a > b)
b = b + a;
else
a = a + b;
p++;
}
cout << p << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, l;
int tow[5001];
int minc[5001];
int minv[5001];
int main(int argc, char** argv) {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> tow[i];
}
int cmin = n;
int sum = 0;
bool poss = false;
for (int i = 1; i <= n; ++i) {
cmin = n;
sum = 0;
poss = false;
int j = 0;
while ((!poss) && (j < i)) {
sum += tow[i - j];
if (sum >= minv[i - j - 1]) {
cmin = j + minc[i - j - 1];
poss = true;
}
j += 1;
}
minc[i] = cmin;
minv[i] = sum;
}
cout << minc[n];
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T>
using Table = vector<vector<T>>;
const ld eps = 1e-9;
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> v) {
os << "( " << v.first << ", " << v.second << ")";
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << " ";
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<set<T>> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &v) {
int i = 0;
for (auto it : v) {
if (i > 0) {
os << ' ';
}
os << it;
i++;
}
return os;
}
using ll = long long int;
ll get_sum(ll x) {
vector<int> v(19);
ll amin = 1;
ll min_cnt = 1;
ll amax = min(9ll, x);
ll max_cnt = min(9ll, x);
ll sum = 0;
ll xx = 9;
for (int keta = 1; keta < 19; ++keta) {
ll asum = (min_cnt + max_cnt) * (amax - amin + 1) / 2;
sum += asum;
amin *= 10;
amax = amax * 10 + 9;
if (amax > x) amax = x;
if (amin > x) break;
min_cnt = max_cnt + keta + 1;
max_cnt = max_cnt + (keta + 1) * (amax - amin + 1);
}
return sum;
}
int solve(ll place) {
if (place <= 9) return place;
place--;
ll aten = 1;
for (int keta = 1; keta < 20; ++keta) {
if (aten * 9 * keta <= place) {
place -= aten * keta * 9;
aten *= 10;
} else {
ll num = place / keta + aten;
ll xx = place % keta;
string st = to_string(num);
return st[xx] - '0';
}
}
return -1;
}
int main() {
ios::sync_with_stdio(false);
vector<int> vs(2e5 + 1);
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
int a;
cin >> a;
vs[a]++;
}
int sum = 0;
int al = -1;
pair<int, pair<int, int>> answer = make_pair(0, make_pair(0, 0));
for (int i = 0; i < vs.size(); ++i) {
if (vs[i] == 0) {
answer = max(answer, make_pair(sum, make_pair(al, i)));
sum = 0;
al = i + 1;
} else if (vs[i] == 1) {
sum += 1;
answer = max(answer, make_pair(sum, make_pair(al, i + 1)));
sum = 1;
al = i;
} else {
sum += vs[i];
answer = max(answer, make_pair(sum, make_pair(al, i + 1)));
}
}
cout << answer.first << endl;
vector<int> v;
for (int k = answer.second.first; k < answer.second.second; ++k) {
v.push_back(k);
}
for (int k = answer.second.second - 1; k >= answer.second.first; --k) {
for (int t = 1; t < vs[k]; ++t) {
v.push_back(k);
}
}
for (int i = 0; i < v.size(); ++i) {
cout << v[i] << ' ';
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, n, t, k, flag = 0, cnt, sum = 0, x, m, maxi, mini;
cin >> n;
set<long long int> st;
set<long long int> stt;
vector<long long int> v;
for (i = 0; i < n; i++) {
cin >> x;
if (st.size() == 0 && x < 0) {
flag = 1;
break;
} else if (st.size() == 0 && x > 0) {
st.insert(x);
stt.insert(x);
sum++;
} else if (x > 0 && st.find(x) == st.end() && stt.find(x) != stt.end()) {
flag = 1;
break;
} else if (x > 0 && st.find(x) == st.end() && stt.find(x) == stt.end()) {
st.insert(x);
stt.insert(x);
sum++;
} else if (x > 0 && st.find(x) != st.end()) {
flag = 1;
break;
} else if (x < 0 && st.find(-1 * x) == st.end()) {
flag = 1;
break;
} else if (x < 0 && st.find(-1 * x) != st.end())
st.erase(-1 * x);
if (st.size() == 0) {
v.push_back(2 * sum);
sum = 0;
stt.clear();
}
}
if (stt.size() != 0) flag = 1;
if (flag == 1)
cout << -1 << endl;
else {
cout << v.size() << endl;
for (auto it = v.begin(); it != v.end(); it++) cout << *it << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, x, y, h, m;
scanf("%d%d%d%d%d:%d", &a, &x, &b, &y, &h, &m);
m += h * 60;
h = 0;
a = 300;
while (a < m + x && a < 1440) {
if (a + y > m) h++;
a += b;
}
cout << h << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
int a[N];
struct node {
int x, y, z;
};
vector<node> cnt;
int main() {
int t;
cin >> t;
while (t--) {
int n, sum = 0, ans = 0;
cnt.clear();
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
if (sum % n == 0) {
int x, av = sum / n;
for (int i = 2; i <= n; i++) {
if (a[i] % i == 0) {
x = a[i] / i;
a[1] += a[i];
cnt.push_back({i, 1, x});
ans++;
} else {
x = a[i] % i;
a[1] -= i - x;
cnt.push_back({1, i, i - x});
x = (a[i] + i - x) / i;
a[1] += (a[i] + i - x);
cnt.push_back({i, 1, x});
ans += 2;
}
}
for (int i = 2; i <= n; i++) {
cnt.push_back({1, i, av});
ans++;
}
cout << ans << endl;
for (auto i : cnt) printf("%d %d %d\n", i.x, i.y, i.z);
} else
puts("-1");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, res, ans = 0;
printf("? ");
x = 127;
for (int i = 0; i < 100; i++) {
printf("%d ", x);
x += 128;
}
printf("\n");
fflush(stdout);
scanf("%d", &res);
for (int i = 0; i < 7; i++) {
if ((res | (1 << i)) > res) ans += (1 << i);
}
printf("? ");
x = 16256;
for (int i = 0; i < 100; i++) {
printf("%d ", x++);
}
printf("\n");
fflush(stdout);
scanf("%d", &res);
for (int i = 7; i < 14; i++) {
if ((res | (1 << i)) > res) ans += (1 << i);
}
printf("! %d\n", ans);
fflush(stdout);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxint = -1u >> 1;
const string mas[] = {"lios", "etr", "initis"};
const string fem[] = {"liala", "etra", "inites"};
const int maxn = 100000 + 10;
pair<int, int> rec[maxn];
string word;
int n;
bool check() {
if (n == 1) {
return rec[0].first >= 0;
}
int sta = -1, step = 0;
for (int i = 0; i < n; ++i) {
if (rec[i].first == -1) return false;
if (sta < 0) sta = rec[i].first;
if (sta != rec[i].first) return false;
if (step == 0) {
if (rec[i].second == 2) return false;
step = rec[i].second;
} else if (step == 1) {
if (rec[i].second <= 1) return false;
step = rec[i].second;
} else if (step == 2) {
if (rec[i].second <= 1) return false;
}
}
if (step == 0) return false;
return true;
}
bool has(const string &word, const string &key) {
if (word.size() < key.size()) return false;
for (int i = 0; i < ((int)(key).size()); ++i) {
if (word[word.size() - key.size() + i] != key[i]) return false;
}
return true;
}
pair<int, int> type(const string &word) {
for (int i = 0; i < 3; ++i) {
if (has(word, mas[i])) return make_pair(0, i);
if (has(word, fem[i])) return make_pair(1, i);
}
return make_pair(-1, 0);
}
int main() {
n = 0;
while (cin >> word) {
rec[n++] = type(word);
}
bool flag = check();
if (flag)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[200009];
long long f[200009][2], n, T;
void upd(long long x, long long v, long long t) {
while (x <= n) {
f[x][t] += v;
x += (x & -x);
}
}
long long cnt(long long x, long long v) {
long long ans = 0;
while (x) {
ans += f[x][v];
x -= (x & -x);
}
return ans;
}
long long Cnt(long long l, long long C, long long t) {
if (!C) return 0;
long long r = l + C - 1;
r = (r - 1) % n + 1;
if (l + C - 1 <= n) return cnt(r, t) - cnt(l - 1, t);
return cnt(n, t) - cnt(l - 1, t) + cnt(r, t);
}
int main() {
cin >> n >> T;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
upd(i, a[i], 0);
upd(i, 1, 1);
}
long long cr = 1;
long long ans = 0;
while (T) {
long long S = cnt(n, 0), C = cnt(n, 1);
if (!S) break;
ans += (T / S) * C;
T %= S;
long long lo = 0, hi = n - 1;
while (lo < hi) {
long long mid = (lo + hi + 1) / 2;
if (Cnt(cr, mid, 0) <= T)
lo = mid;
else
hi = mid - 1;
}
ans += Cnt(cr, lo, 1);
T -= Cnt(cr, lo, 0);
cr = cr + lo;
cr = (cr - 1) % n + 1;
upd(cr, -a[cr], 0);
upd(cr, -1, 1);
cr = cr % n + 1;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
inline int rd() {
int x = 0, p = 1;
char a = getchar();
while ((a < 48 || a > 57) && a != '-') a = getchar();
if (a == '-') p = -p, a = getchar();
while (a > 47 && a < 58) x = (x << 1) + (x << 3) + (a & 15), a = getchar();
return x * p;
}
inline long long max(long long x, long long y) { return x > y ? x : y; }
const int N = 200002;
int n, q;
int d[N], h[N];
long long s[N];
int lg[N];
long long f1[N][25], f2[N][25];
int p1[N][25], p2[N][25];
inline int query1(int l, int r) {
int x = lg[r - l + 1];
if (f1[l][x] > f1[r - (1 << x) + 1][x])
return p1[l][x];
else
return p1[r - (1 << x) + 1][x];
}
inline int query2(int l, int r) {
int x = lg[r - l + 1];
if (f2[l][x] < f2[r - (1 << x) + 1][x])
return p2[l][x];
else
return p2[r - (1 << x) + 1][x];
}
inline long long calc(int l, int r) {
return s[l] + 2ll * h[l] - s[r] + 2ll * h[r];
}
inline long long query(int l, int r) {
int x = query1(l, r), y = query2(l, r);
if (x != y)
return calc(x, y);
else {
if (x == l && x == r) return 0;
if (x > l && x < r)
return max(max(calc(query1(l, x - 1), x), calc(query1(x + 1, r), x)),
max(calc(x, query2(l, x - 1)), calc(x, query2(x + 1, r))));
if (x == l)
return max(calc(query1(x + 1, r), x), calc(x, query2(x + 1, r)));
if (x == r)
return max(calc(query1(l, x - 1), x), calc(x, query2(l, x - 1)));
}
}
int main() {
n = rd(), q = rd();
for (int i = 1; i <= n; i++) d[i] = d[i + n] = rd();
for (int i = 1; i <= n; i++) h[i] = h[i + n] = rd();
for (int i = 1; i <= n + n; i++) s[i + 1] = s[i] + d[i];
lg[0] = -1;
for (int i = 1; i <= n + n; i++) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= n + n; i++)
f1[i][0] = s[i] + 2ll * h[i], f2[i][0] = s[i] - 2ll * h[i],
p1[i][0] = p2[i][0] = i;
for (int j = 1; j <= lg[n + n]; j++)
for (int i = 1; i + (1 << (j - 1)) <= n + n; i++) {
if (f1[i][j - 1] > f1[i + (1 << (j - 1))][j - 1]) {
f1[i][j] = f1[i][j - 1];
p1[i][j] = p1[i][j - 1];
} else {
f1[i][j] = f1[i + (1 << (j - 1))][j - 1];
p1[i][j] = p1[i + (1 << (j - 1))][j - 1];
}
if (f2[i][j - 1] < f2[i + (1 << (j - 1))][j - 1]) {
f2[i][j] = f2[i][j - 1];
p2[i][j] = p2[i][j - 1];
} else {
f2[i][j] = f2[i + (1 << (j - 1))][j - 1];
p2[i][j] = p2[i + (1 << (j - 1))][j - 1];
}
}
while (q--) {
int L = rd(), R = rd(), l, r;
l = R + 1, r = L - 1;
if (L <= R) r += n;
printf("%lld\n", query(l, r));
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
struct str {
long long int x0;
long long int y0;
long long int count;
} query[2010];
int t = 1;
str makeQuery(long long int a, long long int b, long long int c) {
str A;
A.x0 = a;
A.y0 = b;
A.count = c;
return A;
}
int main() {
int a, b;
long long int c, d, e;
scanf("%d", &a);
for (int i = 1; i <= a; i++) {
scanf("%d", &b);
if (b == 1) {
scanf("%I64d%I64d%I64d", &c, &d, &e);
long long int c2, d2;
c2 = c, d2 = d;
while (c2 != d2) {
if (c2 > d2)
c2 /= 2;
else
d2 /= 2;
}
query[t++] = makeQuery(c2, c, e);
query[t++] = makeQuery(d2, d, e);
} else if (b == 2) {
scanf("%I64d%I64d", &c, &d);
long long int c2, d2;
long long int ans = 0;
c2 = c, d2 = d;
while (c2 != d2) {
if (c2 > d2)
c2 /= 2;
else
d2 /= 2;
}
for (int j = 1; j < t; j++) {
long long int p = query[j].y0;
long long int q = c;
while (p != q) {
if (p > q)
p /= 2;
else
q /= 2;
}
while (p > query[j].x0 && p > c2) ans += query[j].count, p /= 2;
}
for (int j = 1; j < t; j++) {
long long int p = query[j].y0;
long long int q = d;
while (p != q) {
if (p > q)
p /= 2;
else
q /= 2;
}
while (p > query[j].x0 && p > c2) ans += query[j].count, p /= 2;
}
printf("%I64d\n", ans);
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int num[1000][1000];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x1, x2, y1, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
for (int i = x1; i <= x2; i++) {
for (int j = y1; j <= y2; j++) {
num[i][j]++;
}
}
}
int ans = 0;
for (int i = 1; i <= 100; i++) {
for (int j = 1; j <= 100; j++) {
ans += num[i][j];
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 1000;
int siz[maxn], son[maxn], dep[maxn], flag = 0;
int xor_sum[maxn];
int cnt[1 << 22];
int ans[maxn];
vector<pair<int, int> > g[maxn];
void predfs(int u, int fa) {
siz[u] = 1;
dep[u] = dep[fa] + 1;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first;
int k = g[u][i].second;
if (v == fa) continue;
xor_sum[v] = xor_sum[u] ^ k;
predfs(v, u);
siz[u] += siz[v];
if (siz[v] > siz[son[u]]) {
son[u] = v;
}
}
}
void cal(int u, int fa, int lca, int val) {
if (cnt[xor_sum[u]])
ans[lca] = max(ans[lca], cnt[xor_sum[u]] + dep[u] - 2 * dep[lca]);
for (int i = 0; i <= 21; i++)
if (cnt[xor_sum[u] ^ (1 << i)])
ans[lca] =
max(ans[lca], cnt[xor_sum[u] ^ (1 << i)] + dep[u] - 2 * dep[lca]);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first;
if (v == fa || v == flag) continue;
cal(v, u, lca, val);
}
}
void add(int u, int fa, int val) {
cnt[xor_sum[u]] = max(cnt[xor_sum[u]], dep[u]);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first;
if (v == fa || v == flag) continue;
add(v, u, val);
}
}
void del(int u, int fa, int val) {
cnt[xor_sum[u]] = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first;
if (v == fa || v == flag) continue;
del(v, u, val);
}
}
void dfs(int u, int fa, bool keep) {
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first;
if (v == fa || v == son[u]) continue;
dfs(v, u, 0);
ans[u] = max(ans[u], ans[v]);
}
if (son[u]) {
dfs(son[u], u, 1);
flag = son[u];
ans[u] = max(ans[u], ans[son[u]]);
}
cnt[xor_sum[u]] = max(cnt[xor_sum[u]], dep[u]);
ans[u] = max(ans[u], cnt[xor_sum[u]] - dep[u]);
for (int i = 0; i <= 21; i++)
if (cnt[xor_sum[u] ^ (1 << i)])
ans[u] = max(ans[u], cnt[xor_sum[u] ^ (1 << i)] - dep[u]);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first;
if (v == fa || v == flag) continue;
cal(v, u, u, 1);
add(v, u, 1);
}
flag = 0;
if (keep == 0) {
del(u, fa, -1);
}
}
int main(void) {
int n;
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int x;
char str;
scanf("%d %c", &x, &str);
g[x].push_back({i, (1 << (str - 'a'))});
g[i].push_back({x, (1 << (str - 'a'))});
}
predfs(1, 0);
dfs(1, 0, 0);
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
printf("\n");
return 0;
}
| 10 |
#include <bits/stdc++.h>
int main() {
int _;
for (scanf("%d", &_); _; _--) {
long long int a, b, c;
scanf("%lld%lld%lld", &a, &b, &c);
printf("%lld\n", a + b + c - 1);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using cat = long long;
cat sz[82] = {1, 2};
pair<int, int> solve_pair(cat x, int k) {
if (x == 0) return {0, (k + 1) / 2};
if (x == sz[k] - 1) return {(k + 1) / 2, 0};
if (x >= sz[k - 1]) {
pair<int, int> prev = solve_pair(x - sz[k - 1], k - 2);
prev.first++;
return prev;
}
pair<int, int> prev = solve_pair(x, k - 1);
return {min(prev.first, prev.second + 2),
min(prev.first, prev.second) + (k + 1) / 2};
}
int solve(cat a, cat b, int k) {
if (a > b) swap(a, b);
if (a == b) return 0;
if (k == 1) return 1;
while (sz[k - 2] > b) k--;
if (a == 0 && b == sz[k] - 1) return (k + 1) / 2;
if (a >= sz[k - 1]) return solve(a - sz[k - 1], b - sz[k - 1], k - 2);
if (b >= sz[k - 1] && a < sz[k - 1]) {
pair<int, int> d_a = solve_pair(a, k - 1);
pair<int, int> d_b = solve_pair(b - sz[k - 1], k - 2);
return min(d_a.first, d_a.second) + d_b.first + 1;
} else {
int d0 = solve(a, b, k - 1);
pair<int, int> d_a = solve_pair(a, k - 1);
pair<int, int> d_b = solve_pair(b, k - 1);
return min(d0, min(d_a.first + d_b.second, d_a.second + d_b.first) + 2);
}
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
int T, N;
cin >> T >> N;
N = min(N, 81);
for (int i = 2; i <= 81; i++) sz[i] = sz[i - 1] + sz[i - 2];
while (T--) {
cat a, b;
cin >> a >> b;
cout << solve(a - 1, b - 1, N) << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 5;
long long int arr[mx], seg[mx], l[mx], r[mx], d[mx], ans[mx];
int main() {
long long int n, m, k, a, b;
while (~scanf("%lld %lld %lld", &n, &m, &k)) {
seg[0] = ans[0] = 0;
for (int i = 1; i <= n; i++) {
seg[i] = 0;
ans[i] = 0;
scanf("%lld", &arr[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%lld %lld %lld", &l[i], &r[i], &d[i]);
}
for (int i = 1; i <= k; i++) {
scanf("%lld %lld", &a, &b);
seg[a]++;
seg[b + 1]--;
}
for (int i = 1; i <= m; i++) {
seg[i] += seg[i - 1];
ans[l[i]] += seg[i] * d[i];
ans[r[i] + 1] -= seg[i] * d[i];
}
for (int i = 1; i <= n; i++) {
ans[i] += ans[i - 1];
arr[i] += ans[i];
cout << arr[i] << " ";
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, a, b;
cin >> t;
while (t--) {
cin >> a >> b;
if (a % b == 0) {
cout << 0 << "\n";
continue;
}
long long d = a / b;
cout << ((d + 1) * b) - a << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double x, y;
while (~scanf("%lf%lf", &x, &y)) {
if (x < y) {
printf("-1\n");
} else if (x == y) {
printf("%.9lf\n", x);
} else {
double k1 = floor((x - y) / 2 / y);
double k2 = floor((x + y) / 2 / y);
printf("%.9lf\n", min((x - y) / k1 / 2, (x + y) / k2 / 2));
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
int maxi = arr[0];
int mini = arr[0];
int ctr = 0;
for (int i = 0; i < n; ++i) {
if (arr[i] > maxi) {
ctr++;
maxi = arr[i];
}
if (arr[i] < mini) {
ctr++;
mini = arr[i];
}
}
cout << ctr;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("input.txt");
ofstream fout("output.txt");
const int p = 10000;
int k, m, xval;
set<int> res;
void solve(int value, int remain) {
if (remain == 0) {
int dif = abs(k - abs(value));
if (dif < p) {
if (res.size() < m) res.insert(dif * p + xval);
if (res.size() < m) res.insert(p * xval + dif);
}
return;
}
solve(value + remain % 10, remain / 10);
solve(value - remain % 10, remain / 10);
solve(value * (remain % 10), remain / 10);
}
int main() {
cin >> k >> m;
for (int i = 0; i < p; i++) {
xval = i;
solve(i % 10, i / 10);
}
for (set<int>::iterator i = res.begin(); i != res.end(); i++)
printf("%08d\n", *i);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char num[5];
while (~scanf("%s", num)) {
if (strlen(num) < 2) {
if (num[0] == '0')
printf("zero\n");
else if (num[0] == '1')
printf("one\n");
else if (num[0] == '2')
printf("two\n");
else if (num[0] == '3')
printf("three\n");
else if (num[0] == '4')
printf("four\n");
else if (num[0] == '5')
printf("five\n");
else if (num[0] == '6')
printf("six\n");
else if (num[0] == '7')
printf("seven\n");
else if (num[0] == '8')
printf("eight\n");
else if (num[0] == '9')
printf("nine\n");
} else {
if (num[0] == '1') {
if (num[1] == '0')
printf("ten\n");
else if (num[1] == '1')
printf("eleven\n");
else if (num[1] == '2')
printf("twelve\n");
else if (num[1] == '3')
printf("thirteen\n");
else if (num[1] == '4')
printf("fourteen\n");
else if (num[1] == '5')
printf("fifteen\n");
else if (num[1] == '6')
printf("sixteen\n");
else if (num[1] == '7')
printf("seventeen\n");
else if (num[1] == '8')
printf("eighteen\n");
else if (num[1] == '9')
printf("nineteen\n");
} else {
if (num[0] == '2')
printf("twenty");
else if (num[0] == '3')
printf("thirty");
else if (num[0] == '4')
printf("forty");
else if (num[0] == '5')
printf("fifty");
else if (num[0] == '6')
printf("sixty");
else if (num[0] == '7')
printf("seventy");
else if (num[0] == '8')
printf("eighty");
else if (num[0] == '9')
printf("ninety");
if (num[1] == '0')
printf("\n");
else if (num[1] == '1')
printf("-one\n");
else if (num[1] == '2')
printf("-two\n");
else if (num[1] == '3')
printf("-three\n");
else if (num[1] == '4')
printf("-four\n");
else if (num[1] == '5')
printf("-five\n");
else if (num[1] == '6')
printf("-six\n");
else if (num[1] == '7')
printf("-seven\n");
else if (num[1] == '8')
printf("-eight\n");
else if (num[1] == '9')
printf("-nine\n");
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
void solve() {}
double ab(double a) {
if (a < 0.)
return -a;
else
return a;
}
int main() {
int n;
cin >> n;
n *= 2;
vector<double> v;
double ans = 0;
for (int i = 0; i < n; i++) {
double vv;
cin >> vv;
if (vv - floor(vv) != 0.0)
v.push_back(vv - floor(vv)), ans += vv - (floor(vv));
}
int nn = ((signed)v.size());
int m = max((2 * nn - n) / 2, 0), M = min(n / 2, nn);
double ans1 = 100000000000.;
for (int i = (m); i < (M + 1); i++) {
if (ans1 > ab(ans - (double)i)) {
ans1 = ab(ans - i);
}
}
printf("%.3lf", ans1);
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void cmin(int& a, int b) {
if (b < a) a = b;
}
const int N = 78, inf = 0x3f3f3f3f;
int dp[N][N][N][2];
vector<int> a[3];
int cnt(int i, int j, int k, int x) {
return max(int(lower_bound(begin(a[0]), end(a[0]), x) - begin(a[0])) - i, 0) +
max(int(lower_bound(begin(a[1]), end(a[1]), x) - begin(a[1])) - j, 0) +
max(int(lower_bound(begin(a[2]), end(a[2]), x) - begin(a[2])) - k, 0);
}
int main() {
int n;
string s;
cin >> n >> s;
for (int i = 0; i < n; ++i) {
auto& x = s[i];
x = x == 'V' ? 1 : x == 'K' ? 2 : 0;
a[x].push_back(i);
}
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0][0] = 0;
for (int m = 0; m < n; ++m)
for (int i = 0; i <= min(m, ((int)(a[0]).size())); ++i)
for (int j = 0; j <= min(m - i, ((int)(a[1]).size())); ++j) {
int k = m - i - j;
for (int b = 0; b <= 1; ++b) {
int od = dp[i][j][k][b];
if (od == inf) continue;
if (i != ((int)(a[0]).size()))
cmin(dp[i + 1][j][k][0], od + cnt(i, j, k, a[0][i]));
if (j != ((int)(a[1]).size()))
cmin(dp[i][j + 1][k][1], od + cnt(i, j, k, a[1][j]));
if (!b && k != ((int)(a[2]).size()))
cmin(dp[i][j][k + 1][0], od + cnt(i, j, k, a[2][k]));
}
}
cout << min(dp[((int)(a[0]).size())][((int)(a[1]).size())]
[((int)(a[2]).size())][0],
dp[((int)(a[0]).size())][((int)(a[1]).size())]
[((int)(a[2]).size())][1])
<< endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string str;
int idx;
vector<vector<string> > ans;
pair<string, int> parse() {
if (idx >= (int)str.size()) return make_pair("", -1);
string res1;
string res2;
while (str[idx] != ',') {
res1.push_back(str[idx]);
idx++;
}
idx++;
while (idx != str.size() && str[idx] != ',') {
res2.push_back(str[idx]);
idx++;
}
idx++;
return make_pair(res1, stoi(res2));
}
void solve(int lvl) {
if ((int)ans.size() <= lvl) ans.resize(ans.size() + 1);
pair<string, int> p = parse();
if (p.second != -1) {
ans[lvl].push_back(p.first);
for (int i = 0; i < p.second; i++) solve(lvl + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> str;
while (idx < str.size()) solve(0);
cout << ans.size() << endl;
for (vector<string>& vs : ans) {
for (string& s : vs) cout << s << " ";
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[4];
for (int i = 0; i < 4; i++) {
cin >> a[i];
}
if (a[0] == 0 && a[2] == 0 && a[3] == 0) {
cout << 1;
return 0;
}
if (a[0] == a[3] && a[0] != 0) {
cout << 1;
return 0;
}
cout << 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, ans;
priority_queue<long long> q;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
q.push(x);
if (q.top() > x) {
ans += q.top() - x;
q.pop();
q.push(x);
}
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
//using namespace __gnu_pbds;
#define st first
#define nd second
#define pb push_back
#define popb pop_back
#define mp make_pair
#define all(x) x.begin(),x.end()
#define sortall(x) sort(all(x));
#define deb(x) cout << #x << " = " << x << endl
#define debv(x) cout << #x << ": "; for (int i = 0; i < (x).size(); i++) cout << (x)[i] << ' '; cout << endl
#define PI 3.1415926535897932384626
#define fastio ios_base::sync_with_stdio(false); cin.tie(); cout.tie(); srand(time(NULL)); cout << fixed << setprecision(9)
typedef pair< int ,int > pii;
typedef pair< long long, long long > pll;
typedef vector< pii > vii;
typedef vector< pll > vll;
typedef long long ll;
typedef map< int, int > mii;
typedef set< pii > sii;
typedef set< int > si;
typedef vector< int > vi;
typedef vector< ll > vl;
typedef long double ld;
typedef pair< ld, ld > pld;
typedef vector< pld > vpld;
typedef unsigned long long ull;
typedef long long ll;
//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
//ordered_set t;
//t.insert(val);
//t.find_by_order(i) - returns iterator to the i-th element in set
//t.order_of_key(i) - index of value i
const ll mod = 1e9 + 7; /// 1 000 000 007
const ll mod2 = 119 << 23 | 1; /// 998244353
const ll mod3 = 467093870598391; /// big prime
int inf = 1e9 + 7;
ll INF = 1e16 + 9;
///tagliatelle here
///
ll power (ll x, ll y);
ll inv (ll x);
bool isPrime (ll x);
ll gcd (ll x, ll y);
//================================================================================
const int nax = 2e5 + 13;
void prep(){
}
vi a, b;
int n;
bool check(){
for(int i = 1; i < 2 * n; i++){
if(a[i - 1] > a[i]){
return false;
}
}
return true;
}
void one(){
for(int i = 0; i < 2 * n; i += 2){
swap(a[i], a[i + 1]);
}
}
void two(){
for(int i = 0; i < n; i++){
swap(a[i], a[i + n]);
}
}
int run(int start){
int ile = start;
while(true){
two();
ile++;
if(check())
return ile;
if(a == b)
return -1;
one();
ile++;
if(check())
return ile;
if(a == b)
return -1;
}
}
void solve(){
cin >> n;
a.resize(2 * n);
for(int i = 0; i < 2 * n; i++){
cin >> a[i];
}
if(check()){
cout << 0 << endl;
return;
}
b = a;
one();
if(check()){
cout << 1 << endl;
return;
}
int ans = run(1);
if(ans == -1){
a = b;
ans = run(0);
if(ans == -1){
cout << ans << endl;
return;
}else{
cout << ans << endl;
return;
}
}else{
a = b;
int tmp = run(0);
if(tmp == -1){
cout << ans << endl;
}else{
cout << min(ans, tmp) << endl;
}
}
}
int main(){ ///use cin and printf if you wanna see some REAL SPEED
//#ifndef ONLINE_JUDGE
// freopen("in.in", "r", stdin);
// freopen("out.txt", "w", stdout);
//#endif
fastio;
int T = 1;
prep();
//cin >> T;
for(int i = 1; i <= T; i++){
//cout << "test number " << i << endl;
solve();
//cout << "end" << endl;
}
return 0;
}
ll power (ll x, ll y) {
ll res = 1ll;
x %= mod;
if (x == 0)
return 0;
while (y > 0) {
if (y & 1)
res = (res * x) % mod;
y = y >> 1ll;
x = (x * x) % mod;
}
return res;
}
bool isPrime (ll x) {
if (x == 1)
return false;
for (ll i = 2ll; i * i <= x; i++) {
if (x % i == 0)
return false;
}
return true;
}
ll gcd (ll x, ll y) {
if (!y)
return x;
return gcd (y, x % y);
}
/*
__builtin_popcount
__builtin_ctz
__builtin_clz
*/
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
const int maxn = 100010;
int n, A, cf, cm, val[maxn];
long long m, sum[maxn];
pair<int, int> a[maxn];
bool check(int x, long long left, int mr) {
int l = 1, r = mr;
while (l <= r) {
int mid = l + r >> 1;
if (a[mid].first <= x)
l = mid + 1;
else
r = mid - 1;
}
l--;
return (1ll * l * x - sum[l]) <= left;
}
int main() {
n = read(), A = read(), cf = read(), cm = read();
scanf("%I64d", &m);
for (int i = 1; i <= n; i++) {
a[i].first = read();
a[i].second = i;
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i].first;
long long ans = -1, _max, _min;
for (int i = 0; i <= n; i++) {
long long left = m - 1ll * i * A + (sum[n] - sum[n - i]);
if (left < 0) break;
int l = 0, r = A;
while (l <= r) {
int mid = l + r >> 1;
if (check(mid, left, n - i))
l = mid + 1;
else
r = mid - 1;
}
l--;
long long tmp = 1ll * l * cm + 1ll * i * cf;
if (tmp > ans) {
ans = tmp;
_max = i;
_min = l;
}
}
for (int i = 1; i <= n; i++) {
if (i + _max > n)
val[a[i].second] = A;
else if (a[i].first < _min)
val[a[i].second] = _min;
else
val[a[i].second] = a[i].first;
}
printf("%I64d\n", ans);
for (int i = 1; i <= n; i++) printf("%d ", val[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MN = 101234, MOD = 1000 * 1000 * 1000 + 7;
long long st[MN], fn[MN], h[MN], res[MN], n;
vector<pair<long long, long long> > adj[MN], qwr[MN];
long long se1[MN * 4], se2[MN * 4], lz[MN * 4];
void boom(long long v, long long val, long long sz) {
(se2[v] += val * val % MOD * sz % MOD + 2 * se1[v] * val % MOD) %= MOD;
(se1[v] += val * sz % MOD) %= MOD;
(lz[v] += val) %= MOD;
}
void add(long long l, long long r, long long val, long long s = 0,
long long e = n, long long v = 1) {
if (r <= s || e <= l) return;
if (l <= s && e <= r) {
boom(v, val, e - s);
return;
}
long long mid = (s + e) / 2;
boom(v * 2, lz[v], mid - s);
boom(v * 2 + 1, lz[v], e - mid);
lz[v] = 0;
add(l, r, val, s, mid, v * 2);
add(l, r, val, mid, e, v * 2 + 1);
se1[v] = (se1[v * 2] + se1[v * 2 + 1]) % MOD;
se2[v] = (se2[v * 2] + se2[v * 2 + 1]) % MOD;
}
long long get(long long l, long long r, long long s = 0, long long e = n,
long long v = 1) {
if (r <= s || e <= l) return 0;
if (l <= s && e <= r) return se2[v];
long long mid = (s + e) / 2;
boom(v * 2, lz[v], mid - s);
boom(v * 2 + 1, lz[v], e - mid);
lz[v] = 0;
long long x = get(l, r, s, mid, v * 2);
long long y = get(l, r, mid, e, v * 2 + 1);
return (x + y) % MOD;
}
void dfs(long long v, long long p = 0) {
static long long t = 0;
st[v] = t++;
for (auto [u, w] : adj[v]) {
if (u == p) continue;
h[u] = (h[v] + w) % MOD;
dfs(u, v);
}
fn[v] = t;
}
void sar(long long v, long long p = 0) {
for (auto [u, w] : adj[v]) {
if (u == p) continue;
add(0, n, w);
add(st[u], fn[u], ((-2 * w) % MOD + MOD) % MOD);
sar(u, v);
add(0, n, (-w + MOD) % MOD);
add(st[u], fn[u], 2 * w % MOD);
}
for (auto [u, i] : qwr[v])
res[i] = (get(st[u], fn[u]) * 2 % MOD - get(0, n) + MOD) % MOD;
}
int32_t main() {
cin >> n;
for (long long i = 1; i < n; i++) {
long long u, v, w;
cin >> u >> v >> w;
adj[--u].push_back({--v, w});
adj[v].push_back({u, w});
}
dfs(0);
long long q;
cin >> q;
for (long long i = 0; i < q; i++) {
long long u, v;
cin >> u >> v;
qwr[--u].push_back({--v, i});
}
for (long long i = 0; i < n; i++) add(st[i], st[i] + 1, h[i]);
sar(0);
for (long long i = 0; i < q; i++) cout << res[i] << endl;
}
| 9 |
#include <bits/stdc++.h>
const int N = 100005;
using namespace std;
vector<int> p(N, 1), primes, ex(N, 1);
int n;
vector<pair<int, int>> pairs;
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n;
for (int i = 2; i <= n; i++) {
if (p[i]) {
primes.push_back(i);
for (int j = i * 2; j <= n; j += i) p[j] = 0;
}
}
reverse(primes.begin(), primes.end());
for (auto el : primes) {
vector<int> curs;
for (int i = el; i <= n; i += el) {
if (ex[i]) {
curs.push_back(i);
}
}
if ((curs.size() % 2 == 1) && curs.size() > 1) {
curs.erase(curs.begin() + 1);
}
if (curs.size() < 2) continue;
for (int i = 0; i < curs.size(); i += 2) {
pairs.push_back({curs[i], curs[i + 1]});
ex[curs[i]] = 0;
ex[curs[i + 1]] = 0;
}
}
cout << pairs.size() << '\n';
for (auto el : pairs) cout << el.first << ' ' << el.second << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline _T sqr(const _T& x) {
return x * x;
}
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
const double PI = 3.1415926535897932384626433832795;
const double EPS = 1e-11;
int n, k, m;
int nn;
vector<int> g[32];
int c[32][32];
double a[256][256];
double b[256][256];
double z[256][256];
int xy[256][2];
double p[256];
double ans[256];
void mult(double a[][256]) {
int n = nn;
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(n); j++) {
b[i][j] = a[j][i];
}
}
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(n); j++) {
z[i][j] = 0.0;
double* p1 = a[i];
double* p2 = b[j];
for (int k = 0; k < (int)(n); k++) {
z[i][j] += *p1++ * *p2++;
}
if (z[i][j] < 1e-40) z[i][j] = 0.0;
}
}
memcpy(a, z, sizeof(z));
}
int main() {
cout << setiosflags(ios::fixed) << setprecision(10);
k = 0;
int x1, x2;
scanf("%d%d%d%d", &n, &m, &x1, &x2);
x1--;
x2--;
for (int i = 0; i < (int)(m); i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 0; i < (int)(n); i++) {
scanf("%lf", &p[i]);
}
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(i + 1); j++) {
c[i][j] = c[j][i] = k;
xy[k][0] = i;
xy[k][1] = j;
k++;
}
}
memset((a), 0, sizeof(a));
for (int i = 0; i < (int)(k); i++) {
int x = xy[i][0];
int y = xy[i][1];
if (x == y) {
a[i][i] = 1.0;
continue;
}
double px = p[x];
double py = p[y];
double qx = (1.0 - px) / g[x].size();
double qy = (1.0 - py) / g[y].size();
for (int jx = 0; jx < (int)(g[x].size() + 1); jx++) {
int xn = (jx == (int)g[x].size()) ? x : g[x][jx];
double vx = (jx == (int)g[x].size()) ? px : qx;
for (int jy = 0; jy < (int)(g[y].size() + 1); jy++) {
int yn = (jy == (int)g[y].size()) ? y : g[y][jy];
double vy = (jy == (int)g[y].size()) ? py : qy;
int j = c[xn][yn];
a[i][j] += vx * vy;
}
}
}
nn = k;
for (int i = 0; i < (int)(20); i++) {
mult(a);
}
memset((p), 0, sizeof(p));
p[c[x1][x2]] = 1.0;
memset((ans), 0, sizeof(ans));
for (int i = 0; i < (int)(k); i++) {
for (int j = 0; j < (int)(k); j++) {
ans[i] += p[j] * a[j][i];
}
}
for (int i = 0; i < (int)(n); i++) {
if (i) putchar(' ');
printf("%0.9lf", ans[c[i][i]]);
}
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
const long long INF = 1e9 + 7;
const long long maxn = 2e5 + 7;
using namespace std;
void solve() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long ans = 0;
for (long long z = c; z < d + 1; z++) {
long long r1 = z - c + 1;
long long r2 = z - b + 1;
if (r1 > b) continue;
long long sStart = 1;
if (r2 < b) {
sStart += (b - r2);
}
r2 = max(r2, b);
long long numTerms = c - r2 + 1;
long long whichTermGreater = b - a + 2 - sStart;
long long numGreater = max(min(numTerms - whichTermGreater, numTerms), 0LL);
ans += numGreater * (b - a + 1);
numTerms -= numGreater;
long long finalTerm = sStart + numTerms - 1;
long long summn = (numTerms) * (sStart + finalTerm);
summn /= 2;
ans += summn;
}
cout << ans << '\n';
}
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
static constexpr int SZ = 'z' - 'a' + 1;
namespace atcoder {
template <class T>
struct fenwick_tree final {
fenwick_tree() : _n(0) {}
fenwick_tree(int n) : _n(n), data(n) {}
void add(int p, T x) {
assert(0 <= p && p < _n);
p++;
while (p <= _n) {
data[p - 1] += x;
p += p & -p;
}
}
T sum(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
return sum(r) - sum(l);
}
private:
int _n;
vector<T> data;
T sum(int r) {
T s = 0;
while (r > 0) {
s += data[r - 1];
r -= r & -r;
}
return s;
}
};
} // namespace atcoder
string reversed(string s) {
reverse(begin(s), end(s));
return s;
}
vector<int> permutation_of_reversed(const string &s) {
const auto rs = reversed(s);
const int n = s.size();
vector<int> ans(n, -1);
vector<deque<int>> idx(SZ);
for (int i = 0, j = 0; i < n;) {
const char x = s[i];
const char y = rs[j];
idx[y - 'a'].push_back(j);
if (!idx[x - 'a'].empty()) {
ans[i] = idx[x - 'a'].front();
idx[x - 'a'].pop_front();
++i;
}
if (j < n - 1) ++j;
}
return ans;
}
ll count_inversions(const vector<int> &xs) {
const int n = xs.size();
ll ans = 0;
atcoder::fenwick_tree<int> t(n);
for (int i = n - 1; i >= 0; --i) {
t.add(xs[i], 1);
ans += t.sum(0, xs[i]);
}
return ans;
}
ll min_swaps(const string &s) {
return count_inversions(permutation_of_reversed(s));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
string s(n, ' ');
cin >> s;
cout << min_swaps(s) << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
vector<int> G[maxn], rp[maxn];
int dfn[maxn], coc, bel[maxn], blo, crash[maxn][2], id[maxn], maxr[maxn];
bool ins[maxn];
long long ans[maxn];
stack<int> s;
set<int> lp;
pair<int, int> query[maxn];
inline int tarjan(int k, int fa) {
int lowu = dfn[k] = ++coc;
ins[k] = true;
s.push(k);
for (int i = 0; i < G[k].size(); i++) {
int v = G[k][i];
if (v == fa) continue;
if (!dfn[v]) {
int lowv = tarjan(v, k);
lowu = min(lowu, lowv);
} else if (ins[v])
lowu = min(lowu, dfn[v]);
}
if (lowu == dfn[k]) {
crash[blo][0] = crash[blo][1] = k;
int size = 0;
while (ins[k]) {
int v = s.top();
s.pop();
size++;
ins[v] = false;
bel[v] = blo;
crash[blo][0] = min(crash[blo][0], v);
crash[blo][1] = max(crash[blo][1], v);
}
if (size != 1) blo++;
}
return lowu;
}
inline bool cmp(int x, int y) { return query[x] > query[y]; }
struct node {
long long sum[maxn << 3], all[maxn << 3];
inline void update(int p, int lp, int rp, int l, int r, long long v) {
if (l == lp && r == rp) return void(all[p] += v);
sum[p] += (r - l + 1) * v;
int mid = lp + rp >> 1;
if (r <= mid)
update(p << 1, lp, mid, l, r, v);
else if (l > mid)
update(p << 1 | 1, mid + 1, rp, l, r, v);
else
update(p << 1, lp, mid, l, mid, v),
update(p << 1 | 1, mid + 1, rp, mid + 1, r, v);
}
inline long long query(int p, int lp, int rp, int l, int r) {
long long rtn = all[p] * (r - l + 1);
if (l == lp && r == rp) return rtn + sum[p];
int mid = lp + rp >> 1;
if (r <= mid)
return query(p << 1, lp, mid, l, r) + rtn;
else if (l > mid)
return query(p << 1 | 1, mid + 1, rp, l, r) + rtn;
else
return query(p << 1, lp, mid, l, mid) +
query(p << 1 | 1, mid + 1, rp, mid + 1, r) + rtn;
}
} S;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i, 0);
for (int i = 0; i < blo; i++) {
rp[crash[i][0]].push_back(crash[i][1]);
lp.insert(crash[i][1]);
}
for (int i = 1; i <= n; i++) {
maxr[i] = lp.size() ? *lp.begin() - 1 : n;
for (int j = 0; j < rp[i].size(); j++) lp.erase(rp[i][j]);
}
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++)
scanf("%d%d", &query[i].first, &query[i].second), id[i] = i;
sort(id + 1, id + 1 + q, cmp);
int minl = n + 1;
for (int i = 1; i <= q; i++) {
while (minl > query[id[i]].first)
S.update(1, 1, n, minl - 1, maxr[minl - 1], 1), --minl;
ans[id[i]] = S.query(1, 1, n, query[id[i]].first, query[id[i]].second);
}
for (int i = 1; i <= q; i++) printf("%lld\n", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf_int = 2e9;
const long long inf_ll = 2e18;
int Gcd(int p, int q) { return q == 0 ? p : Gcd(q, p % q); }
int Pow(int p, int q) {
int ans = 1;
while (q) {
if (q & 1) ans = ans * p;
p = p * p;
q >>= 1;
}
return ans;
}
inline int read() {
int ra, fh;
char rx;
rx = getchar(), ra = 0, fh = 1;
while ((rx < '0' || rx > '9') && rx != '-') rx = getchar();
if (rx == '-') fh = -1, rx = getchar();
while (rx >= '0' && rx <= '9') ra *= 10, ra += rx - 48, rx = getchar();
return ra * fh;
}
int f(int x) {
if (x & 1)
return (x - 1) / 2 * x;
else
return x / 2 * (x - 1);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
int flag = 0;
int A = 0, B = 0;
for (int i = 0; f(i) <= a; i++) {
if (f(i) == a) {
for (int j = 0; f(j) <= d; j++) {
if (f(j) == d) {
if (i * j == b + c) {
A = i;
B = j;
flag = 1;
}
}
}
}
}
if (!flag) {
printf("Impossible\n");
} else {
int sum = A + B;
for (int i = 1; i <= sum; i++) {
if (c >= A) {
c -= A;
B--;
printf("1");
} else {
A--;
printf("0");
}
}
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int cinv(const vector<int> &v) {
int ret = 0;
for (int i = 0; i < v.size(); ++i) {
for (int j = i + 1; j < v.size(); ++j) {
if (v[i] > v[j]) ret++;
}
}
return ret;
}
bool sub(const vector<string> &s1, const vector<string> &s2) {
int j = 0;
for (auto w : s2) {
if (w == s1[j]) {
j++;
}
if (j == s1.size()) return true;
}
return false;
}
int main() {
cin >> n;
vector<string> s0;
for (int i = 0; i < n; ++i) {
string c;
cin >> c;
s0.push_back(c);
}
int p = 0;
int rind = -1;
cin >> m;
for (int i = 0; i < m; ++i) {
int k;
cin >> k;
vector<string> w;
for (int j = 0; j < k; ++j) {
string c;
cin >> c;
w.push_back(c);
}
int inv = 1000000;
vector<int> ind(n);
iota(ind.begin(), ind.end(), 0);
do {
vector<string> ns;
for (auto ii : ind) {
ns.push_back(s0[ii]);
}
int invv = cinv(ind);
if (sub(ns, w)) {
if (invv < inv) {
inv = invv;
}
}
} while (next_permutation(ind.begin(), ind.end()));
if (inv < 1000000) {
int pp = n * (n - 1) / 2 - inv + 1;
if (pp > p) {
p = pp;
rind = i;
}
}
}
if (p == 0) {
cout << "Brand new problem!" << endl;
} else {
cout << rind + 1 << endl;
cout << "[:";
for (int i = 0; i < p; ++i) cout << '|';
cout << ":]";
cout << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
double ans = 0, cst = 0;
bool flag = false;
struct Edge {
int from, to, cap, flow;
double cost;
Edge(int _from = 0, int _to = 0, int _cap = 0, int _flow = 0,
double _cost = 0)
: from(_from), to(_to), cap(_cap), flow(_flow), cost(_cost) {}
};
struct Point {
int x, y;
Point(int _x = 0, int _y = 0) : x(_x), y(_y) {}
bool operator<(const Point &a) const {
if (y == a.y) return x < a.x;
return y > a.y;
}
} p[405];
struct MCMF {
static const int N = 800 + 5;
static const int M = 320000 + 5;
static const int oo = 0x3f3f3f3f;
int n, m, s, t, tim, tot;
int first[N], next[M];
int u[M], v[M], cap[M];
double cost[M], dis[N];
bool vi[N];
int cur[N];
void Clear() {
tot = 0;
for (int i = 0; i <= n; ++i) first[i] = -1;
}
void Add(int from, int to, int cp, int flw, double ct) {
u[tot] = from;
v[tot] = to;
cap[tot] = cp;
cost[tot] = ct;
next[tot] = first[u[tot]];
first[u[tot]] = tot;
tot++;
u[tot] = to;
v[tot] = from;
cap[tot] = 0;
cost[tot] = -ct;
next[tot] = first[u[tot]];
first[u[tot]] = tot;
tot++;
}
int aug(int x, int f) {
if (x == t) {
ans += (double)cst * f;
return f;
}
vi[x] = true;
int tmp = f;
for (int i = first[x]; i != -1; i = next[i])
if (cap[i] && !vi[v[i]] && !cost[i]) {
int delta = aug(v[i], tmp < cap[i] ? tmp : cap[i]);
cap[i] -= delta;
cap[i ^ 1] += delta;
tmp -= delta;
if (tmp == 0) return f;
}
return f - tmp;
}
bool modlabel() {
double tmp = (double)oo;
for (int i = 0; i <= n; ++i) {
if (vi[i])
for (int j = first[i]; j != -1; j = next[j])
if (cap[j] && !vi[v[j]] && cost[j] < tmp) tmp = cost[j];
}
if (tmp == (double)oo) return false;
for (int i = 0; i <= n; ++i)
if (vi[i])
for (int j = first[i]; j != -1; j = next[j])
cost[j] -= tmp, cost[j ^ 1] += tmp;
cst += tmp;
return true;
}
void MinCostMaxFlow(int s, int t) {
this->s = s;
this->t = t;
int flw, tot = 0;
for (;;) {
memset(vi, false, sizeof vi);
while (flw = aug(s, oo)) {
tot += flw;
memset(vi, false, sizeof vi);
}
if (!modlabel()) break;
}
if (tot == (n / 2 - 1)) flag = true;
}
} Net;
double dist(int i, int j) {
return sqrt(pow(p[i].x - p[j].x, 2) + pow(p[i].y - p[j].y, 2));
}
int main() {
scanf("%d", &n);
Net.n = n * 2;
Net.Clear();
for (int i = 1; i <= n; ++i) scanf("%d%d", &p[i].x, &p[i].y);
sort(p + 1, p + n + 1);
for (int i = 1; i <= n; ++i) Net.Add(0, i, 1, 0, 0);
for (int i = n + 1; i <= n + n; ++i) Net.Add(i, n + n + 1, 2, 0, 0);
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
if (p[i].y > p[j].y) Net.Add(j, i + n, 1, 0, dist(i, j));
}
}
Net.MinCostMaxFlow(0, Net.n + 1);
if (flag)
printf("%.15lf\n", ans);
else
puts("-1");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 2;
const int mod = 998244353;
int n, k, a[N], ans = 1, dp[2][N];
vector<int> odd, even;
int f(vector<int> v) {
long long ret = 1;
vector<int> b = v;
sort(b.begin(), b.end());
if (b.front() == b.back() && b.front() == -1) {
ret = k;
for (int i = 1; i < b.size(); i++) {
ret = (ret * (k - 1)) % mod;
}
} else {
for (int i = 0; i < v.size(); i++) {
int j = i;
while (j < v.size() && v[j] == -1) j++;
if (i != j) {
if (!i || j == v.size()) {
ret *= (dp[1][j - i - 1] + dp[0][j - i - 1] * 1ll * (k - 1)) % mod;
ret %= mod;
} else {
if (v[i - 1] == v[j]) {
ret *= (dp[0][j - i - 1] * 1ll * (k - 1)) % mod;
} else {
ret *= (dp[1][j - i - 1] + dp[0][j - i - 1] * 1ll * (k - 2)) % mod;
}
ret %= mod;
}
}
i = j;
}
}
return ret;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
if (i % 2)
odd.push_back(a[i]);
else
even.push_back(a[i]);
}
for (int i = 3; i <= n; i++) {
if (a[i] == a[i - 2] && a[i] > 0) {
cout << 0 << endl;
return 0;
}
}
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
dp[0][i] = (dp[1][i - 1] + dp[0][i - 1] * 1ll * (k - 2)) % mod;
dp[1][i] = (dp[0][i - 1] * 1ll * (k - 1)) % mod;
}
ans = (f(odd) * 1ll * f(even)) % mod;
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(51);
const long long MOD = 998244353;
long long mul(long long a, long long b) { return (a * b % MOD); }
long long sub(long long a, long long b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
long long add(long long a, long long b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, m;
cin >> n >> m;
vector<pair<long long, long long>> v(n);
vector<long long> ans(m + 1);
for (long long i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
}
for (long long i = m; i >= 1; --i) {
long long val = (m / i + 1);
vector<long long> dp(val);
dp[0] = 1;
for (long long j = 0; j < n; ++j) {
long long first = ((v[j].first + i - 1) / i), brk = v[j].second / i;
vector<long long> dpp(val);
for (long long k = 1; k < val; k++) {
dp[k] = add(dp[k], dp[k - 1]);
}
for (long long f = 0; f < val; f++) {
if (f >= first) {
dpp[f] = dp[f - first];
}
if (f - brk - 1 >= 0) {
dpp[f] = sub(dpp[f], dp[f - brk - 1]);
}
}
dp = dpp;
}
for (long long f = i; f <= m; f += i) {
ans[i] = sub(ans[i], ans[f]);
}
for (long long j = 0; j < val; j++) {
ans[i] = add(ans[i], dp[j]);
}
}
cout << ans[1] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
double power(double a, int b) {
if (b == 0) {
return 1;
} else if (b % 2 == 0) {
return power(a * a, b / 2);
} else if (b % 2 == 1) {
return a * power(a * a, (b - 1) / 2);
}
}
int sod(int a) {
int c = 0;
while (a != 0) {
c += a % 10;
a = a / 10;
}
return c;
}
bool is_prime(int n) {
if (n == 1) {
return false;
}
int i = 2;
while (i * i <= n) {
if (n % i == 0) {
return false;
}
i += 1;
}
return true;
}
int totaldigits(int n) {
int number_of_digits = 0;
for (int i = 1; i <= n; i *= 10) number_of_digits += (n - i + 1);
return number_of_digits;
}
int bs(int arr[], int l, int r, int x) {
if (r >= l) {
int mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return bs(arr, l, mid - 1, x);
return bs(arr, mid + 1, r, x);
}
return -1;
}
bool tr(int a, int b, int c) {
return ((a + b > c) && (a + c > b) && (b + c > a));
}
using namespace std;
void love_for_infinity() {
long long n, c = 1000000;
cin >> n;
for (int i = 1; i <= n; i++) cout << c++ << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) {
love_for_infinity();
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
int n, m, f[100005];
set<pair<int, int> > heap;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
int x;
for (int i = 1; i <= n; i++) {
heap.insert({0, i});
}
int cur = 1;
for (int i = 1; i <= m; i++) {
cin >> x;
f[x]++;
heap.erase(heap.find({f[x] - 1, x}));
heap.insert({f[x], x});
if (heap.begin()->first == cur) {
cout << 1;
cur++;
} else {
cout << 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
long long b[n];
for (long long i = 0; i < n; i++) {
cin >> b[i];
}
sort(b, b + n);
vector<long long> q;
for (long long i = n / 2; i < n; i++) {
q.push_back(b[i]);
}
long long int sz = (n + 1) / 2;
long long int dif[sz - 1];
for (long long i = 0; i < sz - 1; i++) {
dif[i] = q[i + 1] - q[i];
}
long long int mean = q[0];
int f = 0;
long long s2, tmp_k;
long long lst;
for (long long i = 0; i < sz - 1; i++) {
if (k - (dif[i] * (i + 1)) >= 0) {
mean = q[i + 1];
k = k - (dif[i] * (i + 1));
} else {
s2 = i + 1;
tmp_k = k;
f = 1;
break;
}
}
if (f == 1) {
for (long long i = (k / s2); i >= 0; i--) {
if (mean + i <= q[s2]) {
mean += i;
break;
}
}
} else {
if (k > 0) {
mean = mean + (k / sz);
}
}
cout << mean;
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[300030];
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << a[0] / 3 << endl;
return 0;
}
long long ans = 0, dp = 0;
for (int i = 0; i < n; i++) {
if (i == 0) {
ans += a[0] / 3;
dp += a[0] % 3;
} else {
if (dp <= a[i] / 2) {
ans += dp;
if ((a[i] - 2 * dp) % 3 == 0) {
ans += (a[i] - 2 * dp) / 3;
dp = 0;
} else {
ans += (a[i] - 2 * dp) / 3;
dp = (a[i] - 2 * dp) % 3;
}
} else {
ans += a[i] / 2;
dp += a[i] - (a[i] / 2) * 2 - a[i] / 2;
}
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 9;
int ans[N], cnt[N], p[N];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
int res = 1;
ans[0] = 1;
for (int i = 1; i <= n; i++) {
cin >> p[i], p[i]--;
int v = i;
while (v && ans[v] >= ans[p[v]]) {
res = max(res, ans[v]);
int u = p[v];
int mem = ans[u];
if (!u) ans[u] = ans[v] + 1;
if (ans[v] > ans[u]) {
ans[u] = ans[v];
cnt[u] = 1;
} else {
if (ans[u] == ans[v] && ++cnt[u] > 1) {
ans[u] = ans[v] + 1;
cnt[u] = 0;
}
}
v = p[v];
res = max(res, ans[v]);
if (ans[u] == mem) break;
}
cout << res << ' ';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline void prep() {
cin.tie(0);
cin.sync_with_stdio(0);
};
const int mod = 998244353;
const int MX = (int)2e5 + 10;
int main() {
prep();
int n, m;
cin >> n >> m;
string a, b;
cin >> a >> b;
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
int cnt = count(b.begin(), b.end(), '1');
long long res = 0;
long long p = 1;
for (int i = 0; i < n; ++i) {
if (a[i] == '1') res = (res + p * 1ll * cnt) % mod;
if (cnt > 0 && b[i] == '1') cnt--;
p = p * 2 % mod;
}
cout << res % mod << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[100000];
int n;
cin >> n;
int min = 2147483647;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
a[i] = k;
if (min > k) min = k;
}
for (int i = 0; i < n; i++) {
if (a[i] % min > 0) {
cout << "-1";
return 0;
}
}
cout << min;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
vector<int> adj[100005];
int din[100005];
queue<int> que;
int Vec[100005], V_size;
int a, b, c, d, cur;
bool succ;
int main() {
int Test;
scanf("%d", &Test);
while (Test--) {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i += 1) {
adj[i].clear();
din[i] = 0;
}
while (!que.empty()) que.pop();
for (int i = 1; i <= m; i += 1) {
scanf("%d%d", &a, &b);
adj[a].push_back(b), adj[b].push_back(a);
din[a]++, din[b]++;
}
if (k == 1) {
puts("2");
puts("1");
continue;
}
if (k > ((int)sqrt((double)2 * m) + 2)) {
puts("-1");
continue;
}
for (int i = 1; i <= n; i += 1) sort(adj[i].begin(), adj[i].end());
for (int i = 1; i <= n; i += 1)
if (din[i] < (k - 1)) que.push(i);
while (!que.empty()) {
cur = que.front();
que.pop();
for (auto& i : adj[cur]) {
din[cur]--, din[i]--;
if (din[i] == (k - 2)) que.push(i);
}
}
for (int i = 1; i <= n; i += 1)
if (din[i] == (k - 1)) que.push(i);
bool nex_loop = false;
while (!que.empty()) {
cur = que.front();
que.pop();
if (din[cur] == (k - 1)) {
V_size = 0;
for (auto& i : adj[cur]) {
if (din[i] <= 0) continue;
Vec[V_size++] = i;
}
succ = true;
for (int i = 0; i <= V_size - 1; i += 1) {
for (int j = i + 1; j <= V_size - 1; j += 1) {
a = Vec[i], b = Vec[j];
auto it = lower_bound(adj[a].begin(), adj[a].end(), b);
if ((it == adj[a].end()) || (*it != b)) {
succ = false;
break;
}
}
if (!succ) break;
}
if (succ) {
puts("2");
printf("%d ", cur);
for (int i = 0; i <= V_size - 1; i += 1) printf("%d ", Vec[i]);
printf("\n");
nex_loop = true;
break;
}
}
for (auto& i : adj[cur]) {
if (din[i] <= 0) continue;
din[cur]--, din[i]--;
if (din[i] == (k - 1)) que.push(i);
}
}
if (nex_loop) continue;
V_size = 0;
for (int i = 1; i <= n; i += 1) {
if (din[i] <= 0) continue;
Vec[V_size++] = i;
}
if (V_size == 0)
puts("-1");
else {
printf("1 %d\n", V_size);
for (int i = 0; i <= V_size - 1; i += 1) {
printf("%d ", Vec[i]);
}
printf("\n");
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long num[2005];
int book[2005];
int main() {
int m, n;
scanf("%d %d", &n, &m);
long long t;
for (int i = 0; i < n; i++) {
scanf("%lld", &t);
num[i] = t;
if (t <= m) book[t]++;
}
int x = n / m;
int cnt = 0;
int flag = 0;
for (int i = 0; i < n; i++) {
if (num[i] <= m) {
if (book[num[i]] > x) {
int p = num[i];
for (int j = 1; j <= m; j++) {
if (book[j] < x) {
num[i] = j;
book[j]++;
cnt++;
flag = 1;
break;
}
}
if (flag) book[p]--;
flag = 0;
}
} else {
for (int j = 1; j <= m; j++) {
if (book[j] < x) {
num[i] = j;
book[j]++;
cnt++;
break;
}
}
}
}
printf("%d %d\n", x, cnt);
for (int i = 0; i < n; i++) printf("%d ", num[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 101000;
int n, m, a[100], b[100], res;
void init() { cin >> n >> m; }
void xuat(int l, int r) {
if (l <= 0 || r <= 0) return;
if (l <= r)
for (int i = l; i < r + 1; i++) printf("%i ", i);
else
for (int i = l; i > r - 1; i--) printf("%i ", i);
}
void dq(int k) {
if (k > n) {
int ans = 0;
for (int i = 1; i < n + 1; i++) {
int ht = n + 1;
for (int j = i; j < n + 1; j++) {
ht = min(ht, a[j]);
ans += ht;
}
}
res = max(ans, res);
return;
}
for (int i = 1; i < n + 1; i++)
if (b[i] == 0) {
b[i] = 1;
a[k] = i;
dq(k + 1);
b[i] = 0;
}
}
void dq1(int k) {
if (k > n) {
int ans = 0;
for (int i = 1; i < n + 1; i++) {
int ht = n + 1;
for (int j = i; j < n + 1; j++) {
ht = min(ht, a[j]);
ans += ht;
}
}
if (ans == res) {
--m;
if (m != 0) return;
for (int i = 1; i < n + 1; i++) printf("%i ", a[i]);
cout << "\n";
}
return;
}
for (int i = 1; i < n + 1; i++)
if (b[i] == 0) {
b[i] = 1;
a[k] = i;
dq1(k + 1);
b[i] = 0;
}
}
void xuly() {
int tm = m;
dq(1);
dq1(1);
}
int main() {
init();
xuly();
fclose(stdin);
fclose(stdout);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
long long t, w, b;
cin >> t >> w >> b;
long long p = min(w, b);
long long q = gcd(w, b);
long long r = 0, s = min(t, p - 1);
if (t / (w / q) >= b) {
long long x = (w / q) * b;
r = t / x;
s = min(t % x, p - 1);
}
long long n = p * r + s;
long long d = t;
long long g = gcd(n, d);
n /= g;
d /= g;
cout << n << "/" << d << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double INF = 1e+9;
int main() {
int n, x, y;
cin >> n >> x >> y;
if (x >= n / 2 && x <= n / 2 + 1 && y >= n / 2 && y <= n / 2 + 1)
cout << "NO";
else
cout << "YES";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 105, inf = 4e18 + 4, mod = 1e9 + 7;
ll n, a2[N], num[N], ans, sum, dp[N][N * N], tmp[N][N * N], fac[N], inv[N];
bool mark[N];
ll pw(ll a, ll b) {
if (b == 0) return 1;
a %= mod;
if (b % 2 == 1) return a * pw(a, (b - 1)) % mod;
return pw((a * a % mod), (b / 2)) % mod;
}
ll choose(ll a, ll b) {
if (b > a) return 0;
if (b == 0 || b == a) return 1;
return fac[a] % mod * inv[b] % mod * inv[a - b] % mod;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
tmp[0][0] = 1;
fac[0] = 1;
for (ll i = 1; i < N - 1; i++) fac[i] = (fac[i - 1] * i) % mod;
inv[N - 2] = pw(fac[N - 2], mod - 2) % mod;
for (ll i = N - 3; i >= 0; i--) {
ll x = i + 1;
inv[i] = (inv[x] * (x)) % mod;
}
cin >> n;
ll y = 0;
for (ll i = 0; i < n; i++) {
cin >> a2[i];
if (!mark[a2[i]]) {
mark[a2[i]] = 1;
y++;
}
num[a2[i]]++;
sum += a2[i];
for (ll j = 0; j < n; j++) {
for (ll k = a2[i]; k <= sum; k++) {
dp[j + 1][k] = tmp[j][k - a2[i]];
}
}
for (ll j = 0; j <= n; j++) {
for (ll k = 0; k <= sum; k++) {
(tmp[j][k] += dp[j][k]) % mod;
dp[j][k] = 0;
}
}
}
if (y < 3) {
cout << n << endl;
return 0;
}
for (ll i = 100; i >= 1; i--) {
for (ll j = num[i]; j > 0; j--) {
if (choose(num[i], j) != tmp[j][j * i]) continue;
ans = max(ans, j);
}
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dp[(1 << 24) + 5], pre[(1 << 24) + 5];
int dis[30][30];
int n;
int dfs(int S) {
if (dp[S] != -1) return dp[S];
dp[S] = 0x3f3f3f3f;
int i = 0;
for (; i < n; i++) {
if ((S >> i) & 1) break;
}
if (i == n) return dp[0];
int T = S ^ (1 << i);
int tmp = dfs(T);
if (dp[S] > tmp + 2 * dis[0][i + 1]) {
dp[S] = tmp + 2 * dis[0][i + 1];
pre[S] = T;
}
for (int j = i + 1; j < n; j++) {
if ((T >> j) & 1) {
int K = T ^ (1 << j);
int tmp = dfs(K);
if (dp[S] >= tmp + dis[0][i + 1] + dis[i + 1][j + 1] + dis[0][j + 1]) {
dp[S] = tmp + dis[0][i + 1] + dis[i + 1][j + 1] + dis[0][j + 1];
pre[S] = K;
}
}
}
return dp[S];
}
void output(int S) {
if (pre[S] == -1) {
return;
}
for (int i = 0; i < n; i++) {
if ((S ^ pre[S]) & (1 << i)) {
cout << i + 1 << ' ';
}
}
cout << 0 << ' ';
output(pre[S]);
}
int main() {
vector<pair<int, int> > points;
int x, y;
cin >> x >> y;
points.push_back(make_pair(x, y));
cin >> n;
for (int i = 0; i < n; i++) {
int xx, yy;
cin >> xx >> yy;
points.push_back(make_pair(xx, yy));
}
for (int i = 0; i < points.size(); i++) {
for (int j = i + 1; j < points.size(); j++) {
dis[i][j] = pow(points[i].first - points[j].first, 2) +
pow(points[i].second - points[j].second, 2);
}
}
memset(dp, -1, sizeof(dp));
memset(pre, -1, sizeof(pre));
dp[0] = 0;
cout << dfs((1 << n) - 1) << endl;
cout << 0 << ' ';
output((1 << n) - 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)(1e9 + 7);
int main() {
int n;
scanf("%d", &n);
vector<int> h(n);
for (int i = 0; i < (int)n; ++i) scanf("%d", &h[i]);
vector<long long> dp(n), dpr(n);
long long res = 0;
for (int i = 0; i < n; ++i) {
dp[i] = h[i] - 1;
if (i - 1 >= 0 && h[i - 1] <= h[i]) {
long long tmp = (h[i - 1] - 1) * dp[i - 1];
tmp %= MOD;
dp[i] = (dp[i] + tmp) % MOD;
} else if (i - 1 >= 0 && h[i - 1] > h[i]) {
long long tmp = (h[i] - 1) * dpr[i - 1];
tmp %= MOD;
dp[i] = (dp[i] + tmp) % MOD;
}
if (i + 1 < n && h[i] <= h[i + 1]) {
dpr[i] = 0;
} else if (i + 1 < n && h[i] > h[i + 1]) {
dpr[i] = h[i + 1] - 1;
if (i - 1 >= 0 && h[i - 1] >= h[i + 1] && h[i - 1] <= h[i]) {
long long tmp = (h[i + 1] - 1) * dp[i - 1];
tmp %= MOD;
dpr[i] = (dpr[i] + tmp) % MOD;
} else if (i - 1 >= 0 && h[i - 1] > h[i]) {
long long tmp = (h[i + 1] - 1) * dpr[i - 1];
tmp %= MOD;
dpr[i] = (dpr[i] + tmp) % MOD;
} else if (i - 1 >= 0 && h[i - 1] < h[i + 1]) {
long long tmp = (h[i - 1] - 1) * dp[i - 1];
tmp %= MOD;
dpr[i] = (dpr[i] + tmp) % MOD;
}
}
res = (res + dp[i]) % MOD;
}
cout << res << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 * 1e5 + 5;
long long n, m, cnt[65];
map<long long, long long> mp;
int main() {
for (int i = 0; i < 60; i++) mp[i + 1] = ((long long)1 << i);
int T;
cin >> T;
while (T--) {
cin >> n >> m;
long long tot = 0;
memset(cnt, 0, sizeof(cnt));
for (long long i = 1; i <= m; i++) {
long long x;
cin >> x;
tot += x;
int num = 0;
while (x != 0) {
x >>= 1;
num++;
}
cnt[num]++;
}
if (tot < n) {
cout << -1 << endl;
continue;
}
int num = 1;
long long tmp = 0, ans = 0;
while (n != 0) {
tmp += mp[num] * cnt[num];
if (n & 1 == 1) {
if (tmp >= mp[num]) {
tmp -= mp[num];
} else {
for (int i = num + 1; i < 60; i++) {
if (cnt[i] != 0) {
tmp += mp[i];
tmp -= mp[num];
ans += i - num;
cnt[i]--;
break;
}
}
}
}
n >>= 1;
num++;
}
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int cnt1, cnt0;
map<int, int> m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
int ans = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
cnt1++;
} else {
cnt0++;
}
int bal = cnt0 - cnt1;
if (bal == 0) {
ans = i + 1;
continue;
}
if (m.find(bal) != m.end()) {
ans = max(ans, i - m[bal]);
} else {
m[bal] = i;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int A[200] = {0, 1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1,
14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1,
51, 1, 2, 1, 14, 1, 2, 2, 14, 1, 6, 1, 4, 2, 2, 1,
52, 2, 5, 1, 5, 1, 15, 2, 13, 2, 2, 1, 13, 1, 2, 4,
267, 1, 4, 1, 5, 1, 4, 1, 50, 1, 2, 3, 4, 1, 6, 1,
52, 15, 2, 1, 15, 1, 2, 1, 12, 1, 10, 1, 4, 2, 0};
int main() {
int n;
scanf("%d", &n);
printf("%d", A[n]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x;
scanf("%d%d%d", &n, &m, &x);
if (x % 2 == 0) {
int u = x / 2;
int hang, lie;
if (u % m == 0) {
lie = u / m;
hang = m;
} else {
lie = u / m + 1;
hang = u % m;
}
printf("%d %d R\n", lie, hang);
} else {
int u = x / 2 + 1;
int hang, lie;
if (u % m == 0) {
hang = m;
lie = u / m;
} else {
hang = u % m;
lie = u / m + 1;
}
printf("%d %d L\n", lie, hang);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 0, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
int n, q;
pair<double, double> a[1 << 18];
pair<double, double> merge(pair<double, double> x, pair<double, double> y) {
double l1 = x.first;
double r1 = x.second;
double l2 = y.first;
double r2 = y.second;
double l = (l1 * l2) / (1 - (1 - l2) * r1);
double r = r2 + ((1 - r2) * r1 * l2) / (1 - (1 - l2) * r1);
return {l, r};
}
void build(int o, int l, int r) {
if (l == r) {
double x, y;
scanf("%lf%lf", &x, &y);
a[o] = {x / y, x / y};
return;
}
int mid = (l + r) >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
a[o] = merge(a[o << 1], a[o << 1 | 1]);
}
pair<double, double> V;
int P;
void update(int o, int l, int r) {
if (l == r) {
a[o] = V;
return;
}
int mid = (l + r) >> 1;
if (P <= mid)
update(o << 1, l, mid);
else
update(o << 1 | 1, mid + 1, r);
a[o] = merge(a[o << 1], a[o << 1 | 1]);
}
int L, R;
pair<double, double> query(int o, int l, int r) {
if (l >= L && r <= R) return a[o];
int mid = (l + r) >> 1;
if (R <= mid)
return query(o << 1, l, mid);
else if (L > mid)
return query(o << 1 | 1, mid + 1, r);
else
return merge(query(o << 1, l, mid), query(o << 1 | 1, mid + 1, r));
}
int main() {
while (~scanf("%d%d", &n, &q)) {
build(1, 1, n);
while (q--) {
int op;
scanf("%d", &op);
if (op == 1) {
double x, y;
scanf("%d%lf%lf", &P, &x, &y);
V = {x / y, x / y};
update(1, 1, n);
} else {
scanf("%d%d", &L, &R);
printf("%.12f\n", query(1, 1, n).first);
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
int n, m, k;
int f[5010], c[5010][5010];
int Q_pow(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = 1LL * res * x % mod;
x = 1LL * x * x % mod;
y >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
int inv_m = Q_pow(m, mod - 2), ans = 0;
f[0] = 1;
for (int i = 1; i <= k; ++i) {
f[i] = 1LL * f[i - 1] * (n - i + 1) % mod * inv_m % mod;
}
c[1][1] = 1;
for (int i = 1; i <= k - 1; ++i) {
for (int j = 1; j <= i; ++j) {
c[i + 1][j] = (c[i + 1][j] + 1LL * c[i][j] * j % mod) % mod;
c[i + 1][j + 1] = (c[i + 1][j + 1] + c[i][j]) % mod;
}
}
for (int i = 1; i <= k; ++i) {
ans = (ans + 1LL * c[k][i] * f[i] % mod) % mod;
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int MM = 2e5 + 80;
const int phi = 1e9 + 6;
const int r = 5;
struct mat {
long long m[r + 2][r + 2];
};
mat operator*(mat a, mat b) {
mat res;
memset(res.m, 0, sizeof(res.m));
int i, j, k;
for (i = 1; i <= r; i++)
for (j = 1; j <= r; j++)
for (k = 1; k <= r; k++)
res.m[i][j] = (res.m[i][j] + a.m[i][k] * b.m[k][j]) % phi;
return res;
}
mat qpowmat(mat a, long long b, int len) {
mat res;
memset(res.m, 0, sizeof(res.m));
for (int i = 1; i <= r - len; i++) res.m[i][i] = 1;
while (b) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long qpow(long long a, long long b) {
long long res = 1;
a %= mod;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
int main() {
int i, j;
long long n, f[5], c, ans, t, p;
mat A, B;
memset(A.m, 0, sizeof(A.m));
A.m[1][1] = 1;
A.m[1][2] = 1;
A.m[1][3] = 0;
A.m[2][1] = 1;
A.m[2][2] = 0;
A.m[2][3] = 1;
A.m[3][1] = 1;
cin >> n;
for (i = 1; i <= 3; i++) cin >> f[i];
cin >> c;
mat C, D;
memset(C.m, 0, sizeof(C.m));
C.m[1][1] = 1;
C.m[1][2] = 1;
C.m[2][1] = 1;
C.m[2][3] = 1;
C.m[3][1] = 1;
C.m[4][1] = 2;
C.m[4][4] = 1;
C.m[5][1] = -4;
C.m[5][4] = 1;
C.m[5][5] = 1;
if (n <= 3)
cout << f[n] << endl;
else {
B = qpowmat(A, n - 3, 2);
D = qpowmat(C, n - 3, 0);
t = (D.m[4][1] * 3 % phi + D.m[5][1]) % phi;
t = qpow(c, t) % mod;
ans = t;
for (i = 1; i <= 3; i++) ans = (ans * qpow(f[3 - i + 1], B.m[i][1])) % mod;
printf("%lld\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t-- > 0) {
int n, k;
cin >> n >> k;
int start[n], fin[k];
for (int i = 0; i < n; i++) {
cin >> start[i];
start[i]--;
}
int start_inv[n];
for (int i = 0; i < n; i++) start_inv[start[i]] = i;
char *bruh = (char *)calloc(n, sizeof(char));
int table[n];
for (int i = 0; i < n; i++) table[i] = -1;
int inv[k];
for (int i = 0; i < k; i++) {
cin >> fin[i];
fin[i]--;
bruh[start_inv[fin[i]]] = 1;
table[start_inv[fin[i]]] = i;
}
for (int i = 0; i < n; i++) {
if (table[i] != -1) {
inv[table[i]] = i;
}
}
int ans = 1;
for (int i = 0; i < k; i++) {
int p = inv[i];
if (p != 0 && p != n - 1) {
int temp = 0;
if (bruh[p - 1] == 0) temp++;
if (bruh[p + 1] == 0) temp++;
if (temp == 0) {
printf("0\n");
goto end;
}
ans *= temp;
ans %= 998244353;
bruh[p] = 0;
} else if (p == 0) {
int temp = 0;
if (bruh[p + 1] == 0) temp++;
if (temp == 0) {
printf("0\n");
goto end;
}
ans *= temp;
ans %= 998244353;
bruh[p] = 0;
} else if (p == n - 1) {
int temp = 0;
if (bruh[p - 1] == 0) temp++;
if (temp == 0) {
printf("0\n");
goto end;
}
ans *= temp;
ans %= 998244353;
bruh[p] = 0;
}
}
printf("%d\n", ans);
end:
free(bruh);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
const int MAX_N = 200010;
const long long inf = 1e18;
int n;
long long cost[MAX_N];
vector<int> adj[MAX_N];
vector<int> ch[MAX_N];
long long dp[MAX_N][2];
vector<bool> canTake[MAX_N][2];
bool vis[MAX_N][2];
set<int> ansNodes;
long long getDp(int u, bool x);
vector<pair<int, pair<long long, long long>>> getRec(int u) {
vector<pair<int, pair<long long, long long>>> res;
for (int v : ch[u]) res.push_back({v, {getDp(v, 0), getDp(v, 1)}});
sort(res.begin(), res.end(),
[](const pair<int, pair<long long, long long>>& p1,
const pair<int, pair<long long, long long>>& p2) {
return p1.second.second - p1.second.first >
p2.second.second - p2.second.first;
});
return res;
}
void dfs(int u, int p) {
for (int v : adj[u])
if (v != p) {
dfs(v, u);
ch[u].push_back(v);
}
}
long long getDp(int u, bool x) {
if (dp[u][x] != -1) return dp[u][x];
if ((int)ch[u].size() == 0) {
if (x)
dp[u][x] = cost[u];
else
dp[u][x] = 0;
canTake[u][x].push_back(x);
return dp[u][x];
}
auto rec = getRec(u);
long long tot = 0;
for (int i = 0; i < (int)rec.size(); i++) tot += rec[i].second.second;
long long ifLeave, ifTake;
if (x) {
ifLeave = tot;
ifTake = cost[u] + tot - rec[0].second.second + rec[0].second.first;
} else {
ifLeave = tot - rec[0].second.second + rec[0].second.first;
ifTake = inf;
}
if (ifLeave == ifTake) {
canTake[u][x].push_back(0);
canTake[u][x].push_back(1);
} else if (ifLeave < ifTake) {
canTake[u][x].push_back(0);
} else {
canTake[u][x].push_back(1);
}
dp[u][x] = min(ifLeave, ifTake);
return dp[u][x];
}
void getNodes(int u, int x) {
if (vis[u][x]) return;
vis[u][x] = 1;
if ((int)ch[u].size() == 0) {
if (x) ansNodes.insert(u);
return;
}
auto rec = getRec(u);
for (bool takeThis : canTake[u][x]) {
if (takeThis) {
ansNodes.insert(u);
if (x) {
long long need = rec[0].second.second - rec[0].second.first;
int cntWithNeed = 0;
for (int i = 0; i < (int)rec.size(); i++) {
if (rec[i].second.second - rec[i].second.first == need) cntWithNeed++;
}
for (int i = 0; i < (int)rec.size(); i++) {
if (rec[i].second.second - rec[i].second.first == need) {
getNodes(rec[i].first, 0);
if (cntWithNeed > 1) getNodes(rec[i].first, 1);
} else {
getNodes(rec[i].first, 1);
}
}
long long cur = cost[u];
for (int i = 0; i < (int)rec.size(); i++) cur += rec[i].second.second;
if (cur == dp[u][1]) {
for (int i = 0; i < (int)rec.size(); i++) getNodes(rec[i].first, 1);
}
} else {
assert(0);
}
} else {
if (x) {
for (int i = 0; i < (int)rec.size(); i++) {
getNodes(rec[i].first, 1);
}
} else {
long long need = rec[0].second.second - rec[0].second.first;
int cntWithNeed = 0;
for (int i = 0; i < (int)rec.size(); i++) {
if (rec[i].second.second - rec[i].second.first == need) cntWithNeed++;
}
for (int i = 0; i < (int)rec.size(); i++) {
if (rec[i].second.second - rec[i].second.first == need) {
getNodes(rec[i].first, 0);
if (cntWithNeed > 1) getNodes(rec[i].first, 1);
} else {
getNodes(rec[i].first, 1);
}
}
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> cost[i];
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(0, -1);
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++) dp[i][j] = -1;
long long cnt = getDp(0, 1);
getNodes(0, 1);
cout << cnt << " " << (int)ansNodes.size() << "\n";
for (int u : ansNodes) cout << u + 1 << " ";
cout << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, max;
long long ans;
} tr[2000001];
struct node1 {
int x, y, ne;
} a[200001];
int len = 0, la[100001];
long long w[100001], t[100001];
long long root[100001];
int n;
void read(int &num) {
char ch;
while (ch = getchar(), ch < '!')
;
num = ch - 48;
while (ch = getchar(), ch > '!') num = num * 10 + ch - 48;
}
void add(int x, int y) {
len++;
int k = len;
a[k].x = x, a[k].y = y;
a[k].ne = la[x], la[x] = len;
}
int find(int k1, int k2, int l, int r) {
if ((k1 == 0) || (k2 == 0)) return k1 + k2;
if (l == r) {
tr[k1].max = tr[k1].max + tr[k2].max;
return k1;
}
int mid = (l + r) >> 1;
tr[k1].l = find(tr[k1].l, tr[k2].l, l, mid);
tr[k1].r = find(tr[k1].r, tr[k2].r, mid + 1, r);
int ls = tr[k1].l, rs = tr[k1].r;
if (tr[ls].max > tr[rs].max) {
tr[k1].max = tr[ls].max;
tr[k1].ans = tr[ls].ans;
}
if (tr[ls].max < tr[rs].max) {
tr[k1].max = tr[rs].max;
tr[k1].ans = tr[rs].ans;
}
if (tr[ls].max == tr[rs].max) {
tr[k1].max = tr[ls].max;
tr[k1].ans = tr[ls].ans + tr[rs].ans;
}
return k1;
}
void add2(int k, int l, int r, int pos) {
if (l == r) {
tr[k].max++;
tr[k].ans = l;
return;
}
int mid = (l + r) >> 1;
if (pos <= mid) {
if (tr[k].l == 0) {
len++;
tr[k].l = len;
}
add2(tr[k].l, l, mid, pos);
} else {
if (tr[k].r == 0) {
len++;
tr[k].r = len;
}
add2(tr[k].r, mid + 1, r, pos);
}
int ls = tr[k].l, rs = tr[k].r;
if (tr[ls].max > tr[rs].max) {
tr[k].max = tr[ls].max;
tr[k].ans = tr[ls].ans;
}
if (tr[ls].max < tr[rs].max) {
tr[k].max = tr[rs].max;
tr[k].ans = tr[rs].ans;
}
if (tr[ls].max == tr[rs].max) {
tr[k].max = tr[ls].max;
tr[k].ans = tr[ls].ans + tr[rs].ans;
}
}
void go(int x, int fa) {
for (int k = la[x]; k; k = a[k].ne) {
int y = a[k].y;
if (y == fa) continue;
go(y, x);
root[x] = find(root[x], root[y], 1, n);
}
if (root[x] == 0) {
len++;
root[x] = len;
}
add2(root[x], 1, n, w[x]);
t[x] = tr[root[x]].ans;
}
int main() {
int x, y;
read(n);
memset(root, 0, sizeof(root));
for (int i = 1; i <= n; i++) scanf("%lld", &w[i]);
for (int i = 1; i <= n - 1; i++) {
read(x), read(y);
add(x, y), add(y, x);
}
go(1, 0);
for (int i = 1; i <= n; i++) printf("%lld ", t[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll const MOD = 1e9 + 7;
int const MAXN = 1001;
int bin[MAXN][MAXN]{};
bin[0][0] = 1;
for (int i = 1; i < MAXN; ++i) {
for (int j = 0; j <= i; ++j) {
bin[i][j] = (bin[i - 1][j] + bin[i - 1][j - 1]) % MOD;
}
}
int k;
cin >> k;
int c[MAXN];
for (int i = 0; i < k; ++i) {
cin >> c[i];
}
ll res = 1;
ll total = 0;
for (int i = 0; i < k; ++i) {
res = (res * bin[total + c[i] - 1][c[i] - 1]) % MOD;
total += c[i];
}
cout << res;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long ee, p1[200][200], p2[200][200], e, n, sz[1000], m, k, c[200][200],
ans[200][20000];
long long pw(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 1) {
return a * pw(a, b - 1) % 1000000007;
}
return pw(a * a % 1000000007, b / 2);
}
int main() {
c[0][0] = 1;
for (int i = 1; i <= 100; i++) c[i][0] = 1;
for (int i = 1; i <= 100; i++)
for (int j = 1; j <= i; j++) {
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
c[i][j] %= 1000000007;
}
long a, b;
cin >> n >> m >> k;
long long tsz = m / n + 1;
for (int i = 1; i <= n; i++) {
if (m % n >= i)
sz[i] = m / n + 1;
else
sz[i] = m / n;
}
for (int i = 0; i <= 100; i++)
for (int j = 0; j <= i; j++) {
p1[i][j] = pw(c[i][j], tsz);
p2[i][j] = pw(c[i][j], tsz - 1);
}
long long qq = m % n;
ans[0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= k; j++)
for (int e = 0; e <= n; e++) {
if (i >= qq)
ee = p2[n][e];
else
ee = p1[n][e];
ans[i + 1][j + e] += ee * ans[i][j];
ans[i + 1][j + e] %= 1000000007;
}
}
cout << ans[n][k] << endl;
cin.get();
cin.get();
return 0;
}
| 5 |
//AUTHOR = A MAN
//ANDI BANDI SHANDI , JISNE HACK KIA USKI ** *****
//------------------------------------------Template------------------------------------------------
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define lp(i,a,b) for(ll i=a;i<b;i++)
#define rlp(i,a,b) for(ll i=b;i>=a;i--)
#define KATAI_GAND_FAD_SPEED ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define INF 1e9
#define pb push_back
#define mp make_pair
#define lb lower_bound
#define ub upper_bound
#define ff first
#define ss second
#define vi vector<ll>
#define vii vector<pair<ll,ll>>
#define viii vector<pair<ll,pair<ll,ll>>>
#define all(x) (x).begin(),(x).end()
const ll mod = 1e9 + 7;
#define endl "\n"
#define deb1(a) cout<<#a<<" = "<<(a)<<endl;
#define deb2(a,b) cout<<#a<<" = "<<(a)<<", "<<#b<<" = "<<(b)<<endl;
#define deb3(a,b,c) cout<<#a<<" = "<<(a)<<", "<<#b<<" = "<<(b)<<", "<<#c<<" = "<<(c)<<endl;
int dx[] = {0,0,1,-1};
int dy[] = {1,-1,0,0};
string ds = "RLDU";
//ll n , m;
//bool possible(ll x , ll y)
//{
//return (x < n && x >= 0 && y < m && y>=0) ;
//}
ll abm(ll a,ll b,ll m){ll ans=1;a=a%m;while(b>0){if(b&1)ans=(ans*a)%m;a=(a*a)%m;b=b/2;}return ans%m;}
ll ncr(ll n,ll r,ll m){if(r==0)return 1;ll fac[n+5];fac[0]=1;lp(i,1,n+1){fac[i]=fac[i-1]*i%m;}return (((fac[n]*abm(fac[r],m-2,m))%m)*(abm(fac[n-r],m-2,m)))%m;}
//---------------------------------------------------------------------------------------------------
//---------------------------------<<< DRAGON SIN MELIODAS >>>---------------------------------------
//---------------------------------------------------------------------------------------------------
int main()
{
KATAI_GAND_FAD_SPEED
ll ans = 0;
ll n; cin >> n;
ll r = (n + 1) / 2;
ll i = -1 * r;
for ( ; i < r + 1; i+=1)
{
ll b1 = abs(i) , b2 = 0;
while ((b1 + b2) < n + 1)
{
ll y = b1 + b2 , z = n - y;
if (abs(z- y) < 2)
ans = ans + z + 1;
b2+=1;
b1+=1;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int GCD(int a, int b) {
if (!a) return b;
return GCD(b % a, a);
}
void init() {}
int grid[111][111], n;
bool allE(int a, int b) {
for (int i = 0; i < n; i++) {
if (!grid[a][i]) return false;
}
for (int i = 0; i < n; i++) {
if (!grid[i][b]) return false;
}
return true;
}
bool impos() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (allE(i, j)) return true;
}
}
return false;
}
vector<pair<int, int> > ans;
void solve() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (!grid[i][j]) {
ans.push_back(make_pair(i, j));
break;
}
}
}
if (ans.size() != n) {
ans.clear();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (!grid[j][i]) {
ans.push_back(make_pair(j, i));
break;
}
}
}
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first + 1 << " " << ans[i].second + 1 << "\n";
}
}
int main() {
cin >> n;
string str;
for (int i = 0; i < n; i++) {
cin >> str;
for (int j = 0; j < n; j++) {
grid[i][j] = str[j] == 'E';
}
}
if (impos()) {
puts("-1");
} else {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const* argv[]) {
int n;
pair<char, int> a[105];
int pres[105];
cin >> n;
memset(a, 0, sizeof a);
memset(pres, 0, sizeof pres);
for (int i = 0; i <= n + 1; ++i) pres[i] = 0;
for (int i = 1; i <= n; ++i) {
char c;
int x;
cin >> c >> x;
a[i] = {c, x};
}
int sol = -22;
int vis[105];
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; ++i) {
if (a[i].first == '-' && !vis[i])
for (int j = i - 1; j >= 0; --j) {
if (j == 0)
pres[j]++;
else if (a[j].first == '+' && a[i].second == a[j].second)
break;
else
pres[j]++;
}
else
for (int j = i; j <= n + 1; ++j) {
if (j == n + 1)
pres[j]++;
else if (a[j].first == '-' && a[i].second == a[j].second) {
vis[j] = 1;
break;
} else
pres[j]++;
}
}
for (int i = 0; i <= n + 1; ++i) {
sol = max(sol, pres[i]);
}
cout << sol << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
long long s, c;
int a[100100], b[100100], n, m, i, j, l, r, m1, m2;
long long f(int x) {
long long s = 0;
for (int i = 0; i < n; i++)
if (a[i] < x) s += (long long)x - (long long)a[i];
for (int i = 0; i < m; i++)
if (b[i] > x) s += (long long)b[i] - (long long)x;
return s;
}
int main() {
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (!l || a[i] < l) l = a[i];
if (!r || a[i] > r) r = a[i];
}
for (i = 0; i < m; i++) {
scanf("%d", &b[i]);
if (!l || b[i] < l) l = b[i];
if (!r || b[i] > r) r = b[i];
}
while (r >= l + 3) {
m1 = l + (r - l) / 3;
m2 = r - (r - l) / 3;
if (f(m1) > f(m2))
l = m1;
else
r = m2;
}
s = f(l);
for (i = l + 1; i <= r; i++) {
c = f(i);
if (c < s) s = c;
}
printf("%I64d\n", s);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
const long long INF = 1e16;
const int K = 32;
int mx[N][N];
int ans[N][N];
pair<int, int> r[N][N];
pair<int, int> down[N][N];
int n, m, q;
pair<int, int> real(pair<int, int> q) {
pair<int, int> t = make_pair(0, 0);
for (int i = 0; i < q.first; i++) {
t = down[t.first][t.second];
}
for (int j = 0; j < q.second; j++) {
t = r[t.first][t.second];
}
return t;
}
int main() {
scanf(" %d %d %d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf(" %d", &mx[i][j]);
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
r[i][j] = make_pair(i, j + 1);
down[i][j] = make_pair(i + 1, j);
}
}
for (int i = 0; i < q; i++) {
int a, b;
int c, d;
int h, w;
scanf("%d %d %d %d %d %d", &a, &b, &c, &d, &h, &w);
pair<int, int> q1 = real(make_pair(a - 1, b));
pair<int, int> q2 = real(make_pair(c - 1, d));
pair<int, int> q3 = real(make_pair(a + h - 1, b));
pair<int, int> q4 = real(make_pair(c + h - 1, d));
for (int j = 0; j < w; j++) {
swap(down[q1.first][q1.second], down[q2.first][q2.second]);
swap(down[q3.first][q3.second], down[q4.first][q4.second]);
q1 = r[q1.first][q1.second];
q2 = r[q2.first][q2.second];
q3 = r[q3.first][q3.second];
q4 = r[q4.first][q4.second];
}
pair<int, int> p1 = real(make_pair(a, b - 1));
pair<int, int> p2 = real(make_pair(c, d - 1));
pair<int, int> p3 = real(make_pair(a, b + w - 1));
pair<int, int> p4 = real(make_pair(c, d + w - 1));
for (int j = 0; j < h; j++) {
swap(r[p1.first][p1.second], r[p2.first][p2.second]);
swap(r[p3.first][p3.second], r[p4.first][p4.second]);
p1 = down[p1.first][p1.second];
p2 = down[p2.first][p2.second];
p3 = down[p3.first][p3.second];
p4 = down[p4.first][p4.second];
}
}
pair<int, int> t = make_pair(0, 0);
for (int i = 0; i <= n; i++) {
pair<int, int> nt = t;
for (int j = 0; j <= m; j++) {
ans[i][j] = mx[nt.first][nt.second];
nt = r[nt.first][nt.second];
}
t = down[t.first][t.second];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%d ", ans[i][j]);
}
printf("\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int N = 2e3;
using namespace std;
int n1, n2, m, id1[N + 5], id2[N + 5], S, T, idc, d1[N + 5], d2[N + 5], lim,
num1[N + 5], num2[N + 5];
vector<int> ans[N + 5];
namespace F {
const int N = 3e6;
const long long inf = 2e18;
struct edges {
int to;
long long cost;
} edge[N * 2 + 5];
int nxt[N * 2 + 5], head[N + 5], edge_cnt = 1, dis[N + 5], q[N + 5], cur[N + 5],
S, T;
void add_edge(int u, int v, long long w) {
edge[++edge_cnt] = (edges){v, w};
nxt[edge_cnt] = head[u];
head[u] = edge_cnt;
}
void add(int u, int v, long long w) {
add_edge(u, v, w);
add_edge(v, u, 0);
}
int bfs() {
for (int i = 1; i <= idc; i++) cur[i] = head[i], dis[i] = 0;
int l = 1, r = 0;
dis[S] = 1;
q[++r] = S;
while (l <= r) {
int u = q[l++];
for (int i = head[u]; i; i = nxt[i]) {
int v = edge[i].to, w = edge[i].cost;
if (w && !dis[v]) {
dis[v] = dis[u] + 1;
q[++r] = v;
}
}
}
return dis[T];
}
long long dfs(int u, long long flow) {
if (u == T) return flow;
long long sm = 0;
for (int &i = cur[u]; i; i = nxt[i]) {
int v = edge[i].to;
long long w = edge[i].cost;
if (dis[v] == dis[u] + 1 && w) {
long long res = dfs(v, min(w, flow));
edge[i].cost -= res;
edge[i ^ 1].cost += res;
sm += res;
flow -= res;
if (!flow) break;
}
}
return sm;
}
long long dinic(int s, int t) {
S = s;
T = t;
long long ans = 0;
while (bfs()) ans += dfs(S, inf);
return ans;
}
void clear() {
edge_cnt = 1;
for (int i = 1; i <= idc; i++) head[i] = 0;
idc = 0;
}
void update(int k) {
for (int i = 1; i <= m; i++)
if (edge[i << 1].cost == 1) ans[k].push_back(i);
}
} // namespace F
int main() {
scanf("%d%d%d", &n1, &n2, &m);
S = ++idc;
T = ++idc;
for (int i = 1; i <= n1; i++) id1[i] = ++idc;
for (int i = 1; i <= n2; i++) id2[i] = ++idc;
int u, v;
lim = m + 5;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
F::add(id1[u], id2[v], 1);
d1[u]++;
d2[v]++;
}
for (int i = 1; i <= n1; i++) lim = min(lim, d1[i]);
for (int i = 1; i <= n2; i++) lim = min(lim, d2[i]);
for (int i = 1; i <= n1; i++) {
F::add(S, id1[i], d1[i] - lim);
num1[i] = F::edge_cnt ^ 1;
}
for (int i = 1; i <= n2; i++) {
F::add(id2[i], T, d2[i] - lim);
num2[i] = F::edge_cnt ^ 1;
}
int x = F::dinic(S, T);
F::update(lim);
for (int i = 1; i <= lim; i++) {
for (int j = 1; j <= n1; j++) F::edge[num1[j]].cost++;
for (int j = 1; j <= n2; j++) F::edge[num2[j]].cost++;
x = F::dinic(S, T);
F::update(lim - i);
}
for (int i = 0; i <= lim; i++) {
printf("%d ", ans[i].size());
for (int j = 0; j < ans[i].size(); j++) printf("%d ", ans[i][j]);
putchar(10);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
pair<int, int> P[N];
int a[N], b[N];
int c[N], d[N];
int main() {
int n, h;
scanf("%d%d", &n, &h);
int pre = 0;
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
P[i] = make_pair(x, y);
a[i] = y - x;
b[i] = x - pre;
pre = y;
}
d[0] = 0;
c[0] = 0;
for (int i = 1; i <= n; i++) c[i] = c[i - 1] + b[i], d[i] = d[i - 1] + a[i];
int ans = 0;
for (int i = 1; i <= n; i++) {
int x = lower_bound(c + 1, c + n + 1, c[i] + h) - c;
ans = max(ans, d[x - 1] - d[i - 1]);
}
printf("%d\n", ans + h);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int SZ = 35000;
int t, n;
int a[SZ];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int mn = 2e9;
int ans = 1;
for (int i = 0; i < n; ++i) {
mn = min(mn, a[i]);
a[i] -= mn;
if (a[i] > 0) {
for (int j = i + 1; j < n; ++j) {
if (a[j] < a[j - 1]) {
ans = 0;
break;
}
int h = min(a[j] - a[j - 1], mn);
a[j] -= h;
mn = h;
}
break;
}
}
cout << (ans ? "YES" : "NO") << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int arr = 2e5 + 10;
const int ar = 2e3 + 10;
const long double pi = acos(-1);
const long double eps = 1e-10;
const long long md = 1e9 + 7;
struct solver {
const int M = 22;
int n;
vector<vector<int>> reb;
vector<vector<int>> pred;
vector<int> d;
solver() {
n = 0;
reb.clear();
pred.clear();
d.clear();
}
solver(int n) {
this->n = n;
reb.assign(n, {});
pred.assign(n, vector<int>(M, 0));
d.assign(n, 0);
}
void add_edge(int u, int v) {
reb[u].push_back(v);
reb[v].push_back(u);
}
void dfs(int now, int p) {
pred[now][0] = p;
for (int i = 1; i < M; i++) {
pred[now][i] = pred[pred[now][i - 1]][i - 1];
}
for (auto wh : reb[now]) {
if (wh != p) {
d[wh] = d[now] + 1;
dfs(wh, now);
}
}
}
void build() { dfs(0, 0); }
int lca(int u, int v) {
if (d[u] > d[v]) {
swap(u, v);
}
for (int i = M - 1; i >= 0; i--) {
if (d[pred[v][i]] >= d[u]) {
v = pred[v][i];
}
}
if (u == v) {
return u;
}
for (int i = M - 1; i >= 0; i--) {
if (pred[u][i] != pred[v][i]) {
u = pred[u][i];
v = pred[v][i];
}
}
return pred[u][0];
}
int dist(int u, int v) { return d[u] + d[v] - 2 * d[lca(u, v)]; }
};
vector<int> reb[arr];
bool bad[arr];
vector<vector<int>> comps;
map<pair<int, int>, int> used_edge;
map<pair<int, int>, bool> have_in_start_graph;
bool use_edge(int u, int v) {
if (u > v) {
swap(u, v);
}
return used_edge[{u, v}];
}
void set_use_edge(int u, int v) {
if (u > v) {
swap(u, v);
}
used_edge[{u, v}] = 1;
}
int timer = 0;
bool use[arr];
int tin[arr];
int tup[arr];
set<pair<int, int>> s;
void dfs(int now, int pred) {
use[now] = 1;
tin[now] = timer++;
tup[now] = tin[now];
int cnt_go = 0;
for (auto wh : reb[now]) {
if (wh == pred) {
continue;
}
if (use[wh]) {
tup[now] = min(tup[now], tin[wh]);
} else {
cnt_go++;
dfs(wh, now);
tup[now] = min(tup[now], tup[wh]);
if (tup[wh] >= tin[now]) {
if (now != pred) {
bad[now] = 1;
}
vector<int> cur_comp;
while (!s.empty() && s.rbegin()->first >= tin[wh]) {
auto kek = *s.rbegin();
s.erase(kek);
cur_comp.push_back(kek.second);
}
cur_comp.push_back(now);
comps.push_back(cur_comp);
}
}
}
s.insert(make_pair(tin[now], now));
if (now == pred && cnt_go > 1) {
bad[now] = 1;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m, q;
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
reb[u].push_back(v);
reb[v].push_back(u);
}
int last = n;
if (n * (n - 1) / 2 != m) {
dfs(1, 1);
solver S(n + (int)(comps.size()));
for (auto i : comps) {
for (auto j : i) {
S.add_edge(j, last);
}
last++;
}
S.build();
while (q--) {
int a, b;
cin >> a >> b;
a--;
b--;
cout << S.dist(a, b) / 2 << "\n";
}
} else {
while (q--) {
cout << 1 << "\n";
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 100;
string s[maxn];
vector<pair<int, int> > tmp;
int main(void) {
int n, k, x;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
cin >> s[i] >> k;
for (int j = 0; j < k; j++) {
scanf("%d", &x);
tmp.push_back(make_pair(x, i));
}
}
sort(tmp.begin(), tmp.end());
string ans;
int len = 1;
for (unsigned i = 0; i < tmp.size(); i++) {
int t1 = tmp[i].first, t2 = tmp[i].second;
while (t1 > len) {
ans += 'a';
len++;
}
for (unsigned j = len - t1; j < s[t2].length(); j++) {
ans += s[t2][j];
len++;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
vector<int> G[maxn];
int dp[302][maxn];
int A[maxn];
int B[maxn];
int main() {
int n, m, s, e;
int i, j, k;
scanf("%d%d%d%d", &n, &m, &s, &e);
for (i = 1; i <= n; i++) {
scanf("%d", &A[i]);
}
for (i = 1; i <= m; i++) {
scanf("%d", &B[i]);
G[B[i]].push_back(i);
}
memset(dp, -1, sizeof dp);
memset(dp[0], 0, sizeof dp[0]);
int d = s / e;
int ans = 0;
for (i = 1; i <= d; i++) {
for (j = i; j <= n; j++) {
dp[i][j] = dp[i][j - 1];
if (dp[i - 1][j - 1] != -1) {
vector<int>::iterator it;
it = lower_bound(G[A[j]].begin(), G[A[j]].end(), dp[i - 1][j - 1] + 1);
if (it != G[A[j]].end()) {
if (dp[i][j] == -1)
dp[i][j] = (*it);
else
dp[i][j] = min(dp[i][j], (*it));
}
}
if (dp[i][j] != -1 && i * e + j + dp[i][j] <= s) ans = max(ans, i);
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct Item {
int value[3];
};
int main() {
map<int, int> a;
set<pair<int, int> > b;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int v;
scanf("%d", &v);
a[v]++;
}
for (map<int, int>::iterator it = a.begin(); it != a.end(); it++) {
b.insert(make_pair(it->second, it->first));
}
vector<Item> ans;
while (a.size() >= 3) {
ans.resize(ans.size() + 1);
int* v = ans.back().value;
static pair<int, int> v2[3];
set<pair<int, int> >::reverse_iterator it = b.rbegin();
for (int i = 0; i < 3; i++) {
v2[i] = *it;
v[i] = it->second;
it++;
}
for (int i = 0; i < 3; i++) {
b.erase(v2[i]);
}
for (int i = 0; i < 3; i++) {
v2[i].first--;
if (v2[i].first > 0) {
b.insert(v2[i]);
a[v2[i].second]--;
} else {
a.erase(v2[i].second);
}
}
sort(v, v + 3, greater<int>());
}
printf("%d\n", (int)((ans).size()));
for (int i = 0; i < (int)((ans).size()); i++) {
printf("%d %d %d\n", ans[i].value[0], ans[i].value[1], ans[i].value[2]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1000005], b[1000005];
int m, t[1000005], p[1000005];
bool seq(int i, int j, int n) {
int k = (j + 1) % n;
if (k == i || p[k] < 0) return false;
if (p[i] <= p[j] && (p[j] < p[k] || p[k] < p[i])) return true;
if (p[i] >= p[j] && (p[j] < p[k] && p[k] < p[i])) return true;
return false;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", a + i);
fill_n(t, 1000005, -1);
for (int i = 0; i < m; i++) {
scanf("%d", b + i);
t[b[i]] = i;
}
for (int i = 0; i < n; i++) p[i] = t[a[i]];
int ans = 0;
for (int i = 0, j = 0; i < n; i++) {
if (p[i] < 0) continue;
if (j <= i) j = i;
while (seq(i, j % n, n)) j++;
ans = max(ans, j - i + 1);
}
printf("%d\n", ans);
}
| 6 |
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, m;
scanf("%d%d", &n, &m);
m = std::min(m, n / 2);
int l = 0, r = n, ans;
while (l <= r) {
int mid = l + r >> 1;
long long rem = (long long)mid * m, x = n, y = 1;
for (int i = 0; i <= mid; i++) {
rem -= i * std::min(x, y);
x -= std::min(x, y);
y = y * (mid - i) / (i + 1);
if (rem < 0 || !x) break;
}
if (rem < 0 || x)
l = mid + 1;
else {
ans = mid;
r = mid - 1;
}
}
printf("%d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int h1, a1, c1, h2, a2, n = 0;
vector<int> v;
cin >> h1 >> a1 >> c1;
cin >> h2 >> a2;
while (true) {
if (h2 <= a1) {
v.push_back(0);
n++;
break;
} else if (h1 > a2) {
h1 -= a2;
v.push_back(0);
h2 -= a1;
} else {
h1 += c1;
h1 -= a2;
v.push_back(1);
}
n++;
}
cout << n << endl;
for (long long int i = 0; i < v.size(); i++) {
if (v[i])
cout << "HEAL\n";
else
cout << "STRIKE\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
void solve() {
long long k;
cin >> k;
if (k <= 36) {
if (k == 1) {
cout << 4 << "\n";
} else if (k == 2) {
cout << 8 << "\n";
} else if (k % 2 == 0) {
long long r = k / 2;
for (long long i = 1; i <= r; i++) {
cout << '8';
}
cout << "\n";
} else {
for (long long i = 1; i <= k / 2; i++) {
cout << '8';
}
cout << 6 << "\n";
}
} else {
cout << -1 << "\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int64_t M = 1e2 + 5;
int64_t n, t[M], w[M], dp[M][20005], totalW;
int64_t solve(int64_t idx, int64_t wt) {
if (idx > n) {
if (wt >= 0) return 0;
return 1e9;
}
if (dp[idx][1001 + wt] != -1) return dp[idx][1001 + wt];
int64_t ans = t[idx] + solve(idx + 1, wt + t[idx]);
ans = min(ans, solve(idx + 1, wt - w[idx]));
return dp[idx][1001 + wt] = ans;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int64_t i = 1; i <= n; i++) cin >> t[i] >> w[i];
memset(dp, -1, sizeof(dp));
cout << solve(1, 0);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int kase, n;
int cnt1[30], cnt2[30];
char s[maxn], t[maxn];
int main() {
scanf("%d", &kase);
while (kase--) {
scanf("%d", &n);
scanf("%s %s", s + 1, t + 1);
memset(cnt1, 0, sizeof cnt1);
memset(cnt2, 0, sizeof cnt2);
for (int i = 1; i <= n; i++) {
cnt1[s[i] - 'a' + 1]++;
cnt2[t[i] - 'a' + 1]++;
}
bool flag = true;
for (int i = 1; i <= 26; i++)
if (cnt1[i] != cnt2[i]) flag = false;
if (!flag) {
puts("-1");
continue;
}
int ans = 110;
for (int i = 1; i <= n; i++) {
int k = i, sum = 0;
for (int j = 1; j <= n; j++)
if (t[k] == s[j] && k <= n) k++, sum++;
ans = min(ans, n - sum);
}
printf("%d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool g(pair<long long, long long> a, pair<long long, long long> b) {
return a.first < b.first;
}
int main() {
int n;
cin >> n;
vector<pair<long long, long long> > v(n);
for (int i = 0; i < n; i++) cin >> v[i].first;
for (int i = 0; i < n; i++) cin >> v[i].second;
sort(v.begin(), v.end(), g);
long long b = 0;
for (int i = 0; i < n - 1; i++) {
if (v[i].first == v[i + 1].first) {
b += v[i].second + v[i + 1].second;
for (int j = 0; j < i; j++) {
if (((v[j].first ^ v[i].first) & v[j].first) == 0) {
b += v[j].second;
v[j].second = 0;
}
}
v[i].second = 0;
v[i + 1].second = 0;
}
}
cout << b;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int t, n, k;
bool ok;
bool used[26];
char s[1000010], a[1000010], b[1000010];
map<char, char> mp;
bool check() {
for (register int i = 1; i <= n; i++) {
if (mp[s[i]] < b[i]) {
return true;
} else if (mp[s[i]] > b[i]) {
return false;
}
}
return true;
}
void dfs(int pos, bool lima, bool limb) {
if (ok) return;
if (pos == n + 1) {
int tmp1[26], tmp2[26], cnt = 0;
for (register int i = 0; i < k; i++) {
if (mp[(char)('a' + i)] == '$') {
tmp1[++cnt] = i;
for (register int j = 0; j < k; j++) {
if (!used[j]) {
tmp2[cnt] = j;
used[j] = true;
mp[(char)('a' + i)] = (char)('a' + j);
break;
}
}
}
}
printf("YES\n");
for (register int i = 0; i < k; i++) {
printf("%c", mp[(char)('a' + i)]);
}
printf("\n");
ok = true;
return;
}
if (mp[s[pos]] != '$') {
if ((lima && mp[s[pos]] < a[pos]) || (limb && mp[s[pos]] > b[pos])) {
return;
} else {
dfs(pos + 1, lima && mp[s[pos]] == a[pos], limb && mp[s[pos]] == b[pos]);
if (ok) return;
}
} else {
int st = lima ? a[pos] - 'a' : 0;
int up = limb ? b[pos] - 'a' : k - 1;
for (register int i = st; i <= up; i++) {
if (ok) return;
if (!used[i]) {
mp[s[pos]] = (char)('a' + i);
used[i] = true;
dfs(pos + 1, lima && i == st, limb && i == up);
if (ok) return;
used[i] = false;
mp[s[pos]] = '$';
}
}
}
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &k);
scanf("%s", s + 1);
scanf("%s", a + 1);
scanf("%s", b + 1);
n = strlen(s + 1);
memset(used, false, sizeof(used));
ok = false;
for (register int i = 0; i < 26; i++) {
mp[(char)('a' + i)] = '$';
}
dfs(1, true, true);
if (!ok) {
printf("NO\n");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int cnt[11];
int main() {
string s;
cin >> s;
for (int ch = 0; ch < s.length(); ch++) cnt[s[ch] - '0']++;
int len = (int)s.size();
if (len <= 2) {
int n = (s[0] - '0') * 10 + (s[1] - '0');
if (n == 25 || n == 50 || n == 75)
printf("0\n");
else if (n == 52 || n == 57)
printf("1\n");
else
printf("-1\n");
return 0;
}
int ans = INT_MAX;
if (cnt[0] >= 2) {
string t = s;
int tmp = 0;
int index;
for (int i = len - 1; i >= 0; i--) {
if (t[i] == '0') {
index = i;
break;
}
}
for (int i = index + 1; i <= len - 1; i++) swap(t[i], t[i - 1]), tmp++;
for (int i = len - 2; i >= 0; i--) {
if (t[i] == '0') {
index = i;
break;
}
}
for (int i = index + 1; i <= len - 2; i++) swap(t[i], t[i - 1]), tmp++;
ans = min(ans, tmp);
}
if (cnt[2] >= 1 && cnt[5] >= 1) {
string t = s;
int tmp = 0;
int index;
for (int i = len - 1; i >= 0; i--) {
if (t[i] == '5') {
index = i;
break;
}
}
for (int i = index + 1; i <= len - 1; i++) swap(t[i], t[i - 1]), tmp++;
for (int i = len - 2; i >= 0; i--) {
if (t[i] == '2') {
index = i;
break;
}
}
for (int i = index + 1; i <= len - 2; i++) swap(t[i], t[i - 1]), tmp++;
int cnt = 0;
for (int i = 0; i < len; i++) {
if (t[i] == '0')
cnt++;
else
break;
}
if (len - cnt >= 3) ans = min(ans, tmp + cnt);
}
if (cnt[0] >= 1 && cnt[5] >= 1) {
string t = s;
int tmp = 0;
int index;
for (int i = len - 1; i >= 0; i--) {
if (t[i] == '0') {
index = i;
break;
}
}
for (int i = index + 1; i <= len - 1; i++) swap(t[i], t[i - 1]), tmp++;
for (int i = len - 2; i >= 0; i--) {
if (t[i] == '5') {
index = i;
break;
}
}
for (int i = index + 1; i <= len - 2; i++) swap(t[i], t[i - 1]), tmp++;
int cnt = 0;
for (int i = 0; i < len; i++) {
if (t[i] == '0')
cnt++;
else
break;
}
if (len - cnt >= 3) ans = min(ans, tmp + cnt);
}
if (cnt[5] >= 1 && cnt[7] >= 1) {
string t = s;
int tmp = 0;
int index;
for (int i = len - 1; i >= 0; i--) {
if (t[i] == '5') {
index = i;
break;
}
}
for (int i = index + 1; i <= len - 1; i++) swap(t[i], t[i - 1]), tmp++;
for (int i = len - 2; i >= 0; i--) {
if (t[i] == '7') {
index = i;
break;
}
}
for (int i = index + 1; i <= len - 2; i++) swap(t[i], t[i - 1]), tmp++;
int cnt = 0;
for (int i = 0; i < len; i++) {
if (t[i] == '0')
cnt++;
else
break;
}
if (len - cnt >= 3) ans = min(ans, tmp + cnt);
}
if (ans == INT_MAX)
printf("-1\n");
else
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, q, s, w, v, ans, i, j;
int a[100010], b[100010], t[5], f[5], c[100010];
int ib, ic, jam, cur;
priority_queue<int> Q, F;
int main() {
cin >> k;
cin >> f[1] >> f[2] >> f[3] >> t[1] >> t[2] >> t[3];
for (i = 1; i <= k / f[1]; i++) {
jam += t[1];
for (j = 1; j <= f[1]; j++) {
ib++;
b[ib] = jam;
}
}
jam += t[1];
for (i = 1; i <= k % f[1]; i++) {
ib++;
b[ib] = jam;
}
for (i = 1; i <= min(f[2], k); i++) {
Q.push(-b[i] - t[2]);
ic++;
c[ic] = -b[i] - t[2];
}
for (i = min(f[2], k) + 1; i <= ib; i++) {
jam = Q.top();
Q.pop();
Q.push(min(jam, -b[i]) - t[2]);
ic++;
c[ic] = (min(jam, -b[i]) - t[2]);
}
for (i = 1; i <= min(f[3], k); i++) {
F.push(c[i] - t[3]);
}
for (i = min(f[3], k) + 1; i <= ic; i++) {
jam = F.top();
F.pop();
F.push(min(jam, c[i]) - t[3]);
}
int pop;
while (!F.empty()) {
pop = F.top();
F.pop();
}
cout << -pop << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef struct graph {
list<int> edges[1001];
} graph;
void dfs(graph *g, int i, int group[], int gn) {
for (list<int>::iterator it = g->edges[i].begin(); it != g->edges[i].end();
it++) {
if (group[*it] == -1) {
group[*it] = gn;
dfs(g, *it, group, gn);
}
}
}
void printArray(int arr[], int n) {
for (int i = 1; i <= n; i++) cout << arr[i] << " ";
cout << endl;
}
int main() {
int n;
graph *g = new graph;
cin >> n;
bool flag = false;
int fin[1001], pref[1001], group[1001];
for (int i = 1; i <= n; i++) cin >> fin[i];
for (int i = 1; i <= n; i++) {
cin >> pref[i];
if (i + pref[i] <= n) {
g->edges[i].push_back(i + pref[i]);
g->edges[i + pref[i]].push_back(i);
}
if (i - pref[i] >= 1) {
g->edges[i].push_back(i - pref[i]);
g->edges[i - pref[i]].push_back(i);
}
}
fill_n(group, n + 1, -1);
int gn = 0;
for (int i = 1; i <= n; i++) {
if (group[i] == -1) {
group[i] = gn;
dfs(g, i, group, gn);
gn++;
}
}
for (int i = 1; i <= n; i++) {
if (group[i] == group[fin[i]]) {
} else {
flag = true;
cout << "NO" << endl;
break;
}
}
if (!flag) {
cout << "YES" << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<string, string> m;
string get_type(const string& type) {
if (type == "void") return "void";
if (type == "errtype") return "errtype";
if (m.count(type)) return m[type];
return "errtype";
}
string ref(const string& s) {
if (s == "errtype") return "errtype";
return s + "*";
}
string unref(const string& s) {
if (s == "errtype") return "errtype";
if (s[s.size() - 1] == '*') return s.substr(0, s.size() - 1);
return "errtype";
}
string parse(const string& s) {
int rp = s.size() - 1;
int dp = 0;
while (s[dp] == '&') dp++;
while (s[rp] == '*') rp--;
int nd = dp;
int nr = s.size() - rp - 1;
string type = s.substr(dp, rp - dp + 1);
type = get_type(type);
for (int i = 0; i < nr; ++i) type = ref(type);
for (int i = 0; i < nd; ++i) type = unref(type);
return type;
}
int main() {
int n;
while (cin >> n) {
for (int i = 0; i < n; ++i) {
string com;
cin >> com;
if (com == "typeof") {
string s;
cin >> s;
cout << parse(s) << endl;
} else if (com == "typedef") {
string a, b;
cin >> a >> b;
string res = parse(a);
m[b] = res;
}
}
}
}
| 5 |
#include<bits/stdc++.h>
#define int long long
#define rep(i,a,b) for(register int i=(a);i<=(b);i++)
#define per(i,a,b) for(register int i=(a);i>=(b);i--)
using namespace std;
const int N=2e5+9;
inline int read() {
register int x=0, f=1; register char c=getchar();
while(c<'0'||c>'9') {if(c=='-') f=-1; c=getchar();}
while(c>='0'&&c<='9') {x=(x<<3)+(x<<1)+c-48,c=getchar();}
return x*f;
}
int n,k,a[N],ans,s[N];
bool check(int kk,int p=n*2) {
rep(i,1,n) {
s[i]=s[i-1]+(a[i]>=kk?1:-1);
if(i>=k) {
p=min(p,s[i-k]);
if(s[i]-p>0) return 1;
}
}
rep(i,1,n) s[i]=0;
return 0;
}
signed main() {
n=read(), k=read();
rep(i,1,n) a[i]=read();
int l=1,r=n,ans=0;
while(l<=r) {
int mid=(l+r)/2;
if(check(mid)) l=mid+1, ans=mid;
else r=mid-1;
}
printf("%lld\n",ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int inp[100005][2];
class Node {
public:
int cnt;
long long sum[5];
};
Node seg[1000005];
void init(int x, int L, int R) {
seg[x].cnt = 0;
for (int i = 0; i < 5; i++) seg[x].sum[i] = 0;
}
inline void merge(int x) {
seg[x].cnt = seg[x * 2].cnt + seg[x * 2 + 1].cnt;
int m = seg[x * 2].cnt % 5;
for (int i = 0; i < 5; i++)
seg[x].sum[i] = seg[x * 2].sum[i] + seg[x * 2 + 1].sum[(i + 5 - m) % 5];
}
void goinsert(int x, int L, int R, int p, int v) {
if (L == R) {
seg[x].sum[0] = (long long)v;
seg[x].cnt = 1;
return;
} else {
int M = (L + R) / 2;
if (p <= M)
goinsert(x * 2, L, M, p, v);
else
goinsert(x * 2 + 1, M + 1, R, p, v);
merge(x);
}
}
void godelete(int x, int L, int R, int p) {
if (L == R) {
seg[x].sum[0] = 0;
seg[x].cnt = 0;
return;
} else {
int M = (L + R) / 2;
if (p <= M)
godelete(x * 2, L, M, p);
else
godelete(x * 2 + 1, M + 1, R, p);
merge(x);
}
}
int main(void) {
int n;
scanf("%d", &n);
map<int, int> v2x;
int i;
for (i = 0; i < n; i++) {
char s[100];
scanf("%s", s);
if (s[0] != 's') {
scanf("%d", &inp[i][1]);
v2x[inp[i][1]] = 1;
}
if (s[0] == 'a')
inp[i][0] = 1;
else if (s[0] == 'd')
inp[i][0] = 2;
else
inp[i][0] = 3;
}
int m = 0;
for (map<int, int>::iterator it = v2x.begin(); it != v2x.end(); it++) {
(it->second) = ++m;
}
init(1, 1, m);
for (i = 0; i < n; i++) {
if (inp[i][0] == 1)
goinsert(1, 1, m, v2x[inp[i][1]], inp[i][1]);
else if (inp[i][0] == 2)
godelete(1, 1, m, v2x[inp[i][1]]);
else
cout << seg[1].sum[2] << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt, ans[100005], belong[100005][2];
bool mark[100005];
struct Edge {
int to, num, size;
Edge *next;
} * mat[2][100005], edges[100005 * 4];
void link(int g, int x, int to, int num = 0) {
edges[cnt].to = to;
edges[cnt].num = num;
edges[cnt].next = mat[g][x];
mat[g][x] = &edges[cnt++];
}
int find_root(int x, int father, int size, int &root, int &ma) {
int ret = 1, k = -1;
for (Edge *p = mat[0][x]; p; p = p->next) {
int to = p->to;
if (to == father || mark[to]) continue;
int g = find_root(to, x, size, root, ma);
k = max(k, g);
ret += g;
}
k = max(k, size - ret);
if (k < ma) {
ma = k;
root = x;
}
return ret;
}
int fill(int x, int father, int root, int son) {
belong[x][0] = root;
belong[x][1] = son;
int ret = 1;
for (Edge *p = mat[0][x]; p; p = p->next) {
int to = p->to;
if (to == father || mark[to]) continue;
ret += fill(to, x, root, son);
}
return ret;
}
int updata(int x, int father) {
int ret = 0;
for (Edge *p = mat[0][x]; p; p = p->next) {
int to = p->to;
if (to == father || mark[to]) continue;
int g = updata(to, x);
ans[p->num] += g;
ret += g;
}
for (Edge *p = mat[1][x]; p; p = p->next) {
int to = p->to;
if (belong[x][0] == belong[to][0] && belong[x][1] != belong[to][1]) ret++;
}
return ret;
}
void dfs(int x) {
mark[x] = true;
int son = 0;
belong[x][0] = x;
belong[x][1] = 0;
for (Edge *p = mat[0][x]; p; p = p->next) {
int to = p->to;
if (mark[to]) continue;
son++;
p->size = fill(to, x, x, son);
}
for (Edge *p = mat[0][x]; p; p = p->next) {
int to = p->to;
if (mark[to]) continue;
int g = updata(to, x);
ans[p->num] += g;
}
for (Edge *p = mat[0][x]; p; p = p->next) {
int to = p->to;
if (mark[to]) continue;
int root = -1, ma = 0x7fffffff;
find_root(to, x, p->size, root, ma);
dfs(root);
}
}
int main() {
int x, y;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &x, &y);
link(0, x, y, i);
link(0, y, x, i);
}
int k;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
scanf("%d%d", &x, &y);
link(1, x, y);
link(1, y, x);
}
int root, ma = 0x7fffffff;
find_root(1, -1, n, root, ma);
dfs(root);
for (int i = 0; i < n - 1; i++)
printf("%d%c", ans[i], (i < n - 2) ? ' ' : '\n');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ara[1000005];
long long ans[1000005];
int main() {
long long i, j, k;
long long n, q, p1, p2;
long long pos1, pos2, x;
cin >> n >> q;
p1 = 1;
p2 = 2;
pos1 = 1;
pos2 = 2;
for (i = 0; i < q; ++i) {
scanf("%I64d", &k);
if (k == 2) {
if (pos1 % 2)
p1++;
else
p1--;
if (pos2 % 2)
p2++;
else
p2--;
pos1 = (pos1 == 1) ? 2 : 1;
pos2 = (pos2 == 1) ? 2 : 1;
} else {
scanf("%I64d", &x);
if (x < 0) {
x *= -1;
if (p1 - x > 0)
p1 -= x;
else
p1 = n - (x - p1);
if (p2 - x > 0)
p2 -= x;
else
p2 = n - (x - p2);
} else if (x > 0) {
if (p1 + x <= n)
p1 += x;
else
p1 = x - (n - p1);
if (p2 + x <= n)
p2 += x;
else
p2 = x - (n - p2);
}
if (p1 % 2)
pos1 = 1;
else
pos1 = 2;
if (p2 % 2)
pos2 = 1;
else
pos2 = 2;
}
}
long long t1 = 1, t2 = 2;
for (i = p1, j = p2, k = 1; k <= n / 2;
++k, i += 2, j += 2, t1 += 2, t2 += 2) {
if (i > n) i = i - n;
if (j > n) j = j - n;
ans[i] = t1;
ans[j] = t2;
}
for (i = 1; i <= n; ++i) printf("%I64d ", ans[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
inline bool chkmax(T& a, U b) {
return (a < b) ? (a = b, true) : false;
}
template <class T, class U>
inline bool chkmin(T& a, U b) {
return (a > b) ? (a = b, true) : false;
}
template <class T>
inline vector<T> uniq(vector<T> vec) {
sort((vec).begin(), (vec).end()),
vec.erase(unique((vec).begin(), (vec).end()), end(vec));
return vec;
}
void Main();
int32_t main(int argc, char** argv) {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int T = 1;
while (T--) Main();
}
const int Move[][2] = {{1, 0}, {0, 1}};
void Main() {
int n;
cin >> n;
vector<pair<int, int> > ans(1, {1, 1});
for (int i = 1; i < n; i++) {
pair<int, int> cur;
cur.first = ans.back().first + Move[i & 1][0];
cur.second = ans.back().second + Move[i & 1][1];
ans.push_back(cur);
}
cout << max(ans.back().first, ans.back().second) << "\n";
for (auto& x : ans) cout << x.first << " " << x.second << "\n";
}
| 1 |
#include <bits/stdc++.h>
const long long N = 200010;
long long arr[N];
using namespace std;
bool binasea(long long arr[], long long n, long long key) {
long long hi = n - 1, lo = 0, mid;
while (lo <= hi) {
mid = lo + (hi - lo) / 2;
if (arr[mid] == key)
return true;
else if (arr[mid] > key)
hi = mid - 1;
else
lo = mid + 1;
}
return 0;
}
long long power(long long a, long long b, long long mod) {
long long res = 1;
while (b) {
if (b % 2) res = ((res % mod) * (a % mod)) % mod;
b /= 2;
a = ((a % mod) * (a % mod)) % mod;
}
return res;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
signed main() {
ios_base::sync_with_stdio(NULL);
cin.tie(0);
cout.tie(0);
long long t, n, k;
cin >> t;
while (t--) {
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
long long ans = arr[n - 1];
for (long long i = 0; i < k; i++) {
ans += arr[n - 2 - i];
}
cout << ans << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000 * 1000 * 1000;
const int size = 100;
int ans[size][size][size];
int way[size][size];
int n, k, m;
int main() {
cin >> n >> k;
cin >> m;
if (k == 1) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) way[i][j] = inf;
for (int i = 0; i < m; i++) {
int u, v, c;
cin >> u >> v >> c;
u--, v--;
way[u][v] = min(way[u][v], c);
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) ans[0][i][j] = 0;
int rans = inf;
for (int i = 1; i < k; i++)
for (int j = 0; j < n; j++)
for (int p = 0; p < n; p++) {
ans[i][j][p] = inf;
for (int q = min(j, p); q <= max(j, p); q++) {
if (q != j) {
ans[i][j][p] =
min(ans[i][j][p],
min(ans[i - 1][q][p], ans[i - 1][q][j + (q > j ? 1 : -1)]) +
way[j][q]);
}
}
if (i == k - 1) {
rans = min(rans, ans[i][j][p]);
}
}
if (rans > inf / 2)
cout << -1 << endl;
else
cout << rans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k, l;
cin >> n >> l >> k;
string s;
cin >> s;
sort(s.begin(), s.end());
int ix = 0;
char ans[n][l + 1];
for (int i = 0; i < n; i++) ans[i][l] = '\0';
char last = ' ';
for (int charIx = 0; charIx < l; charIx++) {
if (charIx == 0) {
for (int j = 0; j < k; j++) {
ans[j][charIx] = s[ix++];
}
} else {
for (int line = 0; line < k; line++) {
if (ans[line][charIx - 1] == last)
ans[line][charIx] = s[ix++];
else
ans[line][charIx] = ' ';
}
}
last = ans[k - 1][charIx];
}
for (int line = 0; line < k; line++) {
for (int c = 0; c < l; c++) {
if (ans[line][c] == ' ') ans[line][c] = s[ix++];
}
}
for (int line = k; line < n; line++) {
for (int c = 0; c < l; c++) {
ans[line][c] = s[ix++];
}
}
for (auto cc : ans) cout << cc << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cin >> a[i][j];
}
int sum = 0;
for (int i = 0; i < n; i++)
sum += (a[i][n / 2] + a[n / 2][i] + a[i][i] + a[i][n - 1 - i]);
cout << sum - (3 * a[n / 2][n / 2]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, xo, yo, ans, side;
string s;
bool over(int a, int b) { return b > a; }
bool under(int a, int b) { return b < a; }
void solve() {
cin >> n >> s;
for (int i = int(0); i <= int(n - 1); i++) {
if (s[i] == 'U') y = yo + 1;
if (s[i] == 'R') x = xo + 1;
if (!over(xo, yo) and over(x, y) and (side == 0 or side == 1)) {
ans++;
side = -1;
}
if (!under(xo, yo) and under(x, y) and (side == 0 or side == -1)) {
ans++;
side = 1;
}
xo = x, yo = y;
}
cout << ans - 1 << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.