solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c;
cin >> a >> b >> c;
long long ans = 0;
ans = c * 2;
if (a == b)
ans += (a * 2);
else {
ans += (min(a, b) * 2);
++ans;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int m[100005];
int main() {
memset(a, -1, sizeof a);
int n, x, cur = 0, rec = 0;
cin >> n;
string str;
cin >> str;
for (int i = 0; i < n; i++) cin >> m[i];
while (true) {
rec = cur;
if (str[cur] == '>') {
cur = m[cur] + cur;
} else {
cur = cur - m[cur];
}
if (cur > n - 1 || cur < 0) {
cout << "FINITE" << endl;
return 0;
}
if (a[rec] != -1) {
cout << "INFINITE" << endl;
return 0;
}
a[rec] = cur;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct E {
int to, w;
};
const int N = 2e5 + 5;
vector<E> g[N];
long long ans_g = 0, ans_b = 0;
int sz[N];
int n;
bool dfs(int node, int anc) {
int alone = 0;
for (E e : g[node]) {
if (e.to != anc) {
bool ok = dfs(e.to, node);
if (!ok) {
if (alone) {
ans_g += alone + e.w;
alone = 0;
} else {
alone = e.w;
}
}
}
}
if (alone) {
ans_g += alone;
return true;
}
return false;
}
int dive(int node, int anc) {
int sum = 1;
sz[node] = 1;
for (E e : g[node]) {
if (e.to != anc) {
int ret = dive(e.to, node);
sum += ret;
ans_b += ret * (long long)e.w;
sz[node] += sz[e.to];
}
}
while (sum > n - sz[node]) sum -= 2;
return sum;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int tt;
cin >> tt;
while (tt--) {
cin >> n;
n *= 2;
for (int i = 0; i < n - 1; i++) {
int x, y, z;
cin >> x >> y >> z;
x--, y--;
g[x].push_back({y, z});
g[y].push_back({x, z});
}
ans_b = 0;
ans_g = 0;
dfs(0, -1);
dive(0, -1);
cout << ans_g << " " << ans_b << "\n";
for (int i = 0; i < n; i++) g[i].clear();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[100005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int now = 0;
for (int i = 0; i < n - 1; i++) {
int pkt = 0;
while (i + pow(2, pkt) < n) {
pkt += 1;
}
pkt -= 1;
int tbh = pow(2, pkt);
arr[i + tbh] += arr[i];
cout << arr[i] + now << endl;
now += arr[i];
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int k1 = 0, k0 = 0;
char a[200];
cin >> a;
for (int i = 0; a[i]; i++) {
if (a[i] == '1') k1++;
if (a[i] == '0') k0++;
}
if (k1 == 0 || k0 == 0) {
int k = k1 + k0;
while (k--) cout << a[0];
cout << endl;
} else {
if (a[0] == '0') {
for (int i = 0; i < k1 + k0; i++) {
if (a[i] == '0') {
if (a[i + 1] == '1') {
cout << "01";
i++;
} else {
cout << "01";
}
} else
cout << "01";
}
} else {
for (int i = 0; i < k1 + k0; i++) {
if (a[i] == '1') {
if (a[i + 1] == '0') {
cout << "10";
i++;
} else {
cout << "10";
}
} else
cout << "10";
}
}
cout << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[1 << 20], t[1 << 20];
int n, nq, m, d;
int f[1 << 20];
int g[20][1 << 20], w[20][1 << 20];
pair<int, int> doit(int x, int e) {
int ww = 0;
for (int k = 0, ThxDem = 20; k < ThxDem; ++k)
if (e & (1 << k)) {
int y = g[k][x];
if (y < 0) {
ww += w[k][x];
x = y;
break;
}
x = y;
ww += 1 << k;
}
return make_pair(x, ww);
}
int main() {
scanf("%s%d", s, &nq);
n = strlen(s);
while (nq--) {
scanf("%d%d", &m, &d);
int c = 0;
for (int i = 0, ThxDem = d; i < ThxDem; ++i)
for (int j = i; j < m; j += d) f[j] = c++;
assert(c == m);
for (int i = 0, ThxDem = m; i < ThxDem; ++i)
g[0][i] = f[i] - 1, w[0][i] = g[0][i] < 0;
for (int k = 1, ThxDem = 20; k < ThxDem; ++k)
for (int i = 0, ThxDem = m; i < ThxDem; ++i) {
if (g[k - 1][i] < 0) {
g[k][i] = -1;
w[k][i] = w[k - 1][i];
} else {
g[k][i] = g[k - 1][g[k - 1][i]];
if (g[k][i] < 0) w[k][i] = (1 << (k - 1)) + w[k - 1][g[k - 1][i]];
}
}
for (int i = 0, ThxDem = n; i < ThxDem; ++i) {
int r;
if (i < m) {
auto p = doit(i, n - m + 1);
if (p.first >= 0)
r = n - m + p.first + 1;
else
r = p.second - 1;
} else {
auto p = doit(m - 1, n - i);
if (p.first >= 0)
r = n - m + p.first + 1;
else
r = i - m + p.second;
}
t[r] = s[i];
}
memcpy(s, t, n * sizeof(char));
puts(s);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, c = 0;
cin >> n;
int a[n];
for (i = 0; i < n; i++) cin >> a[i];
int max = a[0];
int min = a[0];
for (i = 1; i < n; i++) {
if (a[i] > max) {
max = a[i];
c++;
} else if (a[i] < min) {
min = a[i];
c++;
}
}
cout << c;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
while (cin >> a >> b >> c) {
long long l = 0, r = 100000000;
while (l <= r) {
long long t = (l + r) / 2;
long long w = b * t;
long long d = b * t;
bool ok = true;
while (d < a * c) {
if (w < a) {
ok = false;
break;
}
w -= a;
w += b;
d += b;
}
if (ok)
r = t - 1;
else
l = t + 1;
}
cout << l - 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long dp[501][501];
long b, a[500];
long long n, m;
long long mod;
long long ans = 0;
cin >> n >> m >> b >> mod;
for (int i = 0; i <= 500; i++)
for (int j = 0; j <= 500; j++) dp[i][j] = 0;
dp[0][0] = 1;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int ld = 0; ld < m; ld++) {
for (int bugs = 0; bugs + a[i] <= b; bugs++) {
dp[ld + 1][bugs + a[i]] =
(dp[ld + 1][bugs + a[i]] + dp[ld][bugs]) % mod;
}
}
}
for (int i = 0; i <= b; i++) {
ans = (ans + dp[m][i]) % mod;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110000;
const int M = 810000;
const int mod = 1e9 + 7;
const int L = 100000;
int n, l[N], r[N];
vector<int> g[N];
int dep[N];
long long sum[M];
int lz[M];
int sz[N], skip[N];
long long coef[N], inv[N];
long long pow_mod(long long a, long long e) {
long long res = 1;
for (; e; a = a * a % mod, e >>= 1)
if (e & 1) res = res * a % mod;
return res;
}
void pushdown(int k, int l, int r) {
if (lz[k] == 0) return;
int mid = (l + r) / 2;
sum[k << 1] = (sum[k << 1] + lz[k] * (long long)(mid - l + 1)) % mod;
sum[k << 1 | 1] = (sum[k << 1 | 1] + lz[k] * (long long)(r - mid)) % mod;
lz[k << 1] = (lz[k << 1] + lz[k]) % mod;
lz[k << 1 | 1] = (lz[k << 1 | 1] + lz[k]) % mod;
lz[k] = 0;
}
void update(int k) { sum[k] = (sum[k << 1] + sum[k << 1 | 1]) % mod; }
void add(int k, int l, int r, int a, int b, long long c) {
if (l == a && r == b) {
sum[k] = (sum[k] + (r - l + 1) * c) % mod;
lz[k] = (lz[k] + c) % mod;
return;
}
int mid = (l + r) / 2;
pushdown(k, l, r);
if (b <= mid)
add(k << 1, l, mid, a, b, c);
else if (a > mid)
add(k << 1 | 1, mid + 1, r, a, b, c);
else
add(k << 1, l, mid, a, mid, c), add(k << 1 | 1, mid + 1, r, mid + 1, b, c);
update(k);
}
long long ask(int k, int l, int r, int a, int b) {
if (l == a && r == b) return sum[k];
int mid = (l + r) / 2;
long long res = 0;
pushdown(k, l, r);
if (b <= mid)
res = ask(k << 1, l, mid, a, b);
else if (a > mid)
res = ask(k << 1 | 1, mid + 1, r, a, b);
else
res = (ask(k << 1, l, mid, a, mid) +
ask(k << 1 | 1, mid + 1, r, mid + 1, b)) %
mod;
update(k);
return res;
}
long long all = 1;
int son[N], pp[N];
void dfs(int x, int fa) {
dep[x] = dep[fa] + 1;
sz[x] = 1;
add(1, 1, L, l[x], r[x], coef[x]);
for (int i = 0; i < g[x].size(); i++)
if (g[x][i] != fa) {
dfs(g[x][i], x);
if (sz[g[x][i]] > sz[son[x]]) son[x] = g[x][i];
sz[x] += sz[g[x][i]];
}
}
long long ans;
vector<int> tmp;
void work(int x, int fa, int ff, int dep) {
if (ff == 1) {
long long tmp = ask(1, 1, L, l[x], r[x]) * inv[x] % mod;
tmp = tmp * (long long)(2 * dep) % mod;
ans = (ans + mod - tmp) % mod;
}
tmp.push_back(x);
for (int i = 0; i < g[x].size(); i++)
if (g[x][i] != fa) work(g[x][i], x, ff, dep);
}
void dfs2(int x, int fa, int kep) {
for (int i = 0; i < g[x].size(); i++)
if (g[x][i] != fa && son[x] != g[x][i]) dfs2(g[x][i], x, 0);
if (son[x]) dfs2(son[x], x, 1), skip[son[x]] = 1;
long long res = ask(1, 1, L, l[x], r[x]) * inv[x] % mod;
res = res * (long long)(2 * dep[x]) % mod;
ans = (ans + mod - res) % mod;
add(1, 1, L, l[x], r[x], coef[x]);
for (int i = 0; i < g[x].size(); i++)
if (g[x][i] != fa && !skip[g[x][i]]) {
tmp.clear();
work(g[x][i], x, 1, dep[x]);
for (auto y : tmp) add(1, 1, L, l[y], r[y], coef[y]);
}
if (son[x]) skip[son[x]] = 0;
if (!kep) {
add(1, 1, L, l[x], r[x], mod - coef[x]);
for (int i = 0; i < g[x].size(); i++)
if (g[x][i] != fa && !skip[g[x][i]]) {
tmp.clear();
work(g[x][i], x, 0, dep[x]);
for (auto y : tmp) add(1, 1, L, l[y], r[y], mod - coef[y]);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &l[i], &r[i]);
all = all * (r[i] - l[i] + 1) % mod;
}
for (int i = 1; i <= n; i++) {
inv[i] = pow_mod(r[i] - l[i] + 1, mod - 2);
coef[i] = inv[i] * all % mod;
}
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
for (int i = 1; i <= n; i++) {
long long res = ask(1, 1, L, l[i], r[i]);
res = (res + mod - ((r[i] - l[i] + 1) * coef[i] % mod)) % mod;
res = res * inv[i] % mod;
res = res * dep[i] % mod;
ans = (ans + res) % mod;
}
memset(sum, 0, sizeof(sum));
memset(lz, 0, sizeof(lz));
dfs2(1, 0, 1);
cout << ans << endl;
return 0;
}
| 9 |
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <cctype>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
#include <functional>
#include <unordered_map>
#include <unordered_set>
#include <ctime>
#include <iomanip>
#include <bitset>
#include <assert.h>
using namespace std;
#define int long long int
#define uint unsigned long long int
#define loop(i,a,b) for(int i=(int)a;i<(int)b;++i)
#define rloop(i,a,b) for(int i=(int)a;i<=(int)b;++i)
#define loopl(i,a,b) for(int i=(int)a;i<(int)b;++i)
#define loopr(i,a,b) for(int i=(int)a;i>=(int)b;--i)
#define count_1(n) __builtin_popcountint(n)
#define pb push_back
#define eb emplace_back
#define ab(a) (a<0)?(-1*a):a
#define pc putchar
#define gc getchar
#define mset(a,b,c) loop(i,0,b) a[i]=c
#define mp make_pair
#define itoc(c) ((char)(((int)'0')+c))
#define aint(p) p.begin(),p.end()
#define max(x,y) ((x>y)?x:y)
#define min(x,y) ((x<y)?x:y)
#define mid(s,e) (s+(e-s)/2)
#define vi vector<int>
#define vvi vector<vector<int>>
const int MOD = 1000000007;
int modpow(int a, int b, int mod) { int res = 1; for (; b; b >>= 1) { if (b & 1)res = res * a; res %= mod; a = a * a; a %= mod; }return res; }
int p(int a, int b) { int res = 1; for (; b; b >>= 1) { if (b & 1)res = res * a; a = a * a; }return res; }
int gcd(int a, int b, int& x, int& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
int x1, y1;
int d = gcd(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * (a / b);
return d;
}
void testcases(int test) {
int n; cin >> n;
set<int> ans; ans.insert(1);
set<int> temp; int prod = 1;
loop(i,2,n) {
int x,y;
int g = gcd(i, n, x, y);
if(g != 1) continue;
x = (x%n + n)%n;
//cout << x << " " << i << "\n";
if(x == i) { prod *= i; prod%=n; temp.insert(i); continue; }
ans.insert(x); ans.insert(i);
}
if(prod == 1) {
for(int i : temp) ans.insert(i);
}
cout << ans.size() << "\n";
//cout << ans.size() << " " << temp.size() << " " << prod << "\n";
prod = 1;
for(int i : ans) { prod*= i; prod%=n; cout << i << " "; }
assert(prod == 1);
//for(int i : temp) cout << i << " "; cout << "\n";
}
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
/* code */
int t;
// cin >> t;
t = 1;
loop(i,0,t) testcases(i);
/* end code */
} | 4 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("input.txt");
ofstream fout("output.txt");
inline void boostIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
boostIO();
long long int n, k;
cin >> n >> k;
vector<long long int> A(n * 2);
for (int i = 0; i < (n); ++i) {
cin >> A[i];
}
long long int Spes = A[0];
long long int Index = n;
for (int i = 1; i < n; ++i) {
if (A[i] < Spes) {
A[Index] = A[i];
++Index;
} else {
A[Index] = Spes;
++Index;
Spes = A[i];
}
}
if (A[n * 2 - 1] == 0) A[n * 2 - 1] = Spes;
int Min = A[0];
for (int i = 0; i < (n); ++i) {
long long int Temp = 0;
if (A[i] > Min) ++Temp;
long long int j = i + 1;
while (A[j] < A[i]) {
++Temp;
++j;
}
if (A[j] == A[i]) {
cout << A[i];
return 0;
}
if (Temp >= k) {
cout << A[i];
return 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, a, b, f1 = 0, f2 = 0;
cin >> n >> m >> a >> b;
long long r1 = (a - 1) / m;
long long r2 = (b - 1) / m;
long long c1 = (a - 1) % m;
long long c2 = (b - 1) % m;
if ((a - 1) % m == 0) f1 = 1;
if (b % m == 0 || b == n) f2 = 1;
if ((f1 && f2) || r1 == r2)
cout << "1\n";
else if ((f2 && !f1) || (f1 && !f2) || abs(r1 - r2) == 1 || ((c1 - c2) == 1))
cout << "2\n";
else
cout << "3\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int val[333333 * 5], mark[333333 * 5];
void down(int rt) {
if (mark[rt]) {
mark[rt << 1] = mark[rt << 1 | 1] = mark[rt];
val[rt << 1] = val[rt << 1 | 1] = mark[rt];
mark[rt] = 0;
}
}
void update(int rt, int l, int r, int L, int R, int x) {
if (L > R) return;
if (L <= l && R >= r) {
mark[rt] = x;
val[rt] = x;
return;
}
down(rt);
int mid = (l + r) / 2;
if (L <= mid) update(rt << 1, l, mid, L, R, x);
if (R > mid) update(rt << 1 | 1, mid + 1, r, L, R, x);
}
int find(int rt, int l, int r, int x) {
if (x == l && l == r) {
return val[rt];
}
down(rt);
int mid = (l + r) / 2;
if (x <= mid)
return find(rt << 1, l, mid, x);
else
return find(rt << 1 | 1, mid + 1, r, x);
}
struct PP {
int l, r, x;
} a[333333];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &a[i].l, &a[i].r, &a[i].x);
}
for (int i = m; i >= 1; i--) {
update(1, 1, n, a[i].l, a[i].x - 1, a[i].x);
update(1, 1, n, a[i].x + 1, a[i].r, a[i].x);
}
for (int i = 1; i <= n; i++) printf("%d ", find(1, 1, n, i));
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Rectangle {
pair<long long, long long> bl, tr;
Rectangle() {}
Rectangle(pair<long long, long long> bl, pair<long long, long long> tr)
: bl(bl), tr(tr) {}
};
Rectangle intersect(Rectangle A, Rectangle B) {
return Rectangle(
{max(A.bl.first, B.bl.first), max(A.bl.second, B.bl.second)},
{min(A.tr.first, B.tr.first), min(A.tr.second, B.tr.second)});
}
long long area(Rectangle R) {
if (R.tr.first < R.bl.first || R.tr.second < R.bl.second) return 0;
return (R.tr.first - R.bl.first + 1) * (R.tr.second - R.bl.second + 1);
}
long long NOB(Rectangle R) {
return ((R.bl.first & 1) == (R.bl.second & 1) ? area(R) / 2
: ceil((double)area(R) / 2));
}
long long NOW(Rectangle R) {
return ((R.bl.first & 1) != (R.bl.second & 1) ? area(R) / 2
: ceil((double)area(R) / 2));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
long long b = n * m / 2;
Rectangle A, B, C;
cin >> A.bl.first >> A.bl.second >> A.tr.first >> A.tr.second;
cin >> B.bl.first >> B.bl.second >> B.tr.first >> B.tr.second;
C = intersect(A, B);
b -= NOB(A);
b += NOW(B) + NOB(C);
cout << n * m - b << " " << b << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > adj[300001];
long long weight[300001], indice[300001], dist[300001];
struct comp {
bool operator()(pair<long long, long long> n1,
pair<long long, long long> n2) {
return n1.first > n2.first;
}
};
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
comp>
qu;
void dijkstra(int src) {
long long i, h, node;
dist[src] = 0;
qu.push(make_pair(0, src));
while (!qu.empty()) {
node = qu.top().second;
qu.pop();
h = adj[node].size();
for (i = 0; i < h; i++) {
long long next, weig, id;
next = adj[node][i].first;
id = adj[node][i].second;
weig = weight[id];
if (dist[next] > (dist[node] + weig)) {
dist[next] = (dist[node] + weig);
qu.push(make_pair(dist[next], next));
indice[next] = id;
} else if (dist[next] == (dist[node] + weig)) {
if (weig < weight[indice[next]]) {
indice[next] = id;
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long N, M, X, Y, W, j, i, uup;
long long sum = 0;
cin >> N >> M;
for (i = 1; i <= M; i++) {
cin >> X >> Y >> W;
adj[X].push_back(make_pair(Y, i));
adj[Y].push_back(make_pair(X, i));
weight[i] = W;
}
for (i = 1; i <= N; i++) {
dist[i] = 9223372036854775807;
}
cin >> uup;
dijkstra(uup);
for (i = 1; i <= N; i++) {
sum += weight[indice[i]];
}
cout << sum << "\n";
for (i = 1; i <= N; i++) {
if (i != uup) {
cout << indice[i] << " ";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 8005;
char s[MN];
int N, deg[MN], bel[MN], num[MN];
vector<bool> A[MN];
int que[MN], lb, rb;
long long ans;
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
scanf("%s", s + 1);
A[i].resize(N + 1);
for (int j = 1; j <= N / 4; ++j) {
int x = isdigit(s[j]) ? s[j] - '0' : s[j] - 'A' + 10;
for (int k = 3; k >= 0; --k) A[i][4 * j - k] = x >> k & 1;
}
}
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j)
if (A[i][j]) ++deg[j];
int C = N;
lb = 1, rb = 0;
for (int i = 1; i <= N; ++i)
if (!deg[i]) que[++rb] = i;
while (lb <= rb) {
int u = que[lb++];
bel[u] = 3;
ans += (614LL * N + 1) * --C;
for (int i = 1; i <= N; ++i)
if (A[u][i])
if (!--deg[i]) que[++rb] = i;
}
if (!C) {
printf("%lld\n", ans);
return 0;
}
int x = max_element(deg + 1, deg + 1 + N) - deg;
for (int i = 1; i <= N; ++i)
if (bel[i] != 3) bel[i] = i == x || A[i][x] ? 1 : 2;
for (int i = 1; i <= N; ++i)
if (bel[i] != 3)
for (int j = 1; j <= N; ++j)
if (i != j && bel[j] != 3)
if (bel[i] != bel[j] && A[i][j]) ++num[j];
for (int i = 1; i < N; ++i)
if (bel[i] != 3)
for (int j = i + 1; j <= N; ++j)
if (bel[j] != 3) ans += 3 + (bel[i] == bel[j] && num[i] == num[j]);
printf("%lld\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
struct BLOCK {
int n;
long long dt, cnt;
long long a[318], b[318];
bool v[318];
int t[318];
int c[318], cn;
void init() {
for (int i = 0; i < n; i++) t[i] = i;
}
double solvex(int p, int q) { return -(double)(b[p] - b[q]) / (a[p] - a[q]); }
void release() {
sort(t, t + n, [&](int p, int q) -> bool {
if (a[p] != a[q]) return a[p] < a[q];
return b[p] > b[q];
});
cn = 0;
for (int i = 0; i < n; i++) {
if (v[t[i]]) continue;
if (cn - 1 >= 0 && a[c[cn - 1]] == a[t[i]]) continue;
while (cn >= 2) {
if (solvex(c[cn - 2], c[cn - 1]) < solvex(c[cn - 1], t[i])) break;
cn--;
}
c[cn++] = t[i];
}
}
pair<long long, int> get(long long x) {
int s, e, m;
for (s = 1, e = cn - 1; s <= e;) {
m = (s + e) / 2;
if (solvex(c[m - 1], c[m]) < x)
s = m + 1;
else
e = m - 1;
}
return make_pair(a[c[s - 1]] * x + b[c[s - 1]] + dt, c[s - 1]);
}
} d[318];
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%I64d", &d[i / 318].a[i % 318]);
d[i / 318].n++;
}
int B = (n + 318 - 1) / 318;
for (int i = 0; i < B; i++) {
d[i].init();
d[i].release();
}
long long r = 0, rr = 0;
for (int i = 0; i < n; i++) {
long long x = 1;
bool f = true;
pair<long long, int> M;
for (int j = 0; j < B; j++) {
if (d[j].cn) {
pair<long long, int> re = d[j].get(x);
re.second += j * 318;
if (f || M < re) {
M = re;
f = false;
}
}
x += d[j].cnt;
}
rr += M.first;
if (r < rr) r = rr;
int kb = M.second / 318, ki = M.second % 318;
d[kb].v[ki] = true;
for (int j = 0; j < ki; j++) d[kb].b[j] += d[kb].a[ki];
for (int j = ki + 1; j < d[kb].n; j++) d[kb].b[j] += d[kb].a[j];
d[kb].cnt++;
d[kb].release();
for (int j = 0; j < kb; j++) d[j].dt += d[kb].a[ki];
}
printf("%I64d", r);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int array[n], xor_ = 0, sum = 0;
for (long long int i = 0; i < n; i++) {
cin >> array[i];
sum += array[i];
xor_ = xor_ ^ array[i];
}
long long int ans1 = xor_;
sum += xor_;
long long int ans2 = sum;
cout << "2\n" << ans1 << " " << ans2 << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> a(5, 0);
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
++a[x];
}
int odp = 0;
if (a[1] >= a[2]) {
odp += a[2];
a[3] += a[2];
a[1] -= a[2];
a[2] = 0;
odp += a[1] / 3 * 2;
a[3] += a[1] / 3;
a[1] %= 3;
if (a[1] == 1) {
if (a[3] >= 1)
++odp;
else {
if (a[4] >= 2)
odp += 2;
else {
cout << "-1";
return 0;
}
}
}
if (a[1] == 2) {
if (a[3] >= 2 || a[4] >= 1)
odp += 2;
else {
cout << "-1";
return 0;
}
}
} else {
odp += a[1];
a[3] += a[1];
a[2] -= a[1];
a[1] = 0;
odp += a[2] / 3 * 2;
a[3] += a[2] / 3 * 2;
a[2] %= 3;
if (a[2] == 1) {
if (a[4] >= 1)
++odp;
else {
if (a[3] >= 2)
odp += 2;
else {
cout << "-1";
return 0;
}
}
}
if (a[2] == 2) odp += 2;
}
cout << odp;
return 0;
}
| 6 |
/*input
*/
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define cin in
ifstream cin("50.in");
#endif
int main () {
ios_base::sync_with_stdio(false), cin.tie(0);
int n;
cin >> n;
bool matr2[n + 4][n + 4] = {};
short matr[n + 4][n + 4] = {};
for (int i = 2; i <= n+1; i++) {
for (int j = 2; j <= n+1; j++)
cin >> matr2[i][j];
}
for (int i = 2; i <= n+1; i++) {
for (int j = 2; j <= n+1; j++){
matr[i][j] = int(matr2[i][j]);
#define bang(x,y) matr[i][j] += matr2[x][y];
bang(i + 1, j);
bang(i, j + 1);
bang(i - 1, j);
bang(i, j - 1);
bang(i + 1, j + 1);
bang(i - 1, j - 1);
bang(i - 1, j + 1);
bang(i + 1, j - 1);
bang(i + 2, j);
bang(i, j + 2);
bang(i - 2, j);
bang(i, j - 2);
#undef bang
}
}
int kvad = 0, skrit = 0;
#define constanta 5
for (int i = 2; i <= n+1; i++) {
for (int j = 2; j <= n+1; j++) {
if (matr[i][j] > constanta) {
queue<pair<int, int> > eil;
int k = 0;
long long tol = 0;
eil.push(make_pair(i, j));
matr[i][j] = 0;
while (!eil.empty()) {
int di = eil.front().first, dj = eil.front().second;
tol = max(tol, (long long)(di - i) * (di - i) + (dj - j) * (dj - j));
eil.pop();
#define bang(x,y) if(matr[x][y ] > constanta) {\
eil.push(make_pair(x,y)); \
matr[x][y]=0;k++; }
bang(di + 1, dj);
bang(di, dj + 1);
bang(di - 1, dj);
bang(di, dj - 1);
bang(di + 1, dj + 1);
bang(di - 1, dj - 1);
bang(di - 1, dj + 1);
bang(di + 1, dj - 1);
#undef bang
}
if (k < 45)
continue;
//cout << tol << " " << k << endl;
long long paklk = abs(tol / 2 - k);
long long pakls = abs(tol * 3.1415 / 4 - k);
//cout << paklk << " " << pakls << endl;
if (abs(paklk) < pakls)
kvad++;
else
skrit++;
}
}
}
cout << skrit << " " << kvad << endl;
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 4 * atan((long double)1);
const long long mod = 1e9 + 7;
const long long inf = 1e9;
const long long llinf = 1e18;
const long long nax = 0;
int n, m, k;
bool vis[505][505];
char arr[505][505];
int row[] = {1, 0, -1, 0};
int col[] = {0, 1, 0, -1};
bool memenuhi(int x, int y) {
return (!(vis[x][y]) && (x >= 0) && (x < n) && (y >= 0) && (y < m) &&
(arr[x][y] == '.'));
}
void dfs(int x, int y) {
if (!k) return;
vis[x][y] = 1;
for (int i = 0; i < 4; ++i) {
int baris = row[i] + x;
int kolom = col[i] + y;
if (memenuhi(baris, kolom)) {
dfs(baris, kolom);
}
}
if (k) {
arr[x][y] = 'X';
k--;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> arr[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (!k) goto sini;
if (arr[i][j] == '.') {
dfs(i, j);
}
}
}
sini:;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << arr[i][j];
}
cout << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 29);
const int INFF = 0x7fffffff;
const long long LINF = (1ll << 60);
const long long LINFF = 0x7fffffffffffffff;
const double PI = 3.14159265359;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rnd(long long a, long long b) {
return uniform_int_distribution<long long>(a, b)(rng);
}
template <typename T>
struct treap {
private:
struct node {
T key;
int prior;
node *l = nullptr, *r = nullptr;
int cnt = 1;
node(T k) : key(k), prior(rand()) {}
};
node *t = nullptr;
int cnt(node *n) { return n ? n->cnt : 0; }
void upd_cnt(node *n) {
if (n) n->cnt = 1 + cnt(n->l) + cnt(n->r);
}
void split(node *root, T key, node *&l, node *&r) {
if (!root)
l = r = nullptr;
else if (key <= root->key) {
r = root;
split(root->l, key, l, root->l);
} else {
l = root;
split(root->r, key, root->r, r);
}
upd_cnt(l);
upd_cnt(r);
}
void insert(node *&root, node *element) {
if (!root) return void(root = element);
if (element->prior > root->prior) {
split(root, element->key, element->l, element->r);
root = element;
} else {
if (element->key < root->key)
insert(root->l, element);
else
insert(root->r, element);
}
upd_cnt(root);
}
void merge(node *&root, node *l, node *r) {
if (!r || !l)
root = l ? l : r;
else if (l->prior > r->prior) {
root = l;
merge(l->r, l->r, r);
} else {
root = r;
merge(r->l, l, r->l);
}
upd_cnt(root);
}
void erase(node *&root, T key) {
if (!root) return;
if (root->key == key) {
node *aux = root;
merge(root, root->l, root->r);
delete aux;
} else {
if (key < root->key)
erase(root->l, key);
else
erase(root->r, key);
}
upd_cnt(root);
}
void del(node *n) {
if (!n) return;
del(n->l);
del(n->r);
delete n;
}
T kth(node *root, int pos) {
if (!root) return {0, 0};
int p = 1 + cnt(root->l);
if (p == pos) return root->key;
if (p > pos)
return kth(root->l, pos);
else
return kth(root->r, pos - p);
}
public:
void insert(T key) { insert(t, new node(key)); }
void erase(T key) { erase(t, key); }
~treap() { del(t); }
T kth(int pos) { return kth(t, pos + 1); }
int size() { return cnt(t); }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
vector<pair<int, int>> vv;
for (int i = 0; i < n; i++) vv.push_back({i, v[i]});
sort(vv.begin(), vv.end(),
[](const pair<int, int> &a, const pair<int, int> &b) {
if (a.second == b.second)
return a.first < b.first;
else
return a.second > b.second;
});
vector<tuple<int, int, int>> queries;
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int k, pos;
cin >> k >> pos;
queries.push_back({k, pos, i});
}
sort(queries.begin(), queries.end());
vector<int> ans(q);
treap<pair<int, int>> trp;
int j = 0;
for (int i = 0; i < q; i++) {
int k, pos, id;
tie(k, pos, id) = queries[i];
while (trp.size() < k) trp.insert(vv[j++]);
ans[id] = trp.kth(pos - 1).second;
}
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 59;
int a[N], n, p;
double dp[N][N][N];
double f[N];
int main() {
scanf("%d", &n);
f[0] = 1;
for (int i = 1; i <= n; ++i) f[i] = f[i - 1] * i;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
scanf("%d", &p);
for (int i = 0; i <= n; ++i) {
dp[i][0][0] = 1;
for (int o = 1; o <= n; ++o) {
if (o == i) continue;
for (int j = p; j >= a[o]; --j) {
for (int k = n; k >= 1; --k) {
dp[i][j][k] += dp[i][j - a[o]][k - 1] * (k);
}
}
}
}
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= p; ++j)
for (int k = 0; k <= n; ++k) {
}
double o = 0;
for (int k = 1; k < n; ++k) {
for (int j = 0; j <= p; ++j) {
for (int i = 1; i <= n; ++i) {
if (j + a[i] > p) {
o += 1.0 * k * dp[i][j][k] * f[n - k - 1];
}
}
}
}
for (int j = 0; j <= p; ++j) {
o += 1.0 * n * dp[0][j][n];
}
o = o / f[n];
printf("%.6f\n", o);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long x[3], y[3];
bool ok(long long a, long long b) {
if (b < 0) b = -b;
if (b == 0) {
return a == 0;
}
return a % b == 0;
}
bool check(long long xx, long long yy) {
long long ex = x[1] - xx;
long long ey = y[1] - yy;
long long dx = x[2];
long long dy = y[2];
if (dx == 0 && dy == 0 && (ex != 0 || ey != 0)) return false;
if (ok(ex * dx + ey * dy, dx * dx + dy * dy) &&
ok(ex * dy - ey * dx, dy * dy + dx * dx)) {
return true;
}
return false;
}
bool work() {
if (check(x[0], y[0]) || check(-y[0], x[0]) || check(-x[0], -y[0]) ||
check(y[0], -x[0]))
return true;
return false;
}
int main() {
for (int i = 0; i < 3; i++) {
scanf("%I64d%I64d", &x[i], &y[i]);
}
puts(work() ? "YES" : "NO");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 120;
int mp[maxn][maxn][maxn];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
string s;
cin >> s;
for (int t = 0; t < s.size(); t++) {
if (s[t] == '1')
mp[i][j][t + 1] = 1;
else
mp[i][j][t + 1] = 0;
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int t = 1; t <= k; t++) {
if (mp[i][j][t]) {
if (mp[i - 1][j][t] && mp[i + 1][j][t])
ans++;
else if (mp[i][j - 1][t] && mp[i][j + 1][t])
ans++;
else if (mp[i][j][t - 1] && mp[i][j][t + 1])
ans++;
else if (mp[i - 1][j][t] && mp[i][j + 1][t] && (!mp[i - 1][j + 1][t]))
ans++;
else if (mp[i][j - 1][t] && mp[i + 1][j][t] && (!mp[i + 1][j - 1][t]))
ans++;
else if (mp[i - 1][j][t] && mp[i][j][t + 1] && (!mp[i - 1][j][t + 1]))
ans++;
else if (mp[i][j - 1][t] && mp[i][j][t + 1] && (!mp[i][j - 1][t + 1]))
ans++;
else if (mp[i][j][t - 1] && mp[i + 1][j][t] && (!mp[i + 1][j][t - 1]))
ans++;
else if (mp[i][j][t - 1] && mp[i][j + 1][t] && (!mp[i][j + 1][t - 1]))
ans++;
}
}
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005, mod = 1000000007;
long long int a, b, c, d, e, f, g, h[N], arr[N];
string s;
vector<pair<long long int, long long int> > v, v2;
vector<pair<pair<long long int, long long int>, long long int> > v3;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> a >> b;
for (long long int i = 1; i <= b; i++) {
long long int x, y, z;
cin >> x >> y >> z;
arr[x] += z;
arr[y] -= z;
}
for (long long int i = 1; i <= a; i++) {
if (arr[i] > 0) v.push_back(make_pair(i, arr[i]));
if (arr[i] < 0) v2.push_back(make_pair(i, -arr[i]));
}
long long int j = 0, i = 0;
while (j < v2.size() or i < v.size()) {
long long int awdasda = min(v2[j].second, v[i].second);
v3.push_back(make_pair(make_pair(v[i].first, v2[j].first), awdasda));
if ((v[i].second -= awdasda) == 0) i++;
if ((v2[j].second -= awdasda) == 0) j++;
}
cout << v3.size() << endl;
for (long long int i = 0; i < v3.size(); i++) {
cout << v3[i].first.first << ' ' << v3[i].first.second << ' '
<< v3[i].second << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
int to[20003], nxt[20003], head[10003], cur[10003];
int n, s, t, cnt = 1;
int ans = 0, val[20003];
bool vis[10003];
int d[10003];
void addedge(int x, int y, int z) {
to[++cnt] = y, nxt[cnt] = head[x], head[x] = cnt, val[cnt] = z;
}
int dfs(int x, int v) {
int res = 0;
if (x == t) return v;
for (int i = cur[x]; i; i = nxt[i])
if (d[to[i]] == d[x] + 1 && val[i]) {
cur[x] = i;
int now = dfs(to[i], min(v, val[i]));
val[i ^ 1] += now, val[i] -= now, v -= now, res += now;
if (!v) return res;
}
if (!res) d[x] = -114514;
return res;
}
signed dinic() {
ans = 0;
while (1) {
memset(vis, 0, sizeof(vis));
memset(d, 0, sizeof(d));
queue<pair<int, int> > q;
q.push(make_pair(0, s)), vis[s] = 1;
while (!q.empty()) {
int x = q.front().second, dep = q.front().first;
for (int i = head[x]; i; i = nxt[i]) {
int y = to[i];
if (!vis[y] && val[i])
vis[y] = 1, d[y] = dep + 1, cur[y] = head[y],
q.push(make_pair(dep + 1, y));
}
q.pop();
}
if (!vis[t]) break;
for (int i = 1; i <= n; i++) cur[i] = head[i];
ans += dfs(s, 1000000000);
}
return ans;
}
int A[100003], B[100003], C[100003], lst = 0;
int id[100003], cccnt = 0;
bool v1s[100003];
signed main() {
int N = read(), K = read();
for (int i = 2; i <= 20000; i++)
if (!v1s[i])
for (int j = 2; i * j <= 20000; j++) v1s[i * j] = 1;
for (int i = 1; i <= N; i++) A[i] = read(), B[i] = read(), C[i] = read();
int l = 1, r = 100000, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
lst = cccnt = 0, cnt = 1, memset(head, 0, sizeof(head));
for (int i = 1; i <= N; i++)
if (C[i] <= mid) {
if (B[i] == 1)
if (lst) {
if (A[i] > A[lst]) lst = i;
} else
lst = i;
else
id[++cccnt] = i;
}
if (lst) id[++cccnt] = lst;
s = cccnt + 1, n = t = cccnt + 2;
for (int i = 1; i < cccnt; i++)
for (int j = i + 1; j <= cccnt; j++)
if (!v1s[B[id[i]] + B[id[j]]]) {
if (B[id[i]] & 1)
addedge(i, j, 1000000000), addedge(j, i, 0);
else
addedge(j, i, 1000000000), addedge(i, j, 0);
}
for (int i = 1; i <= cccnt; i++)
if (B[id[i]] & 1)
addedge(s, i, A[id[i]]), addedge(i, s, 0);
else
addedge(i, t, A[id[i]]), addedge(t, i, 0);
int sum = -dinic();
for (int i = 1; i <= cccnt; i++) sum += A[id[i]];
if (sum >= K)
ans = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int now[5 * 100010], after[5 * 100010], mx[5 * 100010];
int lft[5 * 100010], rgt[5 * 100010], vi[5 * 100010], timer = 0, comp = 0;
long long Add[5 * 100010];
vector<int> g[5 * 100010];
stack<int> stk;
inline void dfs(int c, int p) {
vi[c] = 1;
now[c] = after[c] = ++timer;
stk.push(c);
for (auto x : g[c]) {
if (x != p) {
if (!vi[x]) {
dfs(x, c);
now[c] = min(now[c], now[x]);
} else
now[c] = min(now[c], now[x]);
}
}
if (now[c] == after[c]) {
comp++;
lft[comp] = rgt[comp] = c;
while (1) {
int node = stk.top();
stk.pop();
lft[comp] = min(lft[comp], node);
rgt[comp] = max(rgt[comp], node);
if (node == c) break;
}
}
}
int main() {
int n, m;
scanf("%d", &n);
;
scanf("%d", &m);
;
memset(vi, 0, sizeof(vi));
;
for (int x = 1; x <= m; x++) {
int u, v;
scanf("%d", &u);
;
scanf("%d", &v);
;
g[u].emplace_back(v);
g[v].emplace_back(u);
}
for (int x = 1; x <= n; x++)
if (!vi[x]) dfs(x, 0);
for (int x = 1; x <= n; x++) mx[x] = n;
for (int x = 1; x <= comp; x++)
if (lft[x] != rgt[x]) mx[lft[x]] = rgt[x] - 1;
for (int x = n - 1; x >= 1; x--) mx[x] = min(mx[x + 1], mx[x]);
for (int x = 1; x <= n; x++) Add[x] = Add[x - 1] + mx[x] - x + 1;
int q;
scanf("%d", &q);
;
while (q--) {
int from, to;
scanf("%d", &from);
;
scanf("%d", &to);
;
int l = from, r = to, chk = -1;
while (l <= r) {
int m = l + r >> 1;
if (mx[m] > to)
r = m - 1;
else
chk = max(chk, m), l = m + 1;
}
long long res;
if (chk == -1)
res = 1LL * (to - from + 1LL) * (to - from + 2LL) / 2LL;
else
res = Add[chk] - Add[from - 1] + 1LL * (to - chk) * (to - chk + 1LL) / 2;
printf("%lld\n", res);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream &operator>>(istream &in, vector<T> &v) {
for (auto &i : v) cin >> i;
return in;
}
template <typename T>
istream &operator>>(istream &in, pair<T, T> &p) {
cin >> p.f >> p.s;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &v) {
for (auto &i : v) cout << i << " ";
return out;
}
template <typename T>
ostream &operator<<(ostream &out, pair<T, T> &p) {
cout << p.f << " " << p.s << " ";
return out;
}
template <typename T>
istream &operator>>(istream &in, vector<pair<T, T>> &v) {
for (auto &i : v) cin >> i.f >> i.s;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, vector<pair<T, T>> &v) {
for (auto &i : v) cout << i.f << " " << i.s << "\n";
return out;
}
void solve() {
long long int t;
cin >> t;
for (long long int _ = 1; _ <= t; _++) {
long long int k;
cin >> k;
string s;
cin >> s;
vector<long long int> arr(10, 0);
for (auto &ch : s) {
arr[ch - '0']++;
}
long long int ans[] = {1, 4, 6, 8, 9};
bool flag = 0;
for (auto i : ans) {
if (arr[i]) {
cout << "1\n" << i << "\n";
flag = 1;
break;
}
}
if (flag) continue;
if (arr[2] > 1) {
cout << "2"
<< "\n"
<< 22 << "\n";
continue;
}
if (arr[2] == 1 and s[0] != '2') {
cout << 2 << "\n";
cout << s[0] << 2 << "\n";
continue;
}
if (arr[2]) {
if (arr[5] or arr[7]) {
cout << "2"
<< "\n";
cout << 2 << ((arr[5] ? 5 : 7)) << "\n";
} else {
cout << "2\n33"
<< "\n";
}
continue;
}
if (arr[3] > 1 or arr[5] > 1 or arr[7] > 1) {
cout << 2 << "\n";
cout << (arr[3] > 1 ? 33 : arr[5] > 1 ? 55 : 77) << "\n";
continue;
}
cout << 2 << "\n";
cout << (s[0] == '3' ? 35 : s[0] == '5' ? 57 : 75) << "\n";
}
}
int main() {
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first - t.first, s.second - t.second);
}
template <class S, class T>
ostream &operator<<(ostream &os, pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long inf = 1000000001;
const long long INF = (long long)1e18 + 1;
const long long MOD = 998244353;
const double pi = 3.14159265358979323846;
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
int dx2[8] = {1, 1, 0, -1, -1, -1, 0, 1}, dy2[8] = {0, 1, 1, 1, 0, -1, -1, -1};
struct P {
int x, y, z, i;
P() {}
P(int x, int y, int z, int i) : x(x), y(y), z(z), i(i) {}
bool operator<(const P &ot) const {
pair<pair<int, int>, int> me = make_pair(pair<int, int>(x, y), z);
pair<pair<int, int>, int> ai = make_pair(pair<int, int>(ot.x, ot.y), ot.z);
return me < ai;
}
};
vector<int> a;
class UnionFind {
public:
int n;
vector<int> par;
vector<int> ran;
vector<int> num;
vector<int> high;
int g;
UnionFind(int _n) {
n = _n;
g = n;
par.resize(n);
ran.resize(n);
num.resize(n);
high.resize(n);
for (int i = 0; i < n; i++) {
par[i] = i;
ran[i] = 0;
num[i] = 1;
high[i] = a[i];
}
}
int find(int x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(int x, int y) {
x = find(x);
y = find(y);
int numsum = num[x] + num[y];
int highest = max(high[x], high[y]);
if (x == y) {
return;
}
if (ran[x] < ran[y]) {
par[x] = y;
} else {
par[y] = x;
if (ran[x] == ran[y]) {
ran[x]++;
}
}
num[x] = num[y] = numsum;
high[x] = high[y] = highest;
g--;
}
bool same(int x, int y) { return find(x) == find(y); }
};
pair<int, pair<int, int>> merge(pair<int, pair<int, int>> a,
pair<int, pair<int, int>> b) {
return make_pair(max(a.first, b.first),
pair<int, int>(a.second.first, b.second.second));
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
;
int n;
cin >> n;
a.resize(n);
int ma = 0, mi = inf;
for (int i = 0; i < (n); i++) {
cin >> a[i];
chmin(mi, a[i]);
chmax(ma, a[i]);
}
if (mi > (ma - 1) / 2) {
for (int i = 0; i < (n); i++) {
cout << -1 << " ";
}
cout << endl;
return 0;
}
deque<pair<int, pair<int, int>>> xlr;
int nokori = n;
vector<int> end(n, -1);
for (int _i = 0; _i < (3 * n); _i++) {
int i = _i % n;
if (xlr.size() == 0) {
xlr.push_back(make_pair(a[i], pair<int, int>(_i, _i + 1)));
} else {
while (xlr.size() > 0) {
int ma = xlr[0].first;
pair<int, int> lr = xlr[0].second;
if (a[i] <= (ma - 1) / 2) {
for (int j = lr.first; j < lr.second; j++) {
if (end[j % n] == -1) {
end[j % n] = _i;
nokori--;
}
}
xlr.pop_front();
} else {
break;
}
}
pair<int, pair<int, int>> now =
make_pair(a[i], pair<int, int>(_i, _i + 1));
while (xlr.size() > 0 and xlr.back().first <= a[i]) {
now = merge(xlr.back(), now);
xlr.pop_back();
}
xlr.push_back(now);
}
if (nokori == 0) break;
}
for (int i = 0; i < (n); i++) {
cout << end[i] - i << " ";
}
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
struct tdata {
int position;
int cost;
struct tdata *next;
};
struct heapData {
int distance;
int position;
};
struct heapData arrHeap[2000000];
int heapCountData = 0;
struct tdata *adjListHead[200005];
int compare(struct heapData a, struct heapData b) {
if (a.distance < b.distance) return -1;
if (a.distance == b.distance) {
if (a.position < b.position) return -1;
if (a.position == b.position) return 0;
return 1;
}
return 1;
}
void downHeap(struct heapData *heapArr, int idx, int ndata) {
int toIdx = idx;
if (2 * idx <= ndata && compare(heapArr[toIdx], heapArr[2 * idx]) > 0) {
toIdx = 2 * idx;
}
if (2 * idx + 1 <= ndata &&
compare(heapArr[toIdx], heapArr[2 * idx + 1]) > 0) {
toIdx = 2 * idx + 1;
}
if (toIdx == idx) return;
struct heapData temp = heapArr[toIdx];
heapArr[toIdx] = heapArr[idx];
heapArr[idx] = temp;
downHeap(heapArr, toIdx, ndata);
}
void makeHeap(struct heapData *heapArr, int n) {
for (int i = n / 2; i > 0; i--) {
downHeap(heapArr, i, n);
}
}
void popHeap(struct heapData *heapArr, int *n) {
if (*n == 1) {
(*n)--;
return;
}
heapArr[1] = heapArr[*n];
(*n)--;
downHeap(heapArr, 1, *n);
}
void upHeap(struct heapData *heapArr, int idx, int ndata) {
if (idx == 1) return;
int ParentIdx = idx / 2;
if (compare(heapArr[ParentIdx], heapArr[idx]) < 0) return;
struct heapData temp = heapArr[ParentIdx];
heapArr[ParentIdx] = heapArr[idx];
heapArr[idx] = temp;
upHeap(heapArr, ParentIdx, ndata);
}
void pushHeap(struct heapData *heapArr, int *n, int distance, int position) {
(*n)++;
heapArr[*n].distance = distance;
heapArr[*n].position = position;
upHeap(heapArr, *n, *n);
}
struct heapData topHeap(struct heapData *heapArr, int n) {
if (n < 1) return {-1, -1};
return heapArr[1];
}
void pushList(struct tdata **localHead, int position, int cost) {
struct tdata *newnode = (struct tdata *)malloc(sizeof(struct tdata));
newnode->position = position;
newnode->cost = cost;
newnode->next = NULL;
if (*localHead == NULL) {
*localHead = newnode;
} else {
newnode->next = *localHead;
*localHead = newnode;
}
}
void popAll(struct tdata **localHead) {
while (*localHead != NULL) {
struct tdata *del = *localHead;
*localHead = (*localHead)->next;
free(del);
}
}
struct print {
int prevLevel;
int nextLevel;
};
struct print track[100005];
int distance[200005];
int visited[200005];
int par[200005];
int idx = 1;
int prim(struct tdata **localAdjList, int V, int a, int r, int c) {
heapCountData = 0;
for (int i = 0; i <= V; i++) {
distance[i] = r * c;
visited[i] = 0;
par[i] = 0;
}
pushHeap(arrHeap, &heapCountData, r * c, a);
int mstCost = 0;
while (heapCountData > 0) {
struct heapData topData = topHeap(arrHeap, heapCountData);
popHeap(arrHeap, &heapCountData);
int curPosition = topData.position;
int curDist = topData.distance;
if (visited[curPosition]) continue;
visited[curPosition] = 1;
mstCost += curDist;
track[idx].nextLevel = curPosition;
track[idx++].prevLevel = par[curPosition];
struct tdata *current = localAdjList[curPosition];
while (current != NULL) {
if (visited[current->position] == 0) {
if (current->cost >= distance[current->position]) {
pushHeap(arrHeap, &heapCountData, distance[current->position],
current->position);
} else {
pushHeap(arrHeap, &heapCountData, current->cost, current->position);
par[current->position] = curPosition;
distance[current->position] = current->cost;
}
}
current = current->next;
}
}
return mstCost;
}
char map[1005][15][15];
int main() {
int r, c, l, w;
scanf("%d %d %d %d", &r, &c, &l, &w);
getchar();
for (int i = 1; i <= l; i++) {
for (int j = 0; j < r; j++) {
for (int k = 0; k < c; k++) {
scanf("%c", &map[i][j][k]);
}
getchar();
}
}
for (int i = 0; i <= l; i++) {
adjListHead[i] = NULL;
}
int diff = 0;
for (int i = 1; i <= l - 1; i++) {
for (int ii = i + 1; ii <= l; ii++) {
diff = 0;
for (int j = 0; j < r; j++) {
for (int k = 0; k < c; k++) {
if (map[i][j][k] != map[ii][j][k]) {
diff++;
}
}
}
pushList(&adjListHead[i], ii, diff * w);
pushList(&adjListHead[ii], i, diff * w);
}
}
int mstCost = prim(adjListHead, l, 1, r, c);
printf("%d\n", mstCost);
for (int i = 1; i < idx; i++) {
printf("%d %d\n", track[i].nextLevel, track[i].prevLevel);
}
for (int i = 0; i <= l; i++) {
popAll(&adjListHead[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string second;
int now;
bool ok;
void dfs(int i) {
if (i == second.size()) {
ok = 1;
return;
}
if (second[i] - '0' != now) return;
if (second[i + 1] - '0' == (second[i + 1] - '0' + now) / 2)
now = (second[i + 1] - '0' + now) / 2;
else
now = (second[i + 1] - '0' + now + 1) / 2;
dfs(i + 1);
}
long long dp[10][51];
int main() {
cin >> second;
for (int i = 0; i < 10; i++) dp[i][0] = 1;
for (int i = 0; i < second.size(); i++)
for (int j = 0; j < 10; j++) {
if ((j + second[i] - '0') % 2 == 0)
dp[(j + second[i] - '0') / 2][i] += (i ? dp[j][i - 1] : 0);
else {
dp[(j + second[i] - '0') / 2][i] += (i ? dp[j][i - 1] : 0);
dp[(j + second[i] - '0' + 1) / 2][i] += (i ? dp[j][i - 1] : 0);
}
}
long long ans = 0;
for (int i = 0; i < 10; i++) {
ans += dp[i][second.size() - 1];
}
now = second[0] - '0';
dfs(0);
if (ok) ans--;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5;
pair<int, int> arr[N];
int main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &arr[i].first);
for (int i = 0; i < n; ++i) scanf("%d", &arr[i].second);
sort(arr, arr + n);
multiset<int> s;
ll ans = 0, sum = 0;
int cur = arr[0].first, idx = 0;
while (idx < n or not s.empty()) {
while (idx < n and arr[idx].first == cur) {
s.insert(arr[idx].second);
sum += arr[idx].second;
++idx;
}
auto it = s.end();
--it;
int temp = *it;
s.erase(it);
sum -= temp;
ans += sum;
if (not s.empty())
++cur;
else if (idx < n)
cur = arr[idx].first;
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
long long x[100005];
long long k[100005];
long long t[100005];
int main() {
long long n;
while (scanf("%I64d", &n) != EOF) {
long long i;
for (i = 0; i < n; i++) {
scanf("%I64d%I64d", &x[i], &k[i]);
}
int flag = 1;
for (i = 0; i < n; i++) {
if (x[i] > t[k[i]]) {
flag = 0;
} else if (x[i] == t[k[i]])
t[k[i]]++;
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
inline long long read() {
bool f = false;
char ch = getchar();
long long res = 0;
while (ch < '0' || '9' < ch) f |= (ch == '-'), ch = getchar();
while ('0' <= ch && ch <= '9') res = 10 * res + ch - '0', ch = getchar();
return f ? -res : res;
}
const int N = 2e5 + 10;
int head[N], ver[N * 2], edge[N * 2], Next[N * 2], tot;
void add(int x, int y, int z) {
ver[++tot] = y, edge[tot] = z, Next[tot] = head[x], head[x] = tot;
}
long long a[N];
long long dis[N];
bool vis[N];
int fa[N];
int ans[N];
void getdis(int u, int fa) {
for (int i = head[u]; i; i = Next[i]) {
int v = ver[i], w = edge[i];
if (v == fa) continue;
dis[v] = dis[u] + w;
getdis(v, u);
}
}
struct node {
long long dis, x;
node(long long _dis = 0, long long _x = 0) { dis = _dis, x = _x; }
bool operator<(const node& b) const { return dis < b.dis; }
};
vector<node> path;
void solve(int u) {
path.push_back(node(dis[u], u));
vis[u] = 1;
for (int i = head[u]; i; i = Next[i]) {
int v = ver[i];
if (vis[v]) continue;
long long temp = dis[v] - a[v];
auto pos = lower_bound(path.begin(), path.end(), temp);
if (pos != path.end()) {
ans[u]++;
ans[fa[pos->x]]--;
}
solve(v);
ans[u] += ans[v];
}
path.pop_back();
}
int main() {
int n = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
}
for (int i = 2; i <= n; i++) {
int x = read(), y = read();
fa[i] = x;
add(i, x, y);
add(x, i, y);
}
getdis(1, -1);
solve(1);
for (int i = 1; i <= n; i++) {
printf("%d ", ans[i]);
}
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, x, y, l, r, m;
while (cin >> a >> b >> x >> y) {
l = 1;
r = (a + b) << 2;
while (l <= r) {
m = (l + r) >> 1;
if (m - m / x / y >= a + b && m - m / x >= a && m - m / y >= b)
r = m - 1;
else
l = m + 1;
}
cout << l << endl;
}
return 0;
}
| 5 |
#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);
}
void dfs(long long x, long long y) {
if (x == y) return;
if (x > y) {
cout << (x - 1) / y << "A";
dfs((x - 1) % y + 1, y);
} else {
cout << (y - 1) / x << "B";
dfs(x, (y - 1) % x + 1);
}
}
int main() {
long long x, y;
cin >> x >> y;
if (gcd(x, y) > 1) {
cout << "Impossible" << endl;
return 0;
}
dfs(x, y);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n + 1, -1);
vector<pair<int, int> > q;
vector<int> ts(n);
for (int i = 0; i < k; i++) {
int t, l, r;
cin >> t >> l >> r;
ts[i] = t;
q.push_back(make_pair(l, r));
if (t == 1) {
for (int j = l + 1; j <= r; j++) {
v[j] = 0;
}
}
}
vector<int> arr(n + 1, 0);
arr[0] = n + 1;
for (int i = 1; i <= n; i++) {
arr[i] = arr[i - 1] + v[i];
}
for (int i = 0; i < k; i++) {
if (ts[i] == 0) {
if (is_sorted(arr.begin() + q[i].first, arr.begin() + q[i].second + 1)) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
cout << arr[i] << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool dfs1(vector<vector<int>>& grp, vector<int>& vis, int f, int s) {
vis[s] = 1;
for (int i = 0; i < grp[s].size(); i++) {
if (!vis[grp[s][i]])
return dfs1(grp, vis, f, grp[s][i]);
else {
if (grp[s][i] == f) {
return 1;
}
}
}
return 0;
}
void dfs(vector<vector<int>>& grp, vector<int>& vis, stack<int>& st, int i) {
for (int j = 0; j < grp[i].size(); j++) {
if (!vis[grp[i][j]]) {
vis[grp[i][j]] = 1;
dfs(grp, vis, st, grp[i][j]);
}
}
st.push(i);
}
int main() {
int n;
cin >> n;
vector<string> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
vector<vector<int>> grp(26);
int i = 0;
while (i < n - 1) {
int j = 0;
while (j < v[i].size() && j < v[i + 1].size()) {
if (v[i][j] == v[i + 1][j])
j++;
else
break;
}
if (j >= v[i + 1].size()) {
cout << "Impossible" << endl;
return 0;
} else if (j >= v[i].size()) {
} else {
grp[v[i][j] - 'a'].push_back(v[i + 1][j] - 'a');
}
i++;
}
vector<int> vis(26, 0);
stack<int> st;
for (int i = 0; i < 26; i++) {
vector<int> vis1(26, 0);
if (dfs1(grp, vis1, i, i)) {
cout << "Impossible" << endl;
return 0;
}
}
for (int i = 0; i < 26; i++) {
if (!vis[i]) {
vis[i] = 1;
dfs(grp, vis, st, i);
}
}
while (!st.empty()) {
cout << char(st.top() + 'a');
st.pop();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int a, k;
cin >> a >> k;
vector<long long int> v;
v.push_back(a);
for (int i = 1;; i++) {
long long int ma = 0, mi = 9, r = a, x;
while (r > 0) {
x = r % 10;
ma = max(ma, x);
mi = min(mi, x);
r = r / 10;
}
a += ma * mi;
v.push_back(a);
if (mi == 0) break;
}
if (k <= v.size())
cout << v[k - 1] << "\n";
else
cout << v[(v.size() - 1)] << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int power, i, j, q;
point *previous[3], *next[3];
int c_p, c_n;
};
int toi(char a) {
if (a == '1')
return 1;
else
return 0;
}
void paveTheWay(point ***proc, int n, int m, int k) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int q = 0; q < k; q++)
if (proc[i][j][q].power == 1) {
if (i < n - 1 && proc[i + 1][j][q].power != 0) {
proc[i][j][q].next[proc[i][j][q].c_n++] = &proc[i + 1][j][q];
proc[i + 1][j][q].previous[proc[i + 1][j][q].c_p++] =
&proc[i][j][q];
}
if (j < m - 1 && proc[i][j + 1][q].power != 0) {
proc[i][j][q].next[proc[i][j][q].c_n++] = &proc[i][j + 1][q];
proc[i][j + 1][q].previous[proc[i][j + 1][q].c_p++] =
&proc[i][j][q];
}
if (q < k - 1 && proc[i][j][q + 1].power != 0) {
proc[i][j][q].next[proc[i][j][q].c_n++] = &proc[i][j][q + 1];
proc[i][j][q + 1].previous[proc[i][j][q + 1].c_p++] =
&proc[i][j][q];
}
}
}
int isCritical(point *p) {
bool ways_saved = true;
if (p->c_p != 0)
for (int purp = 0; purp < p->c_n && ways_saved; purp++) {
for (int from = 0; from < p->c_p && ways_saved; from++)
if (p->previous[from] != p) {
bool find_way = false;
queue<point *> qe;
qe.push(p->previous[from]);
point *cur;
while (!qe.empty() && !find_way) {
cur = qe.front();
qe.pop();
if (cur->i <= p->next[purp]->i && cur->j <= p->next[purp]->j &&
cur->q <= p->next[purp]->q) {
for (int step = 0; step < cur->c_n && !find_way; step++)
if (cur->next[step] != p) {
if (cur->next[step] == p->next[purp])
find_way = true;
else
qe.push(cur->next[step]);
}
}
}
ways_saved = ways_saved && find_way;
}
}
if (ways_saved)
return 0;
else
return 1;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
point ***proc = new point **[n];
char buff;
for (int i = 0; i < n; i++) {
proc[i] = new point *[m];
for (int j = 0; j < m; j++) {
proc[i][j] = new point[k];
for (int q = 0; q < k; q++) {
cin >> buff;
proc[i][j][q].power = toi(buff);
proc[i][j][q].i = i;
proc[i][j][q].j = j;
proc[i][j][q].q = q;
proc[i][j][q].c_n = proc[i][j][q].c_p = 0;
}
}
}
paveTheWay(proc, n, m, k);
int count = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int q = 0; q < k; q++)
if (proc[i][j][q].power == 1) count += isCritical(&proc[i][j][q]);
cout << count;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
pair<int, int> p[n + 1];
for (long long i = (long long)1; i <= (long long)n; i++)
cin >> p[i].first >> p[i].second;
if (n == 3)
cout << "1 2 3";
else {
vector<int> v;
v.push_back(1);
if (p[p[1].first].first == p[1].second ||
p[p[1].first].second == p[1].second) {
v.push_back(p[1].first);
v.push_back(p[1].second);
} else {
v.push_back(p[1].second);
v.push_back(p[1].first);
}
int now = 1, top = 2;
for (long long i = (long long)1; i <= (long long)n - 3; i++) {
if (p[v[now]].first != v[top])
v.push_back(p[v[now]].first);
else
v.push_back(p[v[now]].second);
now++;
top++;
}
for (long long i = (long long)0; i <= (long long)n - 1; i++)
cout << v[i] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
const int MAX = 2e3 + 10;
const int MOD = 1e9 + 7;
using namespace std;
long long n, p, k1, k2;
int main() {
cin >> n >> k1 >> p;
k2 = n - k1;
long long pos;
if (k1 >= k2) {
while (p--) {
cin >> pos;
if (pos <= 2 * k2) {
if (pos & 1)
cout << '.';
else
cout << 'X';
} else
cout << 'X';
}
} else {
long long rem = k2 - k1;
if (rem & 1) rem++;
while (p--) {
cin >> pos;
if (pos <= rem)
cout << '.';
else if (pos == n)
cout << 'X';
else {
if ((pos - rem) & 1)
cout << '.';
else
cout << 'X';
}
}
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4004;
struct info {
int val, id, last;
} S[N];
int n, k, m, a, x[N], u, ans[N];
bool cmp(info A, info B) {
return A.val == B.val ? A.last < B.last : A.val > B.val;
}
int main() {
scanf("%d%d%d%d", &n, &k, &m, &a);
for (int i = 1; i <= n; i++) S[i] = (info){0, i, 0};
for (int i = 1; i <= a; i++) scanf("%d", &u), S[u].val++, S[u].last = i;
sort(S + 1, S + n + 1, cmp);
a = m - a;
for (int i = 1; i <= k; i++) {
int sum = 0, cnt = 0;
for (int j = i + 1; j <= n; j++) {
if (sum + (S[i].val + 1 - S[j].val) <= a && cnt < k - i + 1)
sum += S[i].val + 1 - S[j].val, cnt++;
else
break;
}
ans[S[i].id] = cnt >= k - i + 1 ? 2 : 1;
if (!S[i].val) ans[S[i].id] = 2;
}
for (int i = k + 1; i <= n; i++)
ans[S[i].id] = S[i].val + a > S[k].val ? 2 : 3;
for (int i = 1; i <= k; i++)
if (a == 0 && S[i].val == 0) ans[S[i].id] = 3;
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3f;
int sz;
long long tree[400005];
void update(int idx, long long val) {
idx += sz;
while (idx) {
tree[idx] = max(tree[idx], val);
idx /= 2;
}
}
long long query(int a, int b) {
a += sz;
b += sz;
long long ret = -inf;
while (a <= b) {
if (a & 1) ret = max(ret, tree[a++]);
if (!(b & 1)) ret = max(ret, tree[b--]);
a /= 2;
b /= 2;
}
return ret;
}
int n, d;
int arr[100005];
long long sum[100005];
int main() {
for (int i = 0; i < 400005; i++) tree[i] = -inf;
scanf("%d%d", &n, &d);
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
sum[0] = arr[0];
for (int i = 1; i < n; i++) sum[i] = sum[i - 1] + arr[i];
sz = 1;
while (sz < n) sz *= 2;
for (int i = 0; i < n; i++) update(i, sum[i]);
int cnt = 0;
long long diff = 0;
for (int i = 0; i < n; i++) {
if (sum[i] + diff > d) return !printf("-1\n");
if (arr[i] == 0 && sum[i] + diff < 0) {
long long q = query(i, n - 1) + diff;
long long p = -(sum[i] + diff);
if (d - q < p) return !printf("-1\n");
cnt++;
diff += d - q;
}
}
printf("%d\n", cnt);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long func(vector<long long> &v, long long start, long long end) {
long long max_end = v[start], cur_max = v[start];
for (long long i = start + 1; i <= end; i++) {
cur_max = max(v[i], cur_max + v[i]);
max_end = max(max_end, cur_max);
}
return max_end;
}
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> v(n);
long long sum = 0, neg = 0;
for (long long i = 0; i < n; i++) {
cin >> v[i];
if (v[i] <= 0) neg = 1;
sum += v[i];
}
if (neg == 0)
cout << "YES\n";
else {
long long maxi = max(func(v, 1, v.size() - 1), func(v, 0, v.size() - 2));
if (maxi >= sum)
cout << "NO\n";
else
cout << "YES\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 1e4;
int c[MAX];
int main() {
string a, b;
cin >> a >> b;
for (int i = 0; i < b.size(); i++) c[i] = int(b[i]) - int('0');
sort(c, c + (b.size()));
int t = b.size() - 1;
string d = "";
for (int i = 0; i < a.size(); i++) {
if (t >= 0 and c[t] > (int(a[i]) - int('0'))) {
d += char(c[t] + int('0'));
t--;
} else
d += a[i];
}
bool p = 0;
for (int i = 0; i < d.size(); i++) {
if (d[i] != '0') p = 1;
if (p) cout << d[i];
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
if (n % 2 == 1) {
puts("-1");
return 0;
}
for (int i = 1; i <= int(n); i++) {
for (int x = 1; x <= int(n); x++) {
for (int y = 1; y <= int(n); y++) {
int j = x, k = y;
if (x > n / 2) j = n - x + 1;
if (y > n / 2) k = n - y + 1;
if (min(j, k) % 2 ^ i % 2)
putchar('b');
else
putchar('w');
}
puts("");
}
puts("");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300000 + 100;
vector<int> v[MAXN];
int a[MAXN];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int s, e;
a[0] = 1000000000;
a[n + 1] = 1000000000;
for (int i = 1; i <= n; i++) {
s = i;
e = i;
while (a[s] % a[i] == 0 && s >= 1) s--;
while (a[e] % a[i] == 0 && e <= n) e++;
i = e - 1;
v[e - s - 2].push_back(s + 1);
}
int ans = 0;
for (int i = n; 0 <= i; i--)
if (v[i].size() != 0) {
ans = i;
break;
}
sort(v[ans].begin(), v[ans].end());
v[ans].resize(unique(v[ans].begin(), v[ans].end()) - v[ans].begin());
cout << v[ans].size() << " " << ans << endl;
for (int i = 0; i < v[ans].size(); i++) cout << v[ans][i] << " ";
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class T2>
inline int chkmax(T &x, const T2 &y) {
return x < y ? x = y, 1 : 0;
}
template <class T, class T2>
inline int chkmin(T &x, const T2 &y) {
return x > y ? x = y, 1 : 0;
}
const int MAXN = (1 << 20);
int n, k;
void read() { cin >> n >> k; }
void solve() {
if (n == k) {
for (int i = 1; i <= n; i++) cout << "1";
cout << '\n';
return;
}
if (k == 1) {
for (int i = 0; i < n - 1; i++) cout << 1;
cout << 0;
cout << '\n';
return;
}
if (k + 2 == n) {
int bit = 1;
for (int i = 1; i <= n; i++) {
cout << bit;
bit ^= 1;
}
cout << '\n';
return;
}
if (k == 2) {
cout << 0;
for (int v = 0; v < n - 2; v++) cout << 1;
cout << 0;
cout << '\n';
return;
}
for (int pref = 0; pref <= k - 2; pref++)
for (int p = 2; p * (pref + 1) <= n; p++) {
int l = k - 2 - pref;
if (p != 2) {
if (l % (p - 2) != 0) continue;
l /= (p - 2);
if (l == 1) continue;
if (l * p + pref != n) continue;
string base = "";
for (int i = 0; i < l - 1; i++) base.push_back('1');
base.push_back('0');
for (int i = 0; i < p; i++) cout << base;
for (int i = 0; i < pref; i++) cout << base[i];
cout << '\n';
return;
} else if (l == 0) {
if ((n - pref) % p != 0) continue;
l = (n - pref) / p;
if (l == 1) continue;
if (l * p + pref != n) continue;
string base = "";
for (int i = 0; i < l - 1; i++) base.push_back('1');
base.push_back('0');
for (int i = 0; i < p; i++) cout << base;
for (int i = 0; i < pref; i++) cout << base[i];
cout << '\n';
return;
}
}
assert(false);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, d[300001], num[300001], low[300001], cnt = 0, res = 0, par[300001],
kt[300001], x, b;
vector<pair<int, int> > a[300001];
void dfs(int u) {
num[u] = low[u] = ++cnt;
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i].first;
if (num[v] == 0) {
par[v] = u;
dfs(v);
low[u] = min(low[u], low[v]);
if (low[v] > num[u]) d[v] = a[u][i].second, a[u][i].second += 2;
} else if (v != par[u])
low[u] = min(low[u], num[v]);
}
}
void loang(int u) {
kt[u] = 1;
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i].first;
if (a[u][i].second == 1) {
res = 1;
return;
} else if (kt[v] == 0 && a[u][i].second < 1)
loang(v);
}
}
int main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v, c;
cin >> u >> v >> c;
a[u].push_back(pair<int, int>(v, c));
a[v].push_back(pair<int, int>(u, c));
}
cin >> x >> b;
dfs(x);
while (b != 0) {
if (d[b] == 1) {
cout << "YES";
return 0;
}
if (kt[b] == 0) loang(b);
if (res == 1) {
cout << "YES";
return 0;
}
b = par[b];
}
cout << "NO";
return 0;
}
| 7 |
#include <bits/stdc++.h>
template <typename A, typename B>
inline char smax(A &a, const B &b) {
return a < b ? a = b, 1 : 0;
}
template <typename A, typename B>
inline char smin(A &a, const B &b) {
return b < a ? a = b, 1 : 0;
}
template <typename I>
inline void read(I &x) {
int f = 0, c;
while (!isdigit(c = getchar())) c == '-' ? f = 1 : 0;
x = c & 15;
while (isdigit(c = getchar())) x = (x << 1) + (x << 3) + (c & 15);
f ? x = -x : 0;
}
const int N = 1e5 + 7;
int n;
int a[N];
inline void work() {
int cnt2 = 0;
long long cnt = 0;
std::sort(a + 1, a + n + 1);
for (int i = 1; i < n; ++i) cnt2 += a[i] == a[i + 1];
if (cnt2 > 1) puts("cslnb"), exit(0);
for (int i = 1; i < n; ++i)
if (a[i] == a[i + 1] && ((i != 1 && a[i - 1] == a[i] - 1) || !a[i]))
puts("cslnb"), exit(0);
else if (a[i] == a[i + 1])
--a[i], ++cnt;
for (int i = 1; i <= n; ++i)
if (a[i] >= i - 1) cnt += a[i] - i + 1;
if (cnt & 1)
puts("sjfnb");
else
puts("cslnb");
}
inline void init() {
read(n);
for (int i = 1; i <= n; ++i) read(a[i]);
}
int main() {
init();
work();
fclose(stdin), fclose(stdout);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const long long max9 = 10 + 1e9, max6 = 10 + 1e6, max12 = 10 + 1e12,
max15 = 10 + 1e15;
const long long min6 = -1 * max6, min9 = -1 * max9, min12 = -1 * max12,
min15 = -1 * max15;
const long long R = 7 + 1e9, NN = 10 + 1e5;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
string s;
cin >> n >> s;
if (n == 2) {
if (s[1] > s[0]) {
cout << "YES" << endl << 2 << endl << s[0] << " " << s[1] << endl;
} else
cout << "NO" << endl;
} else {
cout << "YES" << endl
<< 2 << endl
<< s[0] << " " << s.substr(1, s.size() - 1) << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, mx, sum_1, sum1, mo, o;
int main() {
scanf("%d %d", &n, &k);
vector<bool> v(n);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
if (a == -1) {
v[i] = 0;
sum_1++;
} else {
v[i] = 1;
sum1++;
}
}
for (int d = 1; d <= k; d++) {
mo = sum_1;
o = sum1;
for (int i = d - 1; i < n; i += k) {
if (v[i] == false)
mo--;
else
o--;
}
mx = max(mx, abs(mo - o));
}
printf("%d\n", mx);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
string c;
cin >> c;
int cntb = 0, cntw = 0;
for (int i = 0; i < n; i++) {
if (c[i] == 'B')
cntb++;
else
cntw++;
}
if (cntb % 2 == 1 && cntw % 2 == 1) {
cout << -1;
return 0;
}
vector<int> p;
char swp = 'W', neg = 'B';
if (cntw % 2) swp = 'B', neg = 'W';
for (int i = 1; i < n; i++) {
if (c[i] == c[i - 1] && c[i] == swp) {
c[i] = c[i - 1] = neg;
p.push_back(i);
}
}
for (int i = 0; i < n - 1; i++) {
if (c[i] == swp) {
while (c[i + 1] != swp && i < n - 1) {
c[i] = neg;
c[i + 1] = swp;
i++;
p.push_back(i);
}
c[i] = c[i + 1] = neg;
p.push_back(i + 1);
}
}
cerr << c << '\n';
cout << p.size() << '\n';
for (auto i : p) cout << i << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct box {
int in, out, w, s, v;
} inp[600];
int dp1[600][1005] = {{0}};
int dp2[1005];
inline bool cc1(const box &a, const box &b) {
return a.out < b.out || a.out == b.out && a.in > b.in;
}
int main() {
int i, j, k, l, n, S;
scanf("%d", &n), scanf("%d", &S);
inp[0] = (box){0, 2 * n + 1, 0, S, 0};
for (int i = 1; i <= n; i++)
scanf("%d", &inp[i].in), scanf("%d", &inp[i].out), scanf("%d", &inp[i].w),
scanf("%d", &inp[i].s), scanf("%d", &inp[i].v);
sort(inp, inp + n + 1, cc1);
for (int i = 0; i <= n + 1 - 1; i++) {
k = min(inp[i].s + inp[i].w, S);
vector<int> sub;
for (int j = 0; j <= i; j++) {
if (inp[j].in >= inp[i].in) sub.push_back(j);
}
l = sub.size();
for (int j = inp[i].w; j <= k; j++) {
memset(dp2, 0, sizeof(dp2));
int p, q, r, t;
for (int p = 0; p <= l - 1 - 1; p++) {
q = sub[p], r = sub[p + 1];
dp2[inp[q].out] =
max(dp2[inp[q].out], dp2[inp[q].in] + dp1[q][j - inp[i].w]);
for (int t = inp[q].out; t <= inp[r].out; t++) dp2[t] = dp2[inp[q].out];
}
dp1[i][j] = dp2[inp[i].out] + inp[i].v;
}
for (int j = k + 1; j <= S; j++) dp1[i][j] = dp1[i][j - 1];
}
cout << dp1[n][S] << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, a = 1;
cin >> n;
for (i = 1; i <= n; i++) {
a *= i;
}
a = a / (n * n / 2);
cout << a << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10, K = 1e6 + 10;
int n, m, k, p;
long long rowSum[N], colSum[N];
long long rowGain[K], colGain[K];
priority_queue<long long> rowPQ, colPQ;
long long ans = LLONG_MIN;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
scanf("%d%d%d%d", &n, &m, &k, &p);
for (int r = 1; r <= n; r++)
for (int c = 1; c <= m; c++) {
int a;
scanf("%d", &a);
rowSum[r] += a;
colSum[c] += a;
if (r == n) colPQ.push(colSum[c]);
if (c == m) rowPQ.push(rowSum[r]);
}
for (int kk = 1; kk <= k; kk++) {
rowGain[kk] = rowGain[kk - 1] + rowPQ.top();
int top = rowPQ.top();
top -= p * m;
rowPQ.pop();
rowPQ.push(top);
colGain[kk] = colGain[kk - 1] + colPQ.top();
top = colPQ.top();
top -= p * n;
colPQ.pop();
colPQ.push(top);
}
for (int rowK = 0; rowK <= k; rowK++) {
int colK = k - rowK;
long long cost = (long long)p * rowK * colK;
ans = max(ans, rowGain[rowK] + colGain[colK] - cost);
}
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int xinc[] = {0, 0, 1, -1};
const int yinc[] = {1, -1, 0, 0};
const long double PI = acos(-1.0);
const double EPS = 1e-9;
int n, m, q, c;
map<string, int> sno;
string st;
string s1, s2;
int it;
int parent[N], nbr[N];
int size[N];
void make_set(int v) {
parent[v] = v;
size[v] = 1;
}
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(int u, int v) {
u = find_set(u);
v = find_set(v);
if (u != v) {
if (size[u] < size[v]) swap(u, v);
parent[v] = u;
size[u] += size[v];
}
}
int find_nbr(int v) {
v = find_set(v);
if (nbr[v] == -1) return -1;
return nbr[v] = find_set(nbr[v]);
}
map<int, string> ma;
bool eq(int v1, int v2) {
if (v1 == -1 || v2 == -1) return false;
return v1 == v2;
}
void solve() {
cin >> n >> m >> q;
for (int i = 0; i < n; i++) {
cin >> st;
sno[st] = c++;
ma[c - 1] = st;
make_set(c - 1);
}
memset(nbr, -1, sizeof nbr);
for (int i = 0; i < m; i++) {
cin >> it >> s1 >> s2;
int v1 = sno[s1];
int v2 = sno[s2];
v1 = find_set(v1);
v2 = find_set(v2);
int n1 = find_nbr(v1);
int n2 = find_nbr(v2);
bool valid = true;
if (it == 1) {
if (eq(v1, n2) || eq(v2, n1))
valid = false;
else {
union_sets(v1, v2);
v1 = find_set(v1);
if (n1 != -1 && n2 != -1) {
union_sets(n1, n2);
n1 = find_set(n1);
nbr[v1] = n1;
nbr[n1] = v1;
} else if (n1 != -1) {
nbr[v1] = n1;
nbr[n1] = v1;
} else if (n2 != -1) {
nbr[v1] = n2;
nbr[n2] = v1;
}
}
} else {
if (eq(v1, v2) || eq(n1, n2))
valid = false;
else {
if (n1 != -1) {
union_sets(v2, n1);
}
if (n2 != -1) {
union_sets(v1, n2);
}
v1 = find_set(v1);
v2 = find_set(v2);
nbr[v1] = v2;
nbr[v2] = v1;
}
}
if (valid)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
for (int i = 0; i < q; i++) {
cin >> s1 >> s2;
int v1 = find_set(sno[s1]);
int v2 = find_set(sno[s2]);
int n1 = find_nbr(v1);
int n2 = find_nbr(v2);
if (v1 == v2)
cout << 1 << '\n';
else if (eq(v1, n2) || eq(v2, n1))
cout << 2 << '\n';
else
cout << 3 << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
for (int i = 1; i < n; i++) {
if (s[i] != s[i - 1]) {
cout << "YES" << endl;
cout << s[i - 1] << s[i] << endl;
return 0;
}
}
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &n) {
n = 0;
T f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') f = -1, c = getchar();
while (isdigit(c)) n = n * 10 + c - '0', c = getchar();
n *= f;
}
int n, m, k, lim;
int a[55][20005], f[55][20005], s[55][20005];
int mx[20005 * 4], tag[20005 * 4];
void push_down(int p) {
mx[(p << 1)] += tag[p], mx[(p << 1 | 1)] += tag[p];
tag[(p << 1)] += tag[p], tag[(p << 1 | 1)] += tag[p];
tag[p] = 0;
}
void build(int p, int l, int r, int id) {
tag[p] = 0;
mx[p] = -0x3f3f3f3f;
if (l == r) {
mx[p] = f[id][l] + s[id + 1][l + k - 1] - s[id + 1][l - 1];
return;
}
build((p << 1), l, ((l + r) >> 1), id);
build((p << 1 | 1), ((l + r) >> 1) + 1, r, id);
mx[p] = max(mx[(p << 1)], mx[(p << 1 | 1)]);
}
void update(int p, int l, int r, int ul, int ur, int k) {
if (l >= ul && r <= ur) {
mx[p] += k, tag[p] += k;
return;
}
push_down(p);
if (((l + r) >> 1) >= ul) update((p << 1), l, ((l + r) >> 1), ul, ur, k);
if (((l + r) >> 1) < ur)
update((p << 1 | 1), ((l + r) >> 1) + 1, r, ul, ur, k);
mx[p] = max(mx[(p << 1)], mx[(p << 1 | 1)]);
}
int main() {
cin >> n >> m >> k;
lim = m - k + 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
read(a[i][j]);
s[i][j] = s[i][j - 1] + a[i][j];
}
}
for (int i = 1; i <= lim; i++) {
f[1][i] = s[1][i + k - 1] - s[1][i - 1];
}
build(1, 1, lim, 1);
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= k; j++) {
update(1, 1, lim, 1, min(j, lim), -a[i][j]);
}
for (int j = 1; j <= lim; j++) {
f[i][j] = mx[1] + s[i][j + k - 1] - s[i][j - 1];
update(1, 1, lim, max(j - k + 1, 1), j, a[i][j]);
update(1, 1, lim, j + 1, min(j + k, lim), -a[i][j + k]);
}
build(1, 1, lim, i);
}
int ans = -0x3f3f3f3f;
for (int i = 1; i <= lim; i++) {
ans = max(ans, f[n][i]);
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e4 + 10;
const long long mod = 1e9 + 7;
const double PI = acos(-1);
int p[N];
int v[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 2; i <= n; ++i) {
scanf("%d", &p[i]);
}
int tot = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &v[i]);
}
tot++;
for (int i = 2; i <= n; ++i)
if (v[p[i]] != v[i]) tot++;
printf("%d\n", tot);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
template <typename T>
void print(T v) {
for (auto i = v.begin(); i != v.end(); i++) cout << setw(2) << *i << " ";
cout << endl;
}
template <typename T>
void print_vv(T v, bool same_line = true) {
for (auto i = 0; i < v.size(); i++) {
cout << "{";
for (auto j = 0; j != v[i].size(); j++) {
cout << setw(3) << v[i][j] << ",";
}
cout << "},";
if (same_line) cout << endl;
}
cout << endl;
}
int main() {
int n;
while (cin >> n) {
map<int, vector<pair<int, int>>> queues;
int x, y;
for (int i = 0; i < n; i++) {
cin >> x >> y;
queues[y - x].push_back({x, y});
}
for (auto &q : queues) {
sort(queues[q.first].rbegin(), queues[q.first].rend());
}
vector<pair<int, int>> ans(n);
int w;
for (int i = 0; i < n; i++) {
cin >> w;
if (queues.find(w) == queues.end() || queues[w].empty()) {
cout << "NO\n";
return 0;
}
ans[i] = queues[w].back();
queues[w].pop_back();
}
for (int i = 1; i < n; i++) {
if (ans[i].first <= ans[i - 1].first &&
ans[i].second <= ans[i - 1].second) {
cout << "NO\n";
return 0;
}
}
cout << "YES" << endl;
for (int i = 0; i < int(n); i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int t, k;
long long l, r, p;
long long qpower(long long a, long long b, long long M) {
long long s = 1;
while (b) {
if (b & 1 == 1) s = (s * a) % M;
b >>= 1;
a = (a * a) % M;
}
return s;
}
int main() {
int i;
long long x, y;
scanf("%d", &t);
for (i = 1; i <= t; i++) {
scanf("%d%I64d%I64d%I64d", &k, &l, &r, &p);
if (k == 1) {
printf("%d\n", 2 % p);
continue;
}
x = qpower(2, r + 1, p - 1);
if (x == 0) x = p - 1;
x = qpower(k, x, p);
x = (x - 1 + p) % p;
y = qpower(2, l, p - 1);
if (y == 0) y = p - 1;
y = qpower(k, y, p);
y = (y - 1 + p) % p;
if (y == 0) {
y = qpower(2, r - l + 1, p);
if (k & 1 == 1) y = (y * qpower(qpower(2, r - l, p), p - 2, p)) % p;
printf("%I64d\n", y);
continue;
}
if (k & 1 == 1) y = (y * qpower(2, r - l, p)) % p;
y = qpower(y, p - 2, p);
y = (x * y) % p;
printf("%I64d\n", y);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> q;
int n;
void op(int i, int j) { q.push_back({i, j}); }
void f(int l, int r) {
if (l >= r) return;
int len = (r - l + 1);
if (len % 2 == 0) {
int m = (l + r) / 2;
f(l, m);
f(m + 1, r);
for (int j = 0; j < len / 2; j++) op(l + j, l + len / 2 + j);
} else {
r--;
int m = (l + r) / 2;
f(l, m);
f(m + 1, r);
for (int j = 0; j < len / 2; j++) op(l + j, l + len / 2 + j);
r++;
for (int j = l; j < r; j++) op(j, r);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
int k = log2(n);
k = (1 << k);
f(1, k);
f(n - k + 1, n);
cout << (int)q.size() << "\n";
for (auto &it : q) cout << it.first << " " << it.second << "\n";
}
| 7 |
#include <bits/stdc++.h>
const int N = 1e6 + 5;
int a[N];
int maxn[N];
int minn[N];
int left[N];
int Right[N];
int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }
void insert(int v, int p) {
if (maxn[v] == -1)
maxn[v] = p;
else
maxn[v] = max(maxn[v], p);
if (minn[v] == -1)
minn[v] = p;
else
minn[v] = min(minn[v], p);
}
int main() {
int n, x;
scanf("%d%d", &n, &x);
for (int i = 1; i <= x; i++) maxn[i] = -1, minn[i] = -1;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
insert(a[i], i);
}
int R = x + 1;
Right[x + 1] = n + 1;
while (R--) {
if (maxn[R] == -1) {
Right[R] = Right[R + 1];
continue;
}
if (maxn[R] > Right[R + 1] || R == 0) {
R++;
break;
} else
Right[R] = min(Right[R + 1], minn[R]);
}
maxn[0] = 0;
minn[0] = n + 1;
long long ans = 0;
for (int L = 0; L <= x - 1; L++) {
if (minn[L] != -1) {
if (L - 1 >= 0 && minn[L] < left[L - 1]) {
break;
} else {
if (L - 1 >= 0)
left[L] = max(left[L - 1], maxn[L]);
else
left[L] = maxn[L];
while (R <= x && (Right[R] <= left[L] || L + 1 > R - 1)) R++;
ans += (long long)(x + 2 - R);
}
} else {
left[L] = left[L - 1];
while (R <= x && (Right[R] <= left[L] || L + 1 > R - 1)) R++;
ans += (long long)(x + 2 - R);
}
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200005;
long long n, m;
struct qq {
long long x, y, last;
} e[N * 2];
long long num, last[N];
struct path {
long long x, y, c;
path() {}
path(long long _x, long long _y, long long _c) {
x = _x;
y = _y;
c = _c;
}
};
void init(long long x, long long y) {
num++;
e[num].x = x;
e[num].y = y;
e[num].last = last[x];
last[x] = num;
}
long long fa[N][21];
long long dep[N];
void dfs(long long x) {
for (long long u = 1; u <= 20; u++) fa[x][u] = fa[fa[x][u - 1]][u - 1];
for (long long u = last[x]; u != -1; u = e[u].last) {
long long y = e[u].y;
if (y == fa[x][0]) continue;
fa[y][0] = x;
dep[y] = dep[x] + 1;
dfs(y);
}
}
long long lca(long long x, long long y) {
if (dep[y] > dep[x]) swap(x, y);
for (long long u = 20; u >= 0; u--)
if (dep[fa[x][u]] >= dep[y]) x = fa[x][u];
if (x == y) return x;
for (long long u = 20; u >= 0; u--)
if (fa[x][u] != fa[y][u]) x = fa[x][u], y = fa[y][u];
return fa[x][0];
}
long long s[5];
bool cmp(long long a, long long b) { return dep[a] < dep[b]; }
path mix(path x, path y) {
if (x.c == 0 || y.c == 0) return path(0, 0, 0);
s[1] = lca(x.x, y.x);
s[2] = lca(x.x, y.y);
s[3] = lca(x.y, y.x);
s[4] = lca(x.y, y.y);
sort(s + 1, s + 1 + 4, cmp);
long long mx = max(dep[x.c], dep[y.c]), mn = min(dep[x.c], dep[y.c]);
if (dep[s[1]] < mn || dep[s[3]] < mx) return path(0, 0, 0);
return path(s[3], s[4], lca(s[3], s[4]));
}
long long dis(long long x, long long y) {
long long z = lca(x, y);
return dep[x] + dep[y] - 2 * dep[z];
}
long long mymin(long long x, long long y) {
if (x == -1) return y;
if (y == -1) return x;
return x < y ? x : y;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long tx, ty;
long long d = exgcd(b % a, a, tx, ty);
y = tx;
x = ty - (b / a) * tx;
return d;
}
long long same(long long t1, long long t2, long long f1, long long f2) {
long long tx, ty;
long long d = exgcd(f1, f2, tx, ty);
long long t = ((t2 - t1) % f2 + f2) % f2;
if (t % d != 0) return -1;
tx = (tx * (t / d) % (f2 / d) + (f2 / d)) % (f2 / d);
return tx * f1 + t1;
}
long long G(long long M, long long D, long long L, long long R) {
long long t = L / D;
if (t * D < L) t++;
if (t * D <= R) return t;
if (2 * D > M) return G(M, M - D, M - R, M - L);
long long k = G(D, (-M % D + D) % D, L % D, R % D);
L = L + M * k;
R = R + M * k;
t = L / D;
if (t * D < L) t++;
return t;
}
long long make(long long M, long long D, long long L, long long R) {
long long tx, ty;
long long g = exgcd(M, D, tx, ty);
if ((L - 1) / g >= R / g) return -1;
return G(M, D, L, R);
}
long long diff(long long t1, long long t2, long long f1, long long f2,
long long d) {
long long l = t2 - t1 - d, r = t2 - t1 + d;
l = (l % f2 + f2) % f2;
r = (r % f2 + f2) % f2;
if (l % 2 != 0) return -1;
if (l > r || l == 0) return t1 + r / 2;
if (f2 == d * 2) return t1 + r / 2;
long long p = make(f2, f1 % f2, l, r);
if (p == -1) return p;
return p * f1 + t1 + d - p * f1 % f2 / 2 + l / 2;
}
long long solve(path x, path y) {
path z = mix(x, y);
if (z.c == 0) return -1;
long long d = dis(z.x, z.y), f1 = 2 * dis(x.x, x.y), f2 = 2 * dis(y.x, y.y);
long long d1, d2;
long long t1, t2, t3, t4;
d1 = dis(x.x, z.x);
d2 = dis(x.x, z.y);
if (d1 < d2)
t1 = d1, t2 = f1 - d2;
else
t1 = f1 - d1, t2 = d2;
d1 = dis(y.x, z.x);
d2 = dis(y.x, z.y);
if (d1 < d2)
t3 = d1, t4 = f2 - d2;
else
t3 = f2 - d1, t4 = d2;
long long ans = -1;
ans = mymin(ans, same(t1, t3, f1, f2));
ans = mymin(ans, same(t2, t4, f1, f2));
ans = mymin(ans, diff(t1, t4, f1, f2, d));
ans = mymin(ans, diff(t2, t3, f1, f2, d));
return ans;
}
int main() {
num = 0;
memset(last, -1, sizeof(last));
scanf("%lld", &n);
for (long long u = 1; u < n; u++) {
long long x, y;
scanf("%lld%lld", &x, &y);
init(x, y);
init(y, x);
}
dep[1] = 1;
dfs(1);
scanf("%lld", &m);
for (long long u = 1; u <= m; u++) {
long long a, b, c, d;
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
printf("%lld\n", solve(path(a, b, lca(a, b)), path(c, d, lca(c, d))));
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
stack<char> st;
int jud = 0;
int main() {
int len = 0;
string s;
cin >> len;
if (len == 0) {
return 0;
}
cin >> s;
if (len % 2) {
cout << ":(";
} else {
if (s[0] == ')' || s[len - 1] == '(') {
jud = 0;
cout << ":(";
return 0;
}
int cnt1 = 0, cnt2 = 0;
int jud = 1;
for (int i = 1; i < len - 1; i++) {
if (s[i] == '(')
cnt1++;
else if (s[i] == ')')
cnt2++;
}
for (int i = 1; i < len - 1; i++) {
if (s[i] == '?') {
if (cnt1 < len / 2 - 1) {
s[i] = '(';
st.push(s[i]);
cnt1++;
} else if (cnt2 < len / 2 - 1) {
s[i] = ')';
if (st.size())
st.pop();
else {
cout << ":(";
jud = 0;
break;
}
cnt2++;
}
} else if (s[i] == '(')
st.push(s[i]);
else if (s[i] == ')') {
if (st.size())
st.pop();
else {
cout << ":(";
jud = 0;
break;
}
}
}
if (jud) {
if (!st.size()) {
s[0] = '(';
s[len - 1] = ')';
cout << s;
} else {
cout << ":(";
}
}
}
getchar();
getchar();
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int maxn = 100005;
using namespace std;
struct edge {
int u, w, id;
edge(int u, int w, int id) : u(u), w(w), id(id) {}
};
int dis[2 * maxn], x[maxn], p[maxn], d[maxn], t[maxn];
bool mark[2 * maxn];
pair<int, int> par[2 * maxn];
vector<edge> v[2 * maxn];
vector<int> X;
void dijkstra(int n, int src, int des) {
fill(dis, dis + n, 2e9);
dis[src] = 0;
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
pq.push({0, src});
par[src] = {-1, 0};
while (!pq.empty()) {
int cur = pq.top().second;
pq.pop();
if (mark[cur]) continue;
mark[cur] = true;
for (edge e : v[cur]) {
int u = e.u, w = e.w;
if (dis[u] > dis[cur] + w) {
dis[u] = dis[cur] + w;
pq.push({dis[u], u});
par[u] = {cur, e.id};
}
}
}
cout << dis[des] << endl;
vector<int> rmp;
for (int it = des; it != -1; it = par[it].first)
if (par[it].second) rmp.push_back(par[it].second);
cout << rmp.size() << endl;
for (int i = int(rmp.size()) - 1; i >= 0; i--) cout << rmp[i] << ' ';
cout << endl;
}
int main() {
ios::sync_with_stdio(false);
int n, m, L;
cin >> n >> L;
for (int i = 0; i < n; i++) {
cin >> x[i] >> d[i] >> t[i] >> p[i];
if (x[i] - p[i] >= 0) X.push_back(x[i] - p[i]);
X.push_back(x[i] + d[i]);
}
X.push_back(0);
X.push_back(L);
sort(X.begin(), X.end());
int N = X.size();
for (int i = 0; i < N; i++) {
if (i + 1 < N) v[i].push_back(edge(i + 1, X[i + 1] - X[i], 0));
if (i - 1 >= 0) v[i].push_back(edge(i - 1, X[i] - X[i - 1], 0));
}
for (int i = 0; i < n; i++) {
if (x[i] - p[i] < 0) continue;
int src = lower_bound(X.begin(), X.end(), x[i] - p[i]) - X.begin();
int des = lower_bound(X.begin(), X.end(), x[i] + d[i]) - X.begin();
v[src].push_back(edge(des, p[i] + t[i], i + 1));
}
dijkstra(N, 0, N - 1);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000;
const double eps = 1e-8;
int a[maxn] = {0};
int main() {
int n, i, j, k, sum = 0;
cin >> n;
int t = 0;
for (i = 0; i < n * 2 - 1; i++) {
cin >> a[i];
if (a[i] < 0) t++;
a[i] = abs(a[i]);
sum += a[i];
}
if (n % 2)
cout << sum << endl;
else {
if (t % 2 == 0)
cout << sum << endl;
else {
sort(a, a + 2 * n - 1);
sum -= 2 * a[0];
cout << sum << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int ss[1 << 16];
int deg[16];
int d[16][16];
int f[1 << 16];
int n, m;
int ans;
int main() {
for (int i = 0; i < 16; i++) ss[1 << i] = i;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) d[i][j] = (i == j ? 0 : 100000000);
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
--u, --v;
deg[u]++;
deg[v]++;
d[u][v] = min(d[u][v], w);
d[v][u] = min(d[v][u], w);
ans += w;
}
for (int k = 0; k < n; k++)
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (d[i][k] + d[k][j] < d[i][j]) d[i][j] = d[i][k] + d[k][j];
for (int i = 1; i < n; i++)
if (deg[i] > 0 && d[0][i] == 100000000) {
puts("-1");
return 0;
}
int tmask = 0;
for (int i = 0; i < n; i++)
if (deg[i] % 2 == 1) tmask |= (1 << i);
for (int i = 0; i < (1 << n); i++) f[i] = 100000000;
f[tmask] = 0;
for (int mask = tmask; mask > 0; mask--)
if (f[mask] < 100000000) {
int x = (mask & (mask ^ (mask - 1)));
x = ss[x];
for (int j = x + 1; j < n; j++)
if ((mask ^ (1 << j)) > 0) {
int cmask = mask;
cmask ^= (1 << x);
cmask ^= (1 << j);
f[cmask] = min(f[cmask], f[mask] + d[x][j]);
}
}
printf("%d\n", ans + f[0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
int32_t main(){
ios::sync_with_stdio(0),cin.tie(0);
int T;
cin >> T;
while(T--){
int n;
cin >> n;
int nt=0,nx=0,pt=0,px=0,ans=0;
int l=0;
int t[n+1],x[n+1];
for(int i=0;i<n;i++){
cin >> t[i] >> x[i];
}
t[n]=1e18;
for(int i=0;i<n;i++){
if(t[i]>=nt){
pt=t[i],px=nx;
nx=x[i];
nt=abs(px-nx)+pt;
if(t[i+1]>=nt)ans++;
}
else{
if((x[i]-px)*(x[i]-nx)>0){
l=t[i];
continue;
}
int ct=abs(x[i]-px)+pt;
if(ct>=t[i] and ct<=t[i+1])ans++;
}
l=t[i];
}
cout << ans << '\n';
}
} | 5 |
#include <bits/stdc++.h>
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using namespace std;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int N;
cin >> N;
vector<int> a(N);
for (int i = 0; i < (int)(N); i++) cin >> a[i];
int res = 0;
for (int i = (int)(30); i >= (int)(0); i--) {
int cnt = 0;
for (int j = 0; j < (int)(N); j++) {
if (a[j] >> i & 1) cnt++;
}
if (cnt & 1) {
if (cnt % 4 == 1 || N % 2 == 0)
res = 1;
else
res = 2;
break;
}
}
if (res == 1) {
cout << "WIN\n";
} else if (res == 2) {
cout << "LOSE\n";
} else {
cout << "DRAW\n";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string st;
cin >> st;
int f = 0, s = 0;
for (int i = 0; i < st.size(); i++) {
if (st[i] == '7')
s++;
else if (st[i] == '4')
f++;
}
if (s == 0 && f == 0) {
cout << "-1";
return 0;
;
} else if (f >= s)
cout << "4";
else
cout << "7";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > v;
vector<pair<int, int> > ans;
vector<string> s;
vector<string> s1;
string w;
char let;
int main() {
int n;
cin >> n;
s.resize(n);
s1.resize(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
s1[i] = s[i];
}
cin >> w;
cin >> let;
string w1 = w;
for (int i = 0; i < int(w1.size()); i++)
if (w1[i] < 'a') w1[i] = w1[i] - 'A' + 'a';
for (int i = 0; i < n; i++)
for (int j = 0; j < int(s1[i].size()); j++)
if (s1[i][j] < 'a') s1[i][j] = s1[i][j] - 'A' + 'a';
for (int i = 0; i < n; i++)
for (int j = 0; j < int(w1.size()); j++)
if (w1.substr(j, int(s1[i].size())) == s1[i])
v.push_back(make_pair(j, j + int(s1[i].size()) - 1));
sort(v.begin(), v.end());
if (v.empty()) {
cout << w << endl;
return 0;
}
int beg = v[0].first, en = v[0].second;
for (int i = 1; i < int(v.size()); i++)
if (v[i].first <= en)
en = max(en, v[i].second);
else {
ans.push_back(make_pair(beg, en));
beg = v[i].first;
en = v[i].second;
}
ans.push_back(make_pair(beg, en));
for (int i = 0; i < int(ans.size()); i++)
for (int j = ans[i].first; j <= ans[i].second; j++)
if (w1[j] != let)
if (w[j] < 'a')
w[j] = let - 'a' + 'A';
else
w[j] = let;
else if (w[j] >= 'a')
w[j] = (let == 'a') ? 'b' : 'a';
else
w[j] = (let == 'a') ? 'B' : 'A';
cout << w << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> C;
int main() {
int A[400], W[400], count;
int m, t, r;
bool ok = false;
scanf("%d %d %d", &m, &t, &r);
for (int i = 1; i <= m; i++) scanf("%d", &W[i]);
for (int i = 1; i <= r; i++) {
A[i] = W[1] - i;
C[A[i]] = 1;
}
for (int i = 1; i <= m; i++) {
count = 0;
for (int j = 1; j <= r; j++) {
if (W[i] <= A[j] + t)
continue;
else {
count++;
if (C[W[i] - count]) {
ok = true;
break;
} else {
C[W[i] - count] = 1;
A[j] = W[i] - count;
}
}
}
if (ok) break;
}
int ans = 0;
if (ok) {
printf("-1\n");
return 0;
}
for (int i = W[1] - r; i <= 305; i++) ans += C[i];
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
vector<int> to, ko;
vector<int> ans[2000];
bool f(int x, int y) { return (a[x] > a[y]); };
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
int x, c;
scanf("%d%d", &c, &x);
a.push_back(c);
if (x == 1)
to.push_back(i);
else
ko.push_back(i);
}
sort(to.begin(), to.end(), f);
sort(ko.begin(), ko.end(), f);
int l = 0;
int i = 0;
double sum = 0.0;
for (int L = 0; L < m; L++) {
if (L == m - 1) {
for (int j = l; j < to.size(); j++) {
sum += a[to[j]];
ans[L].push_back(to[j]);
}
for (int j = i; j < ko.size(); j++) {
sum += a[ko[j]];
ans[L].push_back(ko[j]);
}
if (l < to.size()) {
double y = a[to[to.size() - 1]];
if (i < ko.size()) y = min(a[to[to.size() - 1]], a[ko[ko.size() - 1]]);
y /= 2;
sum -= y;
}
continue;
}
if (l < to.size()) {
double y = a[to[l]];
sum += y / 2;
ans[L].push_back(to[l]);
l++;
continue;
}
sum += a[ko[i]];
ans[L].push_back(ko[i]);
i++;
}
printf("%.1f\n", sum);
for (int i = 0; i < m; i++) {
printf("%d ", ans[i].size());
for (int j = 0; j < ans[i].size(); j++) printf("%d ", ans[i][j] + 1);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int i, next = 2, c = 2;
for (i = 0; i < n - 1; i++) {
cout << next << " ";
next += c++;
next %= n;
if (next == 0) {
next += n;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, d, b, mid;
long long a[100005], sum[100005];
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
(x *= 10) += ch - '0';
ch = getchar();
}
return x * f;
}
signed main() {
n = read(), d = read(), b = read();
mid = (n + 1) / 2;
for (long long i = 1; i <= n; i++) a[i] = read(), sum[i] = sum[i - 1] + a[i];
long long avil = 0, avir = 0;
for (long long i = 1; i <= mid; i++)
if (sum[min(i * (d + 1), n)] - b * avil >= b) avil++;
for (long long i = n; i >= mid + 1; i--)
if (sum[n] - sum[max(0ll, n - (n - i + 1) * (d + 1))] - b * avir >= b)
avir++;
cout << max(mid - avil, n - mid - avir);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int binpow(long long int a, long long int b) {
if (a == 0) return 0;
if (b == 0) return 1;
long long int ans = 1;
while (b > 0) {
if (b & 1) ans = ans * a;
a = a * a;
b = b >> 1;
}
return ans;
}
long long int binpowM(long long int a, long long int b,
long long int m = 1000000007) {
if (a == 0) return 0;
if (b == 0) return 1;
long long int ans = 1;
while (b > 0) {
if (b & 1) ans = ans * a;
ans %= m;
a = a * a;
a %= m;
b = b >> 1;
}
return ans;
}
template <typename T>
T Min(T a, T b) {
return a < b ? a : b;
}
template <typename T>
T Max(T a, T b) {
return a > b ? a : b;
}
int n, m;
vector<vector<bool> > vis;
vector<string> a;
bool dfs(int i, int j, char c, char &t) {
if (i < 0 || j < 0 || i >= n || j >= m || t != a[i][j]) return 0;
if (vis[i][j]) {
return 1;
}
bool ans = 0;
vis[i][j] = 1;
if (c != 'L') ans |= dfs(i - 1, j, 'R', t);
if (c != 'R') ans |= dfs(i + 1, j, 'L', t);
if (c != 'U') ans |= dfs(i, j - 1, 'D', t);
if (c != 'D') ans |= dfs(i, j + 1, 'U', t);
return ans;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
vis.resize(n);
vector<bool> X(m, 0);
for (int i = 0; i < (n); ++i) vis[i] = X;
a.resize(n);
for (int i = 0; i < (n); ++i) cin >> a[i];
bool ch = 0;
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) {
if (vis[i][j] == 0) ch |= dfs(i, j, 'a', a[i][j]);
}
ch ? cout << "Yes" << '\n' : cout << "No" << '\n';
return 0;
}
| 3 |
#include<bits/stdc++.h>
#define f first
#define s second
#define _ ios::sync_with_stdio(0);cin.tie(0);
using namespace std;
typedef long long ll;
const int MAX = 1e5+10;
const int MOD = 1e9+7;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;
pair<int,int> seg[2*110];
int n;
vector<int> v;
vector<int> dp;
void build(){
for(int i = 0; i < n; i++) seg[n+i] = {v[i], i};
for(int i = n-1; i >= 0; i--)
seg[i] = seg[i*2].f >= seg[i*2+1].f ? seg[i*2] : seg[i*2+1];
}
pair<int,int> query(int a, int b){
pair<int,int> ret = {-1, -1};
for(a += n, b += n; a <= b; ++a /= 2, --b /= 2){
if (a % 2 == 1) ret = (ret.f >= seg[a].f ? ret : seg[a]);
if (b % 2 == 0) ret = (ret.f >= seg[b].f ? ret : seg[b]);
}
return ret;
}
void get_dp(int l, int r, int dpt=0){
if(l > r) return;
pair<int,int> mx = query(l, r);
dp[mx.s] = dpt;
get_dp(mx.s+1, r, dpt+1);
get_dp(l, mx.s-1, dpt+1);
}
void solve(){
cin >> n;
v = vector<int>(n);
dp = vector<int>(n);
for(int &x: v)
cin >> x;
build();
get_dp(0, n-1);
for(int i = 0; i < n; i++){
if(i) cout << " " ;
cout << dp[i];
}
cout << endl;
}
int main(){_
int t = 1;
cin >> t;
while(t--)
solve();
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <typename T>
inline void rit(T &x) {
char c;
for (x = 0, c = getchar(); c < '-'; c = getchar())
;
for (; c >= '0'; x = x * 10 + c - '0', c = getchar())
;
}
int Q, op, x, c, p = 1;
long long int s[500001];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
rit(Q);
while (Q--) {
rit(op);
if (op == 1) {
s[c + 1] = s[c] + x, ++c, rit(x);
} else {
while (p < c && s[p] + x >= (s[p + 1] - s[p]) * p) ++p;
double ans = (double)x - (double)(s[p] + x) / p;
int a = ans;
cout << a << '.' << setw(7) << setfill('0') << (int)((ans - a) * 1e7)
<< '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int num = 2 * 1e5 + 10;
int a[num];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
int ans = inf;
for (int i = 1; i + n / 2 <= n; i++) {
ans = min(ans, a[i + n / 2] - a[i]);
}
printf("%d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int n = 0;
scanf("%d", &n);
int mat[100][100];
int i = 0;
int j = 0;
int temparr[n + 2];
for (i = 0; i <= n; i++) {
temparr[i] = 0;
}
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
scanf("%d", &mat[i][j]);
}
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
if (mat[i][j] == 1) {
temparr[i]++;
} else if (mat[i][j] == 2) {
temparr[j]++;
} else if (mat[i][j] == 3) {
temparr[i]++;
temparr[j]++;
}
}
int k;
int tempcount = 0;
int min = temparr[0];
int arr2[n];
for (i = 0; i < n; i++) {
arr2[i] = 0;
}
int l = 0;
for (i = 0; i < n; i++) {
if (temparr[i] == 0) {
arr2[l] = i + 1;
l++;
tempcount++;
}
}
printf("%d\n", tempcount);
if (tempcount > 0) {
for (i = 0; i < tempcount; i++) {
printf("%d ", arr2[i]);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 1000007;
struct eT {
void setd(int _u, int _v, int _l) { u = _u, v = _v, last = _l; }
int u, v, last;
} edge[MAXN], re[MAXN];
int n, m, S, T;
int ke, la[MAXN];
int kr, lr[MAXN];
int q[MAXN], lev[MAXN];
void init();
void input();
void work();
void pre(int &x) {
--x;
if (x < 0) x = MAXN - 1;
}
void nxt(int &x) {
++x;
if (x >= MAXN) x = 0;
}
int main() {
init();
input();
work();
}
void init() { ios::sync_with_stdio(false); }
void input() {
scanf("%d%d", &n, &m);
memset(la, -1, sizeof(la));
memset(lr, -1, sizeof(lr));
int u, v;
for (int i = 0; i < m; ++i) {
scanf("%d%d", &u, &v);
edge[ke].setd(u, v, la[u]);
la[u] = ke++;
re[kr].setd(v, u, lr[v]);
lr[v] = kr++;
}
scanf("%d%d", &S, &T);
}
void work() {
int l = 0, r = 0, now, v;
bool flag;
q[r++] = T;
memset(lev, -1, sizeof(lev));
lev[T] = 0;
while (l ^ r) {
now = q[l];
nxt(l);
for (int i = lr[now]; ~i; i = re[i].last) {
if (lev[v = re[i].v] == -1) {
flag = true;
for (int j = la[v]; ~j; j = edge[j].last) {
if (lev[edge[j].v] ^ lev[now]) {
flag = false;
break;
}
}
if (flag) {
lev[v] = lev[now];
pre(l);
q[l] = v;
} else {
lev[v] = lev[now] + 1;
q[r] = v;
nxt(r);
}
}
}
}
cout << lev[S] << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
for (int iq = 0; iq < t; iq++) {
long long first;
cin >> first;
for (int i = 0; i < first - ceil(first / 4.0); i++) cout << 9;
for (int i = 0; i < ceil(first / 4.0); i++) cout << 8;
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int n, m;
std::vector<int> el[200100];
int dist[200100];
int chk[200100];
int da[200100];
void dfs(int x, int d) {
chk[x] = 1;
dist[x] = d;
for (int i = 0; i < el[x].size(); i++) {
int y = el[x][i];
if (chk[y] == 1) continue;
dfs(y, d + 1);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
el[x].push_back(y);
el[y].push_back(x);
}
dfs(1, 0);
if (m == 2) {
printf("Yes\n");
for (int i = 1; i <= n; i++) {
printf("%d ", dist[i] % 2 + 1);
}
return 0;
}
int pa = 1;
for (int i = 1; i <= n; i++) {
if (dist[pa] < dist[i]) pa = i;
chk[i] = 0;
}
dfs(pa, 0);
int pb = 1;
for (int i = 1; i <= n; i++) {
if (dist[pb] < dist[i]) pb = i;
chk[i] = 0;
da[i] = dist[i];
}
dfs(pb, 0);
for (int i = 1; i <= n; i++) {
if (da[i] >= m - 1 && dist[i] >= m - 1 && da[i] + dist[i] != da[pb]) {
printf("No\n");
return 0;
} else if (da[i] >= dist[i]) {
dist[i] = da[pb] - da[i];
}
}
printf("Yes\n");
for (int i = 1; i <= n; i++) {
printf("%d ", dist[i] % m + 1);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 10;
long long a[maxn];
int main() {
std::ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 2; i <= n; i++) a[i] += a[i - 1];
long long mx = a[n];
for (int i = n - 1; i >= 2; i--) {
mx = max(a[i] - mx, mx);
}
cout << mx << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(bool x) { return (x ? "T" : "F"); }
string to_string(const char* s) { return to_string((string)s); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename V>
string to_string(V v) {
bool f = true;
string res = "[";
for (const auto& x : v) {
if (!f) res += ", ";
f = false;
res += to_string(x);
}
res += "]";
return res;
}
void debug() { cerr << endl; }
template <typename H, typename... T>
void debug(H h, T... t) {
cerr << " " << to_string(h);
debug(t...);
}
using ll = long long;
struct Node {
int x, i;
Node() {}
Node(int _x, int _i) : x(_x), i(_i) {}
bool operator<(const Node& _n) const { return x < _n.x; }
};
void solve() {
int m, n;
cin >> m >> n;
vector<Node> a(n), b(n);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x--;
a[i] = {x, i};
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x--;
b[i] = {x, i};
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
int ha = m / 2, ce = (m + 1) / 2;
vector<ll> s(n);
int i, j;
for (i = 0; i < n; i++) {
int x = a[i].x;
if (x < ha) {
j = 0;
s[(n + j - i) % n] += -m;
j = lower_bound(b.begin(), b.end(), Node{x, -1}) - b.begin();
s[(n + j - i) % n] += -2ll * x;
j = lower_bound(b.begin(), b.end(), Node{x + ce, -1}) - b.begin();
s[(n + j - i) % n] += 2ll * x + m;
} else {
j = 0;
s[(n + j - i) % n] += m;
j = lower_bound(b.begin(), b.end(), Node{x - ha, -1}) - b.begin();
s[(n + j - i) % n] += 2ll * x - m;
j = lower_bound(b.begin(), b.end(), Node{x, -1}) - b.begin();
s[(n + j - i) % n] += -2ll * x;
}
}
for (j = 0; j < n; j++) {
int x = b[j].x;
if (x < ce) {
i = n - 1;
s[(n + j - i) % n] += 0;
i = upper_bound(a.begin(), a.end(), Node{x + ha, -1}) - a.begin() - 1;
s[(n + j - i) % n] += -2ll * x;
i = upper_bound(a.begin(), a.end(), Node{x, -1}) - a.begin() - 1;
s[(n + j - i) % n] += 2ll * x;
} else {
i = n - 1;
s[(n + j - i) % n] += 0;
i = upper_bound(a.begin(), a.end(), Node{x, -1}) - a.begin() - 1;
s[(n + j - i) % n] += 2ll * x;
i = upper_bound(a.begin(), a.end(), Node{x - ce, -1}) - a.begin() - 1;
s[(n + j - i) % n] += -2ll * x;
}
}
ll sum = 0;
for (int i = 0; i < n; i++) {
int x = (a[i].x - b[i].x + m) % m;
int y = (b[i].x - a[i].x + m) % m;
sum += min(x, y);
}
s[0] = sum;
for (int t = 1; t < n; t++) {
s[t] += s[t - 1];
}
int t = min_element(s.begin(), s.end()) - s.begin();
cout << s[t] << "\n";
vector<int> res(n);
for (int i = 0; i < n; i++) {
res[a[i].i] = b[(i + t) % n].i + 1;
}
for (auto& x : res) {
cout << x << ' ';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
cout << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long INF = 1e18;
void solve() {
long long N, K;
cin >> N >> K;
vector<long long> a(N);
for (int i = 0; i < N; i++) cin >> a[i];
bool exist = false;
for (auto val : a) {
if (val == K) exist = true;
}
if (!exist) {
cout << "no"
<< "\n";
return;
}
if (N == 1) {
cout << "yes"
<< "\n";
return;
}
long long mini = 0;
long long now = 0;
bool LastMin = true;
for (int i = 0; i < N; i++) {
if (!LastMin and a[i] >= K) {
cout << "yes"
<< "\n";
return;
}
if (a[i] >= K)
now++;
else
now--;
LastMin = chmin(mini, now);
}
cout << "no"
<< "\n";
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long T;
cin >> T;
while (T--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 5;
const long long mod = 1000000007;
long long t;
long long i, j;
long long n, m, k;
long long x, y;
vector<long long> g;
string s;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s;
for (i = 0; i <= s.size() - 1; i++) {
if (s[i] == '(')
x++;
else if (s[i] == ')')
y++;
else
k++;
}
if (x <= y || (x - y) < k)
cout << -1;
else {
long long tmp1 = 0;
long long tmp2 = 0;
long long tmp3 = x - y;
long long zzz = 0;
for (i = 0; i < s.size(); i++) {
if (s[i] == '(')
tmp1++;
else if (s[i] == ')')
tmp1--;
if (tmp1 < 0 || tmp1 <= 0 && s[i] == '#') {
zzz = 1;
break;
}
if (s[i] == '#') {
tmp2++;
if (tmp2 < k) {
g.push_back(1);
tmp3--;
tmp1--;
} else {
tmp1 -= tmp3;
g.push_back(tmp3);
if (tmp1 < 0) {
zzz = 1;
break;
}
}
}
}
if (zzz == 1)
cout << -1 << '\n';
else {
for (i = 0; i <= g.size() - 1; i++) cout << g[i] << '\n';
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
const long long inf = 1e17;
int main() {
ios_base::sync_with_stdio(false);
long long n, t, k;
cin >> n >> t >> k;
vector<long long> a(t);
vector<vector<long long> > g(n + 1, vector<long long>(0));
long long mink = 0;
for (int i = 0; i < t; i++) {
cin >> a[i];
if (i != 0) {
if (a[i - 1] > a[i]) mink += a[i - 1] - a[i];
}
}
mink += a[t - 1];
if (mink > k) {
cout << -1;
return 0;
}
mink = k - mink;
vector<long long> fst;
queue<long long> q;
q.push(1);
long long curk = 0;
long long sch = 2;
for (int p = 0; p < t; p++) {
long long c = a[p];
long long first = q.front();
queue<long long> q1;
fst.push_back(first);
while (c > 0 && !q.empty()) {
long long x = q.front();
q.pop();
g[x].push_back(sch);
q1.push(sch);
sch++;
c--;
}
for (int i = 1; i <= c; i++) {
g[first].push_back(sch);
q1.push(sch);
sch++;
}
q = q1;
}
if (mink == 0) {
cout << n << '\n';
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) {
cout << i << ' ' << g[i][j] << '\n';
}
}
return 0;
}
fst.push_back(n - a.back() + 1);
for (int i = 0; i < fst.size() - 1 && mink > 0; i++) {
long long c = fst[i];
for (int j = c + 1; j < fst[i + 1] && mink > 0; j++) {
if (g[j].size() == 0) continue;
g[c].push_back(g[j][0]);
g[j][0] = -1;
mink--;
}
}
if (mink != 0) {
cout << -1;
return 0;
}
cout << n << '\n';
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) {
if (g[i][j] != -1) cout << i << ' ' << g[i][j] << '\n';
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000000000LL;
int main() {
int M, N;
scanf("%d%d", &M, &N);
static long long A[1000], B[1000];
memset(A, 0, sizeof(A));
memset(B, 0, sizeof(B));
for (int i = 0; i < M; i++)
for (int j = 0; j < N; j++) {
int X;
scanf("%d", &X);
A[i] += X;
B[j] += X;
}
long long Min_0 = inf, Min_1 = inf;
int Best_X, Best_Y;
for (int i = 0; i <= M; i++) {
long long Sum = 0;
for (int j = 0; j < M; j++) {
int T = 4 * (i - j) - 2;
Sum += A[j] * T * T;
}
if (Sum < Min_0) {
Min_0 = Sum;
Best_X = i;
}
}
for (int i = 0; i <= N; i++) {
long long Sum = 0;
for (int j = 0; j < N; j++) {
int T = 4 * (i - j) - 2;
Sum += B[j] * T * T;
}
if (Sum < Min_1) {
Min_1 = Sum;
Best_Y = i;
}
}
cout << Min_0 + Min_1 << endl << Best_X << ' ' << Best_Y << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t5, f0;
int main() {
int n, rub;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &rub);
if (rub == 25)
t5++;
else if (rub == 50) {
if (!t5) {
puts("NO");
return 0;
}
f0++;
t5--;
} else {
if (f0 && t5)
f0--, t5--;
else if (t5 >= 3)
t5 -= 3;
else {
puts("NO");
return 0;
}
}
}
puts("YES");
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const int N = 2e5 + 7;
int Dx[] = {1, 0, -1, 0, 1, 1, -1, -1};
int Dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long powm(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b % 2) res *= a;
a *= a;
b /= 2;
}
return res;
}
vector<int> adj[N];
int par[N];
int sz[N];
struct kruskal {
void inti(int n) {
for (int i = 0; i <= n; i++) {
par[i] = i;
sz[i] = 1;
}
}
int find(int x) {
if (x == par[x]) return x;
return par[x] = find(par[x]);
}
bool same(int a, int b) { return find(a) == find(b); }
void unin(int a, int b) {
a = find(a);
b = find(b);
if (sz[a] < sz[b]) swap(a, b);
par[b] = a;
sz[a] += b;
}
};
int prime[1007];
void seivEraston(int n) {
memset(prime, true, sizeof(prime));
for (int i = 2; i * i <= n; i++) {
if (prime[i])
for (int j = i * i; j <= n; j += i) prime[j] = 0;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s, str;
int arr[300] = {0};
cin >> s;
str = s;
int n = s.size();
for (int i = 0; i < n; i++) arr[s[i]]++;
int k = 0;
for (int i = 0; i < 256; i++)
if (arr[i] > arr[k]) k = i;
seivEraston(n);
prime[1] = true;
for (int i = 2; i + i <= n; i++) prime[i] = false;
for (int i = 1; i <= n; i++)
if (!prime[i]) {
if (arr[k] == 0) {
cout << "NO";
return 0;
}
arr[s[i - 1] = k]--;
}
k = 0;
for (int i = 1; i <= n; i++)
if (prime[i]) {
while (arr[k] == 0) k++;
arr[s[i - 1] = k]--;
}
cout << "YES\n";
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class P, class Q>
inline void smin(P &a, Q b) {
if (b < a) a = b;
}
template <class P, class Q>
inline void smax(P &a, Q b) {
if (a < b) a = b;
}
const int maxn = 100000 + 100;
int n, m;
vector<pair<int, int> > adj[maxn];
bool mark[maxn];
int pxor[maxn];
vector<int> base;
void dfs(int u, int cur = 0) {
mark[u] = true;
pxor[u] = cur;
for (pair<int, int> vw : adj[u])
if (!mark[vw.first]) dfs(vw.first, cur ^ vw.second);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0, i__n = (int)(m); i < i__n; ++i) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
adj[u].push_back({v, w}), adj[v].push_back({u, w});
}
dfs(0);
for (int u = 0, u__n = (int)(n); u < u__n; ++u)
for (pair<int, int> vw : adj[u])
if (u <= vw.first) {
int x = pxor[u] ^ pxor[vw.first] ^ vw.second;
for (int p : base)
if ((x ^ p) < x) x ^= p;
if (x == 0) continue;
for (int &p : base)
if ((p ^ x) < p) p ^= x;
base.push_back(x);
}
int ans = pxor[0] ^ pxor[n - 1];
for (int p : base)
if ((ans ^ p) < ans) ans ^= p;
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int w[N], parent[N];
long long f[N];
long long ans = 0;
vector<pair<int, int>> g[N];
void dfs(int v) {
long long mx1 = 0, mx2 = 0;
for (auto P : g[v]) {
int u = P.first;
int c = P.second;
if (u != parent[v]) {
parent[u] = v;
dfs(u);
long long curVal = f[u] + w[u] - c;
f[v] = max(f[v], curVal);
if (curVal > mx1) {
mx2 = mx1;
mx1 = curVal;
} else if (curVal > mx2) {
mx2 = curVal;
}
}
}
ans = max(ans, mx1 + 0LL + mx2 + w[v]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> w[i];
}
for (int i = 1; i <= n - 1; ++i) {
int v, u, c;
cin >> v >> u >> c;
g[v].push_back(make_pair(u, c));
g[u].push_back(make_pair(v, c));
}
dfs(1);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 2 * (int)1e5 + 10;
const int INF = (int)1e9 + 47;
vector<int> g[nax];
int n, k;
int lvl[nax], tin[nax], tout[nax];
int cnt = 0;
int timer = 0;
int ver[nax];
int seen[nax];
int par[nax];
int vr[nax];
vector<pair<int, int>> vec;
void dfs(int v, int p = -1) {
if (p != -1) lvl[v] = lvl[p] + 1;
vec.push_back({lvl[v], v});
par[v] = p;
if (g[v].size() == 1 && p != -1) cnt++;
if (p != -1) lvl[v] = lvl[p] + 1;
for (auto to : g[v]) {
if (to == p) continue;
dfs(to, v);
}
}
long long f(int red, int blue) {
int w = n - red - blue;
return w * 1ll * (red - blue);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
--a, --b;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(0);
sort(vec.begin(), vec.end(), greater<pair<int, int>>());
vector<int> vv;
for (int i = 0; i < n; i++) {
int cur = vec[i].second;
int cc = 0;
while (cur != -1 && !seen[cur]) {
cc++;
seen[cur] = 1;
cur = par[cur];
}
vv.push_back(cc);
}
sort(vv.begin(), vv.end(), greater<int>());
int blue = n;
long long best_ans = -(long long)1e18;
for (int i = 0; i < min(k, cnt); i++) {
blue -= vv[i];
int l = 0, r = blue;
for (int it = 0; it < 40; it++) {
int mid = (l + r) / 2;
if (f(i + 1, mid + 1) <= f(i + 1, mid))
l = mid;
else
r = mid;
}
if ((f(i + 1, r) > f(i + 1, r + 1) && r + 1 < blue) ||
(f(i + 1, r - 1) < f(i + 1, r) && r - 1 >= 0))
throw 47;
best_ans = max(best_ans, f(i + 1, r));
}
while (cnt <= k) {
best_ans = max(best_ans, (n - cnt) * 1ll * cnt);
cnt++;
}
cout << best_ans << '\n';
}
| 8 |
#include <bits/stdc++.h>
int a[100002];
int b[5002];
int c[10002];
int main() {
int i, k, t, m, temp, max = 0, count = 0;
memset(b, 0, 5002 * sizeof(int));
memset(c, 0, 10002 * sizeof(int));
scanf("%d", &m);
k = 0;
t = 10001;
for (i = 0; i < m; i++) {
scanf("%d", &a[i]);
if (max < a[i]) max = a[i];
b[a[i]]++;
}
b[max] = 1;
for (i = 0; i < 5002; i++) {
if (b[i] == 1) {
c[t] = i;
t--;
count++;
} else if (b[i] >= 2) {
c[t] = i;
c[k] = i;
t--;
k++;
count += 2;
}
}
printf("%d\n", count);
for (i = 0; i < 10002; i++) {
if (c[i] != 0) {
printf("%d", c[i]);
if (i == 10001)
printf("\n");
else
printf(" ");
}
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.