solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
struct ji {
int nex, to, len;
} edge[200005 << 1];
int t, n, x, y, z, E, head[200005];
long long ans1, ans2;
void add(int x, int y, int z) {
edge[E].nex = head[x];
edge[E].to = y;
edge[E].len = z;
head[x] = E++;
}
int dfs(int k, int fa) {
int sz = 1, s;
for (int i = head[k]; i != -1; i = edge[i].nex)
if (edge[i].to != fa) {
s = dfs(edge[i].to, k);
if (s & 1) ans1 += edge[i].len;
ans2 += 1LL * min(n - s, s) * edge[i].len;
sz += s;
}
return sz;
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
n *= 2;
for (int i = 1; i <= n; i++) head[i] = -1;
E = ans1 = ans2 = 0;
for (int i = 1; i < n; i++) {
scanf("%d%d%d", &x, &y, &z);
add(x, y, z);
add(y, x, z);
}
dfs(1, 0);
printf("%lld %lld\n", ans1, ans2);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int R, d, n;
int main() {
scanf("%d%d%d", &R, &d, &n);
int ans = 0, x, y, r;
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d", &x, &y, &r);
double D = sqrt(x * x + y * y);
if (D >= (double)R - d + r && D <= (double)R - r) ans++;
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : -x;
}
const int N = 1e5 + 4, inf = 0x3f3f3f3f;
namespace sz {
int n, t[N << 3];
inline void clear(int cn) {
n = cn;
for (int i = 1; i <= n; i++) t[i] = -inf;
}
inline void add(int x, int v) {
for (; x <= n; x += x & -x) t[x] = max(t[x], v);
}
inline int ask(int x) {
int ret = -inf;
for (; x; x -= x & -x) ret = max(ret, t[x]);
return ret;
}
} // namespace sz
namespace seg {
int t[N << 3], m;
inline void clear(int n) {
m = 1;
while (m < n) {
m <<= 1;
}
memset(t, 0x3f, sizeof(int) * (n + m + 1));
}
void modify(int x, int v) {
x += m;
while (x) {
t[x] = min(t[x], v);
x >>= 1;
}
}
int query(int ql, int qr) {
int ret = inf;
for (ql += m - 1, qr += m + 1; ql ^ qr ^ 1; ql >>= 1, qr >>= 1) {
if (~ql & 1) ret = min(ret, t[ql ^ 1]);
if (qr & 1) ret = min(ret, t[qr ^ 1]);
}
return ret;
}
} // namespace seg
struct poin {
int x, y, id, v;
} a[N], b[N], c[N << 2];
int ans, d[N << 3];
inline bool comp_x(const poin &a, const poin &b) {
return a.x == b.x ? (a.y == b.y ? a.id < b.id : a.y < b.y) : a.x < b.x;
}
inline bool comp_v(const poin &a, const poin &b) { return a.id < b.id; }
inline void getans(int n) {
sort(c + 1, c + n + 1, comp_x);
for (int i = 1; i <= n; i++) d[i] = c[i].y;
sort(d + 1, d + n + 1);
int cn = unique(d + 1, d + n + 1) - d - 1;
sz::clear(cn);
for (int i = 1, r; i <= n; i++) {
r = lower_bound(d + 1, d + cn + 1, c[i].y) - d;
if (c[i].id != -1) {
ans =
min((long long)ans,
max(((long long)c[i].id + c[i].x + c[i].y - sz::ask(r) + 3) >> 2,
(long long)c[i].v));
} else {
sz::add(r, c[i].x + c[i].y);
}
}
}
inline void findnear(int n) {
sort(c + 1, c + n + 1, comp_x);
for (int i = 1; i <= n; i++) d[i] = c[i].y;
sort(d + 1, d + n + 1);
int cn = unique(d + 1, d + n + 1) - d - 1;
sz::clear(cn);
for (int i = 1, r; i <= n; i++) {
r = lower_bound(d + 1, d + cn + 1, c[i].y) - d;
if (c[i].id) {
a[c[i].id].id = min(a[c[i].id].id, c[i].x + c[i].y - sz::ask(r));
} else {
sz::add(r, c[i].x + c[i].y);
}
}
}
struct ques {
int x_1, y_1, x_2, y_2, id, mn;
} cq[N << 1];
inline bool comp_cq(const ques &a, const ques &b) {
return a.x_1 == b.x_1 ? a.id < b.id : a.x_1 < b.x_1;
}
poin Q1[N << 1], Q2[N << 1], Q3[N << 1], Q4[N << 1];
int cq1, cq2, cq3, cq4, cq5, cq6;
ques Q5[N], Q6[N];
inline void getlineans(int n) {
sort(cq + 1, cq + n + 1, comp_cq);
int cn = 0;
for (int i = 1; i <= n; i++) {
d[++cn] = cq[i].y_1;
d[++cn] = cq[i].y_2;
}
sort(d + 1, d + cn + 1);
cn = unique(d + 1, d + cn + 1) - d - 1;
seg::clear(cn);
for (int i = 1, l, r; i <= n; i++) {
r = lower_bound(d + 1, d + cn + 1, cq[i].y_1) - d;
l = lower_bound(d + 1, d + cn + 1, cq[i].y_2) - d;
if (cq[i].id != -1) {
assert(l <= r);
ans =
min((long long)ans,
max(((long long)cq[i].id + cq[i].x_1 + seg::query(l, r) + 3) >> 2,
(long long)cq[i].mn));
} else {
seg::modify(r, -cq[i].x_1);
}
}
}
int n, m, tot;
inline void Findnear() {
findnear(n + m);
for (int i = 1; i <= n + m; i++) c[i].x = -c[i].x;
findnear(n + m);
for (int i = 1; i <= n + m; i++) c[i].y = -c[i].y;
findnear(n + m);
for (int i = 1; i <= n + m; i++) c[i].x = -c[i].x;
findnear(n + m);
}
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) {
a[i].x = c[i].x = read();
a[i].y = c[i].y = read();
a[i].id = inf;
c[i].id = i;
}
for (int i = 1; i <= m; i++) {
b[i].x = c[i + n].x = read();
b[i].y = c[i + n].y = read();
}
Findnear();
sort(a + 1, a + n + 1, comp_v);
int lx = -inf, rx = inf, ly = -inf, ry = inf;
ans = a[n].id;
for (int i = n, sub, d1, d2, u1, u2, v1, v2, mn; i; i--) {
lx = max(lx, a[i].y - a[i].x);
rx = min(rx, a[i].y - a[i].x);
ly = max(ly, a[i].y + a[i].x);
ry = min(ry, a[i].y + a[i].x);
if (i == 1) break;
sub = a[i - 1].id;
d1 = lx - rx + (sub << 1);
d2 = ly - ry + (sub << 1);
mn = max(lx - rx, ly - ry) + 1 >> 1;
if (d1 == d2) {
u1 = rx * 2 + d1 - (sub << 1);
u2 = lx * 2 - d1 + (sub << 1);
v1 = ry * 2 + d2 - (sub << 1);
v2 = ly * 2 - d2 + (sub << 1);
Q1[++cq1] = (poin){(v1 - u1) >> 1, (v1 + u1) >> 1, d1, mn};
Q2[++cq2] = (poin){(v1 - u1) >> 1, (v1 + u1) >> 1, d1, mn};
Q3[++cq3] = (poin){(v1 - u1) >> 1, (v1 + u1) >> 1, d1, mn};
Q4[++cq4] = (poin){(v1 - u1) >> 1, (v1 + u1) >> 1, d1, mn};
} else if (d1 < d2) {
u1 = rx * 2 + d2 - (sub << 1);
u2 = lx * 2 - d2 + (sub << 1);
v1 = ry * 2 + d2 - (sub << 1);
v2 = ly * 2 - d2 + (sub << 1);
Q1[++cq1] = (poin){(v1 - u1) >> 1, (v1 + u1) >> 1, d2, mn};
Q2[++cq2] = (poin){(v1 - u1) >> 1, (v1 + u1) >> 1, d2, mn};
Q3[++cq3] = (poin){(v1 - u1) >> 1, (v1 + u1) >> 1, d2, mn};
Q1[++cq1] = (poin){(v1 - u2) >> 1, (v1 + u2) >> 1, d2, mn};
Q3[++cq3] = (poin){(v1 - u2) >> 1, (v1 + u2) >> 1, d2, mn};
Q4[++cq4] = (poin){(v1 - u2) >> 1, (v1 + u2) >> 1, d2, mn};
Q5[++cq5] = (ques){(v1 - u1) >> 1,
(v1 + u1) >> 1,
(v1 - u2) >> 1,
(v1 + u2) >> 1,
d2,
mn};
} else {
u1 = rx * 2 + d1 - (sub << 1);
u2 = lx * 2 - d1 + (sub << 1);
v1 = ry * 2 + d1 - (sub << 1);
v2 = ly * 2 - d1 + (sub << 1);
Q1[++cq1] = (poin){(v1 - u1) >> 1, (v1 + u1) >> 1, d1, mn};
Q2[++cq2] = (poin){(v1 - u1) >> 1, (v1 + u1) >> 1, d1, mn};
Q4[++cq4] = (poin){(v1 - u1) >> 1, (v1 + u1) >> 1, d1, mn};
Q2[++cq2] = (poin){(v2 - u1) >> 1, (v2 + u1) >> 1, d1, mn};
Q3[++cq3] = (poin){(v2 - u1) >> 1, (v2 + u1) >> 1, d1, mn};
Q4[++cq4] = (poin){(v2 - u1) >> 1, (v2 + u1) >> 1, d1, mn};
Q6[++cq6] = (ques){(v1 - u1) >> 1,
(v1 + u1) >> 1,
(v2 - u1) >> 1,
(v2 + u1) >> 1,
d1,
mn};
}
}
ans = min(ans, max(lx - rx, ly - ry) + 1 >> 1);
tot = 0;
for (int i = 1; i <= m; i++) {
b[i].x *= 2;
b[i].y *= 2;
b[i].id = -1;
c[++tot] = b[i];
}
for (int i = 1; i <= cq3; i++) c[++tot] = Q3[i];
getans(tot);
tot = 0;
for (int i = 1; i <= m; i++) c[++tot] = b[i];
for (int i = 1; i <= cq4; i++) c[++tot] = Q4[i];
for (int i = 1; i <= tot; i++) c[i].x = -c[i].x;
getans(tot);
tot = 0;
for (int i = 1; i <= m; i++) c[++tot] = b[i];
for (int i = 1; i <= cq1; i++) c[++tot] = Q1[i];
for (int i = 1; i <= tot; i++) {
c[i].x = -c[i].x;
c[i].y = -c[i].y;
}
getans(tot);
tot = 0;
for (int i = 1; i <= m; i++) c[++tot] = b[i];
for (int i = 1; i <= cq2; i++) c[++tot] = Q2[i];
for (int i = 1; i <= tot; i++) c[i].y = -c[i].y;
getans(tot);
tot = 0;
for (int i = 1; i <= m; i++)
cq[++tot] = (ques){b[i].x + b[i].y, b[i].y - b[i].x, 0, 0, -1, 0};
for (int i = 1; i <= cq5; i++) {
static ques v;
v = Q5[i];
cq[++tot] =
(ques){v.x_1 + v.y_1, v.y_1 - v.x_1, 0, v.y_2 - v.x_2, v.id, v.mn};
}
getlineans(tot);
for (int i = 1; i <= tot; i++) cq[i].x_1 = -cq[i].x_1;
getlineans(tot);
tot = 0;
for (int i = 1; i <= m; i++)
cq[++tot] = (ques){b[i].y - b[i].x, b[i].x + b[i].y, 0, 0, -1, 0};
for (int i = 1; i <= cq6; i++) {
static ques v;
v = Q6[i];
cq[++tot] =
(ques){v.y_1 - v.x_1, v.x_1 + v.y_1, 0, v.x_2 + v.y_2, v.id, v.mn};
}
getlineans(tot);
for (int i = 1; i <= tot; i++) cq[i].x_1 = -cq[i].x_1;
getlineans(tot);
cout << ans;
return (0 - 0);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int NUM = 100010;
const int inf = 0x3f3f3f3f;
int dp[(1 << 16) + 10][300];
int n;
char c[20];
int C, r[20], b[20];
int sumr, sumb;
inline bool at(int i, int x) { return i & (1 << x); }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf(" %c %d %d", &c[i], &r[i], &b[i]);
if (c[i] == 'R') C |= (1 << i);
sumr += r[i];
sumb += b[i];
}
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
int End = (1 << n) - 1;
int mxR = n * (n - 1) / 2;
for (int s = 0; s < End; ++s) {
for (int R = 0; R <= mxR; ++R) {
if (dp[s][R] == inf) continue;
int nowR = __builtin_popcount(s & C);
int nowB = __builtin_popcount(s) - nowR;
for (int i = 0; i < n; ++i) {
if (!at(s, i)) {
int saveR = R + (r[i] - max(r[i] - nowR, 0));
int saveB = dp[s][R] + (b[i] - max(b[i] - nowB, 0));
int &ans = dp[s | (1 << i)][saveR];
if (ans == inf)
ans = saveB;
else
ans = max(ans, saveB);
}
}
}
}
int ans = inf;
for (int R = 0; R <= mxR; ++R) {
if (dp[End][R] == inf) continue;
ans = min(ans, max(sumr - R, sumb - dp[End][R]));
}
printf("%d\n", ans + n);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int x = 0, y = 0;
for (int i = 1; i <= a; ++i) {
for (int j = 1; j <= b; ++j) {
if ((i + j) % 2 == 0)
++x;
else
++y;
}
}
if (x >= n / 2 && y >= n / 2 + n % 2) {
x = n - (n % 2);
y = n + (n % 2 - 1);
for (int i = 1; i <= a; ++i) {
for (int j = 1; j <= b; ++j) {
if ((i + j) % 2 == 0) {
cout << max(0, x) << " ";
x -= 2;
} else {
cout << max(0, y) << " ";
y -= 2;
}
}
cout << endl;
}
} else if (y >= n / 2 && x >= n / 2 + n % 2) {
y = n - (n % 2);
x = n + (n % 2 - 1);
for (int i = 1; i <= a; ++i) {
for (int j = 1; j <= b; ++j) {
if ((i + j) % 2 == 0) {
cout << max(0, x) << " ";
x -= 2;
} else {
cout << max(0, y) << " ";
y -= 2;
}
}
cout << endl;
}
} else
cout << -1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int Mat[1003][1003];
int Num5[1003][1003];
int Num2[1003][1003];
char Path5[1003][1003];
char Path2[1003][1003];
void path(char Path[1003][1003], int X, int Y) {
if (X == 1 && Y == 1) return;
if (Path[X][Y] == 'D')
path(Path, X - 1, Y);
else
path(Path, X, Y - 1);
cout << Path[X][Y];
}
int main() {
int N;
while (cin >> N) {
memset(Mat, -1, sizeof(Mat));
memset(Num2, 0, sizeof(Num2));
memset(Num5, 0, sizeof(Num5));
int z_X, z_Y;
bool flag = false;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++) {
scanf("%d", &Mat[i][j]);
if (Mat[i][j] == 0) {
flag = true;
z_X = i;
z_Y = j;
}
int Temp = Mat[i][j];
while (Temp % 2 == 0 && Temp) {
Num2[i][j]++;
Temp /= 2;
}
Temp = Mat[i][j];
while (Temp % 5 == 0 && Temp) {
Num5[i][j]++;
Temp /= 5;
}
}
for (int i = 2; i <= N; i++) {
Path5[i][1] = 'D';
Path2[i][1] = 'D';
Num2[i][1] = Num2[i - 1][1] + Num2[i][1];
Num5[i][1] = Num5[i - 1][1] + Num5[i][1];
Path5[1][i] = 'R';
Path2[1][i] = 'R';
Num2[1][i] = Num2[1][i - 1] + Num2[1][i];
Num5[1][i] = Num5[1][i - 1] + Num5[1][i];
}
for (int i = 2; i <= N; i++)
for (int j = 2; j <= N; j++) {
if (Num2[i - 1][j] < Num2[i][j - 1]) {
Path2[i][j] = 'D';
Num2[i][j] += Num2[i - 1][j];
} else {
Path2[i][j] = 'R';
Num2[i][j] += Num2[i][j - 1];
}
if (Num5[i - 1][j] < Num5[i][j - 1]) {
Path5[i][j] = 'D';
Num5[i][j] += Num5[i - 1][j];
} else {
Path5[i][j] = 'R';
Num5[i][j] += Num5[i][j - 1];
}
}
if (Num2[N][N] > 1 && Num5[N][N] > 1 && flag) {
cout << 1 << endl;
path(Path2, z_X, z_Y);
for (int i = z_X; i < N; i++) cout << "R";
for (int i = z_Y; i < N; i++) cout << "D";
} else if (Num2[N][N] < Num5[N][N]) {
cout << Num2[N][N] << endl;
path(Path2, N, N);
} else {
cout << Num5[N][N] << endl;
path(Path5, N, N);
}
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int dp[1010][1010];
int C(int n, int k) {
if (k < 0 or k > n) return 0;
if (k == 0 or k == n) return 1;
if (dp[n][k]) return dp[n][k];
return dp[n][k] = (C(n - 1, k) + C(n - 1, k - 1)) % mod;
}
int ord(int v) {
int a = 0;
while (v != 1) {
a++;
v = __builtin_popcount(v);
}
return a;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string num;
int k;
cin >> num >> k;
if (k == 0) {
cout << 1 << '\n';
return 0;
}
int tam = num.size();
int totaluns = 0;
int ans = 0;
for (char c : num) totaluns += c == '1';
if (ord(totaluns) == k - 1) ans++;
if (k == 1) ans--;
for (int i = 1; i <= tam; i++) {
if (ord(i) == k - 1) {
int uns = 0;
for (int j = 0; j < tam; j++) {
if (num[j] == '1') {
ans = (ans + C(tam - j - 1, i - uns)) % mod;
uns++;
}
}
}
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
const int maxn = 3e6 + 10;
using namespace std;
bool vis[maxn];
int pri[maxn], top;
int n;
int a[maxn], b[maxn];
int cnt[maxn];
int usd[maxn];
int ans;
int pos[maxn];
void init() {
vis[1] = 1;
for (int i = 2; i < maxn; ++i) {
if (!vis[i]) {
pri[++top] = i;
}
for (int j = 1; j <= top && 1LL * i * pri[j] < maxn; ++j) {
vis[i * pri[j]] = 1;
if (i % pri[j] == 0) break;
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= 2 * n; ++i) scanf("%d", b + i);
sort(b + 1, b + 1 + 2 * n, greater<int>());
init();
for (int i = 1; i <= 2 * n; ++i) {
cnt[b[i]]++;
}
for (int i = 1; i <= top; ++i) pos[pri[i]] = i;
for (int i = 1; i <= 2 * n; ++i) {
if (usd[b[i]]) {
--usd[b[i]];
continue;
}
if (!vis[b[i]]) {
a[++ans] = pos[b[i]];
usd[pos[b[i]]]++;
} else {
int mx = 0;
for (int j = 2; 1LL * j * j <= b[i]; ++j) {
if (b[i] % j == 0) mx = max(mx, max(b[i] / j, j));
}
usd[mx]++;
a[++ans] = b[i];
}
}
for (int i = 1; i <= ans; ++i) printf("%d ", a[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int b[300005];
int main() {
long long t, n;
cin >> t;
while (t--) {
cin >> n;
long long a[n + 1], x, p = -1;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (i == 1)
x = a[i];
else if (a[i] != x)
p = i;
}
if (p == -1)
printf("NO\n");
else {
printf("YES\n");
int m = 0;
for (int i = 2; i <= n; i++) {
if (a[i] != x)
cout << 1 << " " << i;
else
cout << p << " " << i;
printf("\n");
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int x[N], a[N], cnta, n;
int main() {
scanf("%d", &n);
int x1, ans = 1;
for (int i = 1; i <= n; i++) {
scanf("%d", &x1);
if (x[x1] <= 1)
x[x1]++;
else
ans = 0;
}
if (!ans) {
printf("NO");
return 0;
}
for (int i = 0; i <= N; i++)
if (x[i]) {
a[++cnta] = i;
x[i]--;
}
printf("YES\n%d\n", cnta);
for (int i = 1; i <= cnta; i++) printf("%d ", a[i]);
printf("\n%d\n", n - cnta);
for (int i = N; i >= 0; i--)
if (x[i]) printf("%d ", i);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000;
int k;
struct matrix {
vector<vector<long long> > t;
matrix() {
t.resize(k + 1);
for (int i = 0; i <= k; i++) t[i].resize(k + 1);
}
};
matrix operator*(matrix A, matrix B) {
matrix res;
for (int i = 0; i <= k; i++)
for (int j = 0; j <= k; j++) {
res.t[i][j] = inf;
for (int l = 0; l <= k; l++)
res.t[i][j] = min(res.t[i][j], A.t[i][l] + B.t[l][j]);
}
return res;
}
int n, m;
vector<int> a;
vector<int> b;
vector<long long> f(int s) {
vector<long long> v;
v.resize(k + 1, inf);
v[s] = 0;
for (int i = 0; i < n; i++) {
vector<long long> tmp = v;
for (int j = 0; j <= k; j++) v[j] = inf;
for (int j = 0; j <= k; j++) {
if (j + 1 <= k) v[j + 1] = min(v[j + 1], tmp[j] + a[i]);
if (j - 1 >= 0) v[j - 1] = min(v[j - 1], tmp[j] + b[i]);
}
}
return v;
}
int main() {
cin >> n >> m;
a.resize(n);
b.resize(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
k = 2 * n;
matrix T;
for (int i = 0; i <= k; i++) {
T.t[i] = f(i);
}
matrix res;
res = T;
m--;
while (m > 0) {
if (m % 2) res = res * T;
m /= 2;
T = T * T;
}
cout << res.t[0][0];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long optFrom[57];
int main() {
int N;
scanf("%d ", &N);
;
long long K;
cin >> K;
optFrom[N - 1] = 1LL;
optFrom[N - 2] = 2LL;
for (int i = (N - 3); i >= (0); i--) {
optFrom[i] = optFrom[i + 1] + optFrom[i + 2];
}
optFrom[N] = 1LL;
for (int i = (0); i < (N); i++) {
if (K > optFrom[i + 1]) {
printf("%d %d ", i + 1 + 1, i + 1);
K -= optFrom[i + 1];
i++;
} else {
printf("%d ", i + 1);
}
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m, k, c[N], can[N], del[N], done[N];
long long h, dis[N], a[N], s[N];
set<pair<long long, int> > S;
set<pair<int, int> > H;
void recalc() {
for (int i = 0; i < k; ++i) {
done[i] = 0;
dis[i] = 1LL << 60;
}
S.insert(make_pair(dis[0] = 0, 0));
while (!S.empty()) {
int u = S.begin()->second;
S.erase(S.begin());
if (done[u]) continue;
done[u] = 1;
for (int i = 1; i <= s[0]; ++i) {
int v = (s[i] + u) % k;
if (dis[u] + s[i] < dis[v]) {
dis[v] = dis[u] + s[i];
if (dis[v] <= h) S.insert(make_pair(dis[v], v));
}
}
}
H.clear();
for (int i = 1; i <= n; ++i)
if (!del[i] && dis[a[i] % k] <= a[i]) {
can[i] = 1;
H.insert(make_pair(c[i], -i));
} else
can[i] = 0;
}
int main() {
scanf("%I64d %d %d %d", &h, &n, &m, &k);
for (int i = 1; i <= n; ++i) {
scanf("%I64d %d", &a[i], &c[i]), --a[i];
if (a[i] % k == 0) {
can[i] = 1;
H.insert(make_pair(c[i], -i));
}
}
for (int i = 1; i <= m; ++i) {
int type;
scanf("%d", &type);
if (type == 1) {
scanf("%I64d", &s[++s[0]]);
recalc();
}
if (type == 2) {
int x, y;
scanf("%d %d", &x, &y);
if (can[x]) {
H.erase(make_pair(c[x], -x));
c[x] -= y;
H.insert(make_pair(c[x], -x));
} else
c[x] -= y;
}
if (type == 3) {
if (H.empty()) {
puts("0");
continue;
}
printf("%d\n", H.rbegin()->first);
del[-H.rbegin()->second] = 1;
H.erase(--H.end());
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int count = 0;
string brack;
cin >> brack;
stack<char> extra;
int x = brack.length();
for (int i = 0; i < x; i++) {
if (brack[i] == '(')
extra.push(brack[i]);
else if (extra.size() > 0)
extra.pop();
else
count++;
}
cout << x - extra.size() - count << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int N = 1e3 + 5, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double PI = acos(-1), EPS = 1e-7;
using namespace std;
namespace fast_IO {
long long read() {
long long x = 0;
char c;
bool flag = false;
while ((c = getchar()) == ' ' || c == '\n' || c == '\r')
;
if (c == '-')
flag = true;
else
x = c ^ 48;
while ((c = getchar()) != ' ' && c != '\n' && c != '\r' && ~c)
x = (x << 1) + (x << 3) + (c ^ 48);
if (flag) return -x;
return x;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 ^ 48);
}
} // namespace fast_IO
long long sum[N][N], a[N][N], cnt[N][N], maxsum[N][N], maxn[2][N][N], n, m,
fir[N];
long long ans, all, same[N][N], tot[2][N][N];
bool tag[N][N];
bool judge(int i, int j, int k, int p) { return tag[abs(i - k)][abs(j - p)]; }
int main() {
n = fast_IO::read(), m = fast_IO::read();
int r = fast_IO::read();
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
a[i][j] = fast_IO::read();
sum[i][j] = sum[i][j - 1] + a[i][j];
}
}
for (int i = r + 1; i <= n - r; ++i) {
for (int j = r + 1; j <= m - r; ++j) {
for (int k = i - r; k <= i + r; ++k) {
int del = sqrt(r * r - (i - k) * (i - k));
cnt[i][j] += sum[k][j + del] - sum[k][j - del - 1];
}
}
}
for (int i = r + 1; i <= n - r; ++i) {
for (int j = r + 1; j <= m - r; ++j) {
if (cnt[i][j] == maxn[0][i][j - 1]) {
tot[0][i][j] = tot[0][i][j - 1] + 1;
maxn[0][i][j] = cnt[i][j];
} else if (cnt[i][j] > maxn[0][i][j - 1]) {
maxn[0][i][j] = cnt[i][j];
tot[0][i][j] = 1;
} else
maxn[0][i][j] = maxn[0][i][j - 1], tot[0][i][j] = tot[0][i][j - 1];
}
for (int j = m - r; j >= r + 1; --j) {
if (cnt[i][j] == maxn[1][i][j + 1]) {
tot[1][i][j] = tot[1][i][j + 1] + 1;
maxn[1][i][j] = cnt[i][j];
} else if (cnt[i][j] > maxn[1][i][j + 1]) {
maxn[1][i][j] = cnt[i][j];
tot[1][i][j] = 1;
} else
maxn[1][i][j] = maxn[1][i][j + 1], tot[1][i][j] = tot[1][i][j + 1];
}
}
for (int dx = 0; dx <= n - r * 2 - 1; ++dx) {
for (int dy = m - r * 2 - 1; ~dy; --dy) {
tag[dx][dy] = true;
for (int i = 0; i <= dx; ++i) {
int x = (r >= i) ? sqrt(r * r - i * i) + 1 : 0;
int y = (r >= (dx - i)) ? sqrt(r * r - (dx - i) * (dx - i)) + 1 : 0;
if (x && y && x + y > dy + 1) {
tag[dx][dy] = false;
break;
}
}
if (tag[dx][dy]) {
fir[dx] = dy;
}
}
}
for (int i = r + 1; i <= n - r; ++i) {
for (int j = r + 1; j <= m - r; ++j) {
for (int k = i; k <= n - r; ++k) {
int L = r + 1, R = j;
if (k != i && L <= R) {
R = j - fir[abs(i - k)];
while (R > r && (!judge(i, j, k, R))) --R;
if (R > r) {
if (maxn[0][k][R] + cnt[i][j] == maxsum[i][j])
same[i][j] += tot[0][k][R];
else if (maxn[0][k][R] + cnt[i][j] > maxsum[i][j]) {
maxsum[i][j] = maxn[0][k][R] + cnt[i][j];
same[i][j] = tot[0][k][R];
}
}
}
L = j + 1, R = m - r;
if (L <= R) {
L = j + fir[abs(i - k)];
if (L == j) L = j + 1;
while (L <= m - r && !judge(i, j, k, L)) ++L;
if (L <= m - r) {
if (maxn[1][k][L] + cnt[i][j] == maxsum[i][j])
same[i][j] += tot[1][k][L];
else if (maxn[1][k][L] + cnt[i][j] > maxsum[i][j]) {
maxsum[i][j] = maxn[1][k][L] + cnt[i][j];
same[i][j] = tot[1][k][L];
}
}
}
}
}
}
for (int i = r + 1; i <= n - r; ++i) {
for (int j = r + 1; j <= m - r; ++j) {
if (!maxsum[i][j]) continue;
if (maxsum[i][j] == ans)
all += same[i][j];
else if (maxsum[i][j] > ans) {
ans = maxsum[i][j];
all = same[i][j];
}
}
}
printf("%lld %lld", ans, all);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int GCD(int x, int y) {
int mx, mn, w;
mx = max(x, y);
mn = min(x, y);
w = mx % mn;
if (w == 0) return mn;
GCD(mn, w);
}
int n, A[110], gcd, res, MAX;
int main() {
cin >> n;
MAX = 0;
for (int I = 0; I < n; ++I) {
cin >> A[I];
MAX = max(MAX, A[I]);
}
gcd = GCD(A[0], A[1]);
for (int I = 2; I < n; ++I) {
gcd = GCD(A[I], gcd);
if (gcd == 1) break;
}
res = (MAX / gcd - n) % 2;
if (res)
cout << "Alice" << endl;
else
cout << "Bob" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dp[30][30];
int main() {
int n;
cin >> n;
memset(dp, 0, sizeof dp);
vector<string> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
int a = v[i][0] - 'a';
int b = v[i][v[i].size() - 1] - 'a';
int len = v[i].size();
for (int j = 0; j <= 25; j++) {
if (dp[j][a] != 0) {
dp[j][b] = max(dp[j][b], (int)(dp[j][a] + v[i].size()));
}
}
dp[a][b] = max(dp[a][b], len);
}
int ans = 0;
for (int i = 0; i <= 25; i++) ans = max(ans, dp[i][i]);
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool desc_sort(const int& lhs, const int& rhs) { return lhs > rhs; }
bool desc_pii_sort(const pair<int, int>& lhs, const pair<int, int>& rhs) {
return lhs > rhs;
}
bool second_sort(const pair<int, int>& lhs, const pair<int, int>& rhs) {
pair<int, int> a, b;
a.first = lhs.second;
a.second = lhs.first;
b.first = rhs.second;
b.second = rhs.first;
return a < b;
}
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, set<T> second) {
os << "{ ";
for (auto s : second) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class L, class R>
ostream& operator<<(ostream& os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
inline long long fast_expo(long long base, long long power,
long long modulo = 1e0) {
base %= modulo;
if (base < 0LL) base += modulo;
long long x = base, cnt = power, ans = 1LL;
while (cnt) {
if (cnt & 1LL) ans = (ans * x) % modulo;
x = (x * x) % modulo;
cnt >>= 1LL;
}
return ans;
}
inline long long inv(long long base, long long modulo = 1e0) {
return fast_expo(base, modulo - 2LL, modulo);
}
struct line {
long long m, c;
line(long long m1, long long c1) {
m = m1;
c = c1;
}
long long eval(long long x) { return m * x + c; }
long double intersectX(line l) { return (long double)(c - l.c) / (l.m - m); }
};
deque<line> dq;
void insert(line l) {
bool done = 0;
while (!dq.empty()) {
line r = dq.back();
if (r.m == l.m) {
if (r.c < l.c) {
dq.pop_back();
}
} else {
dq.pop_back();
if (dq.empty()) {
dq.push_back(r);
dq.push_back(l);
done = 1;
break;
} else {
if (l.intersectX(r) >= r.intersectX(dq.back())) {
continue;
} else {
dq.push_back(r);
dq.push_back(l);
done = 1;
break;
}
}
}
}
if (!done) {
dq.push_back(l);
done = 1;
}
}
long long query(long long x) {
while (dq.size() > 1) {
line r = dq.front();
dq.pop_front();
if (dq.front().eval(x) < r.eval(x)) {
dq.push_front(r);
return r.eval(x);
}
}
return dq.front().eval(x);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
pair<pair<long long, long long>, long long> v[n + 1];
for (int i = 1; i <= n; i++)
cin >> v[i].first.first >> v[i].first.second >> v[i].second;
sort(v + 1, v + n + 1);
long long dp[n + 1];
long long ans = 0;
dp[1] = v[1].first.first * v[1].first.second - v[1].second;
ans = max(ans, dp[1]);
insert(line(-v[1].first.first, dp[1]));
for (int i = 2; i <= n; i++) {
dp[i] = query(v[i].first.second);
dp[i] = max(0ll, dp[i]);
dp[i] += v[i].first.second * v[i].first.first - v[i].second;
insert(line(-v[i].first.first, dp[i]));
ans = max(ans, dp[i]);
}
cout << (ans) << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int b;
double t;
node(){};
node(int B, double T) {
b = B;
t = T;
}
};
struct edge {
double x, y, z;
edge(){};
edge(double X, double Y, double Z) {
x = X;
y = Y;
z = Z;
}
};
int n;
double f[100005][5], siz[100005];
vector<node> G[100005];
bool cmp(edge a, edge b) { return a.y * b.x < b.y * a.x; }
void dfs(int x, int fa) {
vector<edge> fuck;
siz[x] = 1;
for (int i = 0; i < G[x].size(); i++) {
int tmp = G[x][i].b, tot = G[x][i].t;
if (fa != tmp) {
dfs(tmp, x);
f[x][1] += f[tmp][1], siz[x] += siz[tmp];
fuck.push_back(edge(siz[tmp], f[tmp][2] + tot * 2, tot));
}
}
sort(fuck.begin(), fuck.end(), cmp);
for (int i = 0; i < fuck.size(); i++) {
f[x][1] += (f[x][2] + fuck[i].z) * fuck[i].x;
f[x][2] += fuck[i].y;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b;
double t;
scanf("%d %d %lf", &a, &b, &t);
G[a].push_back(node(b, t));
G[b].push_back(node(a, t));
}
dfs(1, 0);
printf("%.6lf\n", f[1][1] / (siz[1] - 1));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int C[N], H[N], n;
int main() {
cin >> n;
if (n <= 2) return cout << n << endl, 0;
int ans = 2;
for (int i = 0; i < n; ++i) cin >> C[i] >> H[i];
double lst = C[0];
for (int i = 1; i < n - 1; ++i) {
if (C[i] - H[i] > lst)
ans++, lst = C[i];
else if (C[i] + H[i] < C[i + 1])
ans++, lst = C[i] + H[i];
else
lst = C[i];
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int in[1000000];
in[0] = 0;
in[1] = 1;
if (n == 0) {
cout << 0 << " " << 0 << " " << 0;
return 0;
} else if (n == 1) {
cout << 1 << " " << 0 << " " << 0;
return 0;
} else if (n == 2) {
cout << 1 << " " << 1 << " " << 0;
return 0;
} else {
long long int i;
long long int x = 0;
for (i = 2; x != n; i++) {
in[i] = in[i - 1] + in[i - 2];
x = in[i];
}
i = i - 1;
cout << in[i - 3] << " " << in[i - 2] << " " << in[i - 2];
}
}
| 0 |
#include <bits/stdc++.h>
int main(void) {
int n, x, y;
scanf("%d %d %d", &n, &x, &y);
if ((x == n / 2 || x == n / 2 + 1) && (y == n / 2 || y == n / 2 + 1))
puts("NO");
else
puts("YES");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 11;
int n;
long long k, x;
int first(int n) {
int sum = 0;
while (n) {
sum += n % 10;
n /= 10;
}
if (sum < 10)
return sum;
else
return first(sum);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
while (n--) {
cin >> k >> x;
cout << (k - 1) * 9 + x << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k;
scanf("%d", &n);
int a[n + 2];
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
if (a[n - 1] == 1 && n > 2) a[n - 2] = 2;
if (n == 1 && a[0] == 1) {
a[0] = 2;
printf("2 ");
} else if (n == 1 && a[0] > 1)
printf("1 ");
else if (n == 2 && a[n - 2] == 1 && a[1] == 1) {
a[n - 2] = 2;
printf("1 ");
} else
printf("1 ");
for (i = 0; i < n - 1; i++) printf("%d ", a[i]);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
stack<char> st;
for (int i = 0; i < 26; i++) {
st.push(i + 'a');
}
string s;
cin >> s;
for (int i = s.size() - 1; i >= 0; i--) {
if (st.size() == 0) break;
if (s[i] <= st.top()) {
s[i] = st.top();
st.pop();
}
}
if (st.size() == 0) {
cout << s;
} else {
cout << -1;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 10;
int sum[N], s[N];
int main() {
int T, n;
scanf("%d", &T);
while (T--) {
scanf("%d\n", &n);
for (int i = 1; i <= n; i++) {
s[i] = getchar() - '0';
if (s[i] & 1)
sum[i] = sum[i - 1] + 1;
else
sum[i] = sum[i - 1];
}
if (sum[n] < 2) {
puts("-1");
continue;
}
for (int i = 1; i <= n; i++) {
putchar(s[i] + '0');
if (sum[i] == 2) break;
}
puts("");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
int64 dp[51][51][51][51];
int main() {
int64 N, A[51], B[51];
cin >> N;
vector<pair<int, int> > vs(N);
for (int i = 0; i < N; i++) cin >> vs[i].first;
for (int i = 0; i < N; i++) cin >> vs[i].second;
sort(begin(vs), end(vs));
reverse(begin(vs), end(vs));
for (int i = 0; i < N; i++) tie(A[i], B[i]) = vs[i];
A[N] = -1;
int64 low = 0, high = 1000000000000LL;
auto check = [&](int64 v) {
vector<int64> C(N);
for (int i = 0; i < N; i++) {
C[i] = A[i] * 1000LL - B[i] * v;
}
memset(dp, -1, sizeof(dp));
function<int64(int, int, int, int)> rec = [&](int idx, int first,
int firstsame, int last) {
if (idx == N) return 0LL;
if (~dp[idx][first][firstsame][last])
return dp[idx][first][firstsame][last];
int64 ret = 1LL << 60;
if (first > last) {
if (A[idx] != A[idx + 1])
ret = min(ret, rec(idx + 1, first + firstsame, 0, last + 1));
else
ret = min(ret, rec(idx + 1, first, firstsame, last + 1));
}
if (A[idx] != A[idx + 1])
ret = min(ret, rec(idx + 1, first + firstsame + 1, 0, last) + C[idx]);
else
ret = min(ret, rec(idx + 1, first, firstsame + 1, last) + C[idx]);
return dp[idx][first][firstsame][last] = ret;
};
return rec(0, 0, 0, 0) <= 0;
};
while (high - low > 1) {
int64 mid = (low + high) / 2;
if (check(mid))
high = mid;
else
low = mid;
}
cout << high << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long calc(long long a, long long c, long long h1, long long h2,
long long w1, long long w2) {
if (c - a * w1 < 0) return -1;
long long t = (c - a * w1) / w2;
return (a * h1 + t * h2);
}
int main() {
int c, w1, w2, h1, h2;
cin >> c >> h1 >> h2 >> w1 >> w2;
long long m = 0;
for (int i = 0; i <= 10000000; i++) {
m = max(m, calc(i, c, h2, h1, w2, w1));
}
for (int i = 0; i <= 10000000; i++) {
m = max(m, calc(i, c, h1, h2, w1, w2));
}
cout << m;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, i, j, k;
cin >> n;
string s;
cin >> s;
string ans = s;
for (i = 0; i < 10; i++) {
for (j = 0; j < n; j++) {
long long x = (s[j] - '0' + i) % 10;
if (x == 0) {
string temp = "";
for (k = j; k < n; k++) {
temp += (s[k] - '0' + i) % 10 + '0';
}
for (k = 0; k < j; k++) {
temp += (s[k] - '0' + i) % 10 + '0';
}
if (temp < ans) {
ans = temp;
}
}
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
a |= (long long)x;
}
long long b = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
b |= (long long)x;
}
cout << a + b;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX / 4, SINF = 0x3f;
const int dx[] = {0, 0, -1, 1}, dy[] = {-1, 1, 0, 0};
const int maxn = 1e6 + 10;
int mo_num = 1e9 + 7;
int n, m, t, a[maxn], case_of_T;
long long ans;
struct DSU {
stack<pair<int, int> > stk;
int p[maxn], siz[maxn];
void init(int x) {
for (int i = 1; i <= x + 1; i++) {
p[i] = i;
siz[i] = 1;
}
}
int Find(int x) { return x == p[x] ? x : Find(p[x]); }
bool merge(int x, int y) {
int rx = Find(x), ry = Find(y);
if (rx == ry) return false;
if (siz[rx] > siz[ry]) swap(rx, ry);
p[rx] = ry;
siz[ry] += siz[rx];
stk.push({rx, ry});
return true;
}
void undo() {
pair<int, int> now = stk.top();
p[now.first] = now.first;
siz[now.second] -= siz[now.first];
stk.pop();
}
} dsu;
map<pair<int, int>, int> vis;
vector<pair<int, int> > Que[maxn], one[maxn];
pair<int, int> to[maxn];
int cnt, To[maxn], cant[maxn];
unordered_map<int, int> E;
vector<int> have;
void solve() {
int k;
cin >> n >> m >> k;
dsu.init(n);
for (int i = 1; i <= n; i++) cin >> a[i];
int Cnt = 0;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
if (!vis[{a[x], a[y]}]) {
if (a[x] != a[y])
vis[{a[x], a[y]}] = vis[{a[y], a[x]}] = ++cnt, to[cnt] = {a[x], a[y]};
else
vis[{a[x], a[y]}] = ++Cnt, To[Cnt] = a[x];
}
if (a[x] != a[y])
Que[vis[{a[x], a[y]}]].push_back({x, y});
else
one[vis[{a[x], a[y]}]].push_back({x, y});
}
for (int i = 1; i <= Cnt; i++) {
for (auto j : one[i]) {
int Fz = dsu.Find(j.first), Fy = dsu.Find(j.second);
if (Fz == Fy) {
k--;
cant[To[i]] = 1;
break;
}
if (!E[Fz])
E[Fz] = Fy;
else
dsu.merge(dsu.p[Fy], dsu.Find(E[Fz]));
if (!E[Fy])
E[Fy] = Fz;
else
dsu.merge(dsu.p[Fz], dsu.Find(E[Fy]));
}
}
ans = 1LL * k * (k - 1) / 2;
for (int i = 1; i <= cnt; i++) {
if (cant[to[i].first] or cant[to[i].second]) continue;
int num = 0;
for (auto j : Que[i]) {
int Fz = dsu.Find(j.first), Fy = dsu.Find(j.second);
if (Fz == Fy) {
ans--;
break;
}
if (!E[Fz])
E[Fz] = Fy, have.push_back(Fz);
else
num += dsu.merge(Fy, E[Fz]);
if (!E[Fy])
E[Fy] = Fz, have.push_back(Fy);
else
num += dsu.merge(Fz, E[Fy]);
}
for (int j = 1; j <= num; j++) dsu.undo();
while (!have.empty()) {
E[have.back()] = 0;
have.pop_back();
}
}
cout << (ans) << '\n';
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
class Graph {
struct Edge {
int From, To, Capacity, Flow, Cost, ConstCost;
};
struct OrderedRib {
int Source;
Edge* Rib;
bool Exist() const {
return Source == Rib->From ? Rib->Capacity > Rib->Flow : Rib->Flow > 0;
}
int Destination() const {
return Source == Rib->From ? Rib->To : Rib->From;
}
int Cost() const { return (Source == Rib->From ? 1 : -1) * Rib->Cost; }
int Capacity() const {
return Source == Rib->From ? Rib->Capacity - Rib->Flow : Rib->Flow;
}
void IncreaseFlow(int v) {
Rib->Flow += (Source == Rib->From ? 1 : -1) * v;
}
};
list<Edge> edges;
vector<vector<OrderedRib> > adjacency_list;
vector<int> BellmanFord() const {
vector<int> distances(adjacency_list.size(), INF);
distances[s] = 0;
for (int i = 0; i < adjacency_list.size(); ++i) {
for (const auto& e : edges) {
if (distances[e.From] != INF)
distances[e.To] = min(distances[e.To], distances[e.From] + e.Cost);
}
}
return distances;
}
vector<int> ShortestPaths(vector<OrderedRib>& parents) {
parents.resize(adjacency_list.size());
vector<int> res(adjacency_list.size(), INF);
using Key = pair<int, int>;
set<Key> queue;
queue.insert(Key(0, s));
res[s] = 0;
while (!queue.empty()) {
auto next = *queue.begin();
queue.erase(queue.begin());
for (const auto& e : adjacency_list[next.second]) {
int other = e.Destination();
if (e.Exist() && (res[other] > next.first + e.Cost())) {
res[other] = next.first + e.Cost();
queue.insert(Key(res[other], other));
parents[other] = e;
}
}
}
return res;
}
vector<int> ShortestPathsAlt(vector<OrderedRib>& parents) {
size_t n = adjacency_list.size();
parents.resize(n);
vector<int> d(n, INF);
d[s] = 0;
vector<int> id(n);
deque<int> q;
q.push_back(s);
while (!q.empty()) {
int v = q.front();
q.pop_front();
id[v] = 1;
for (const auto& e : adjacency_list[v]) {
if (!e.Exist()) continue;
int to = e.Destination(), len = e.Cost();
if (d[to] > d[v] + len) {
d[to] = d[v] + len;
if (id[to] == 0)
q.push_back(to);
else if (id[to] == 1)
q.push_front(to);
parents[to] = e;
id[to] = 1;
}
}
}
return d;
}
public:
static const int INF;
void ReduceCosts(const vector<int>& potentials) {
for (auto& e : edges) {
e.Cost += potentials[e.From] - potentials[e.To];
}
}
private:
void IncreaseFlow(vector<OrderedRib>& parents) {
int current = t;
int min_capacity = INF;
while (current != s) {
min_capacity = min(min_capacity, parents[current].Capacity());
current = parents[current].Source;
}
min_capacity = min(residual_flow, min_capacity);
residual_flow -= min_capacity;
current = t;
while (current != s) {
parents[current].IncreaseFlow(min_capacity);
cost += parents[current].Cost() * min_capacity;
current = parents[current].Source;
}
}
public:
int cost = 0;
int residual_flow;
int s, t;
Graph(size_t vertices) : adjacency_list(vertices) {}
void AddRib(int from, int to, int cost, int capacity) {
edges.push_back(Edge({from, to, capacity, 0, cost, cost}));
adjacency_list[from].push_back(OrderedRib({from, &edges.back()}));
adjacency_list[to].push_back(OrderedRib({to, &edges.back()}));
}
int MinCostFlow() {
while (residual_flow) {
vector<OrderedRib> parents;
auto potentials = ShortestPathsAlt(parents);
IncreaseFlow(parents);
}
return cost;
}
};
const int Graph::INF = 1000000000;
int main() {
vector<int> lst(100011, -1), lst2(7, -1);
int n;
cin >> n;
Graph g(3 * n + 2);
g.residual_flow = 4;
g.s = 0;
g.t = 1;
vector<int> notes(n);
using Value = pair<int, int>;
vector<int> distances(3 * n + 2, 1000000000);
distances[0] = 0;
for (int i = 0; i < n; ++i) {
cin >> notes[i];
}
for (int i = n - 1; i >= 0; --i) {
g.AddRib(0, i + 2 * n + 2, 0, 1);
g.AddRib(i + 2 * n + 2, i + 2, 0, 1);
g.AddRib(i + 2, i + n + 2, -1, 1);
g.AddRib(i + n + 2, 1, 0, 1);
if (lst[notes[i] - 1] >= 0) {
g.AddRib(i + n + 2, lst[notes[i] - 1] + 2, 0, 1);
}
if (lst[notes[i] + 1] >= 0) {
g.AddRib(i + n + 2, lst[notes[i] + 1] + 2, 0, 1);
}
if (lst2[notes[i] % 7] >= 0) {
g.AddRib(i + n + 2, lst2[notes[i] % 7] + 2 * n + 2, 0, 1);
}
if (lst[notes[i]] >= 0) {
g.AddRib(i + 2, lst[notes[i]] + 2, 0, Graph::INF);
}
if (lst2[notes[i] % 7] >= 0) {
g.AddRib(i + 2 * n + 2, lst2[notes[i] % 7] + 2 * n + 2, 0, Graph::INF);
}
lst2[notes[i] % 7] = lst[notes[i]] = i;
}
cout << -g.MinCostFlow();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200015;
const int MOD = 1000000007;
int a[MAXN];
bool F(int len, int num) {
bool flag;
int pres;
for (int i = 0; i <= num - 1; i++) {
flag = true;
pres = i;
for (int j = 0; j <= len - 1; j++) {
if (a[pres] == 0) flag = false;
pres += num;
}
if (flag == true) return flag;
}
return false;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i <= n - 1; i++) scanf("%d", &a[i]);
bool ok = false;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (i >= 3) ok = ok | F(i, n / i);
if (i != sqrt(n) && n / i >= 3) ok = ok | F(n / i, i);
}
}
if (ok)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const int N = 200005;
int n, i, tab[N], j, maxx, akt, ind, ok[N], x, l;
vector<int> wek[N];
long long res;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &tab[i]);
}
for (i = 1; i < n; i++)
if (n % i == 0) {
for (j = 0; j < n; j++) ok[j] = 0;
for (j = 0; j < i; j++) {
maxx = 0;
for (l = j; l < n; l += i)
if (tab[l] > maxx) maxx = tab[l];
for (l = j; l < n; l += i)
if (tab[l] == maxx) ok[l] = 1;
}
wek[i].resize(0);
ind = -1;
for (j = 0; j < n; j++)
if (!ok[j]) {
ind = j;
j = n;
}
if (ind == -1) {
wek[i].push_back(n);
} else {
akt = 0;
for (j = ind; j < n; j++) {
if (ok[j]) {
akt++;
} else if (!ok[j]) {
if (akt > 0) wek[i].push_back(akt);
akt = 0;
}
}
for (j = 0; j <= ind; j++) {
if (ok[j]) {
akt++;
} else if (!ok[j]) {
if (akt > 0) wek[i].push_back(akt);
akt = 0;
}
}
}
sort(wek[i].begin(), wek[i].end());
}
res = 0;
for (i = 1; i < n; i++) {
x = gcd(n, i);
if (wek[x].size() == 1 && wek[x][0] == n) {
res += n;
} else
for (j = wek[x].size() - 1; j >= 0 && wek[x][j] >= i; j--) {
res += wek[x][j] - i + 1;
}
}
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[] = {4, 22, 27, 58, 85, 94, 121, 166, 202, 265, 274, 319, 346,
355, 378, 382, 391, 438, 454, 483, 517, 526, 535, 562, 576, 588,
627, 634, 636, 645, 648, 654, 663, 666, 690, 706, 728, 729, 762,
778, 825, 852, 861, 895, 913, 915, 922, 958, 985, 1086};
int n;
cin >> n;
cout << a[n - 1] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int inf = 1e9 + 7;
int n, a[N], m, k, x, t, b[N];
set<int> s;
set<int>::iterator it, it2;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s.insert(i);
}
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> t >> k;
if (t == 2) {
cout << b[k] << endl;
} else {
cin >> x;
it = s.lower_bound(k);
while (it != s.end()) {
if (x == 0) break;
if (a[*it] - b[*it] > x) {
b[*it] += x;
x = 0;
break;
} else {
x -= (a[*it] - b[*it]);
b[*it] = a[*it];
it2 = it;
*it++;
s.erase(*it2);
}
}
}
}
}
| 5 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int num[100090 << 2];
int num2[100090 << 2];
int m, n, tot;
void Update(int L, int R, int c, int l, int r, int rt) {
if (L <= l && R >= r) {
num[rt] = (num[rt] | c);
return;
}
int m = (l + r) >> 1;
if (L <= m) Update(L, R, c, l, m, rt << 1);
if (R > m) Update(L, R, c, m + 1, r, rt << 1 | 1);
}
int Query2(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) {
return num2[rt];
}
int m = (l + r) >> 1;
int ret = 0x7fffffff;
if (L <= m) ret = (ret & Query2(L, R, l, m, rt << 1));
if (R > m) ret = (ret & Query2(L, R, m + 1, r, rt << 1 | 1));
return ret;
}
void BuildTree(int l, int r, int rt) {
num[rt] = 0;
if (l == r) return;
int m = (l + r) >> 1;
BuildTree(l, m, rt << 1);
BuildTree(m + 1, r, rt << 1 | 1);
}
int Check(int n) {
if (n == 1)
return num[n];
else {
return (num[n] | Check(n / 2));
}
}
int BuildTree2(int l, int r, int rt) {
if (l == r) return num2[rt];
int m = (l + r) >> 1;
int m1 = BuildTree2(l, m, rt << 1);
int m2 = BuildTree2(m + 1, r, rt << 1 | 1);
num2[rt] = (m1 & m2);
return num2[rt];
}
struct query {
int l, r, q;
} Q[100090];
int main() {
int l, r, q;
while (~scanf("%d%d", &n, &m)) {
int s = n;
int t = 1;
while (t < n) t <<= 1;
n = t;
BuildTree(1, n, 1);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &Q[i].l, &Q[i].r, &Q[i].q);
Update(Q[i].l, Q[i].r, Q[i].q, 1, n, 1);
}
for (int i = n; i < n + s; i++) {
num2[i] = Check(i);
}
for (int i = n + s; i < 2 * n; i++) {
num2[i] = 0x7fffffff;
}
BuildTree2(1, n, 1);
bool flag = false;
for (int i = 0; i < m; i++) {
if (Query2(Q[i].l, Q[i].r, 1, n, 1) != Q[i].q) {
flag = true;
break;
}
}
if (!flag) {
printf("YES\n");
for (int i = n; i < n + s; i++) {
printf("%d", num2[i]);
if (i == n + s - 1)
printf("\n");
else
printf(" ");
}
} else
printf("NO\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
const double EPS = 1e-6;
const int INF = 0x3fffffff;
const long long LINF = INF * 1ll * INF;
const double PI = acos(-1.0);
using namespace std;
int sign(double x) { return x < -EPS ? -1 : x > EPS; }
struct Point {
double x, y;
Point(double x, double y) : x(x), y(y) {}
Point() {}
bool operator==(const Point& p) const {
return sign(x - p.x) == 0 && sign(y - p.y) == 0;
}
Point operator-(const Point& p) const { return Point(x - p.x, y - p.y); }
Point operator*(const double t) const { return Point(t * x, t * y); }
Point operator+(const Point& p) const { return Point(x + p.x, y + p.y); }
bool operator<(const Point& p) const {
return sign(x - p.x) == 0 ? sign(y - p.y) < 0 : sign(x - p.x) < 0;
}
};
struct Line {
Point a, b;
Line() {}
Line(Point a, Point b) : a(a), b(b) {}
};
inline double Length(Point a, Point b) {
double x = a.x - b.x, y = a.y - b.y;
return sqrt(x * x + y * y);
}
inline double Cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
inline double Dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
Point Rotate(Point A, double rad) {
return Point(A.x * cos(rad) - A.y * sin(rad),
A.x * sin(rad) + A.y * cos(rad));
}
inline Point LineInterSection(Line l1, Line l2) {
Point u = l1.a - l2.a;
Point v1 = l1.b - l1.a, v2 = l2.b - l2.a;
if (sign(Cross(v1, v2)) == 0) {
if (sign(Cross(u, v1)))
return Point(-INF, -INF);
else
return Point(-INF, -INF);
}
double t = Cross(v2, u) / Cross(v1, v2);
return l1.a + v1 * t;
}
struct Light {
double x, y, ang;
} light[22];
double dp[1 << 20];
int main(void) {
int n;
double l, r;
cin >> n >> l >> r;
for (int i = 0; i < n; i++) {
cin >> light[i].x >> light[i].y >> light[i].ang;
light[i].ang *= PI;
light[i].ang /= 180;
}
for (int i = 0; i < (1 << n); i++) dp[i] = -INF;
dp[0] = l;
for (int i = 0; i < (1 << n); i++) {
if (sign(dp[i] + INF) == 0) continue;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) continue;
dp[i | (1 << j)] = max(dp[i | (1 << j)], dp[i]);
Point p(light[j].x, light[j].y);
Point v1 = Point(dp[i], 0) - p;
v1 = Rotate(v1, light[j].ang);
double ret;
if (sign(Cross(Point(1, 0), v1)) >= 0) {
ret = r;
} else {
Point inter =
LineInterSection(Line(v1 + p, p), Line(Point(1, 0), Point(-1, 0)));
ret = min(r, inter.x);
}
dp[i | (1 << j)] = max(dp[i | (1 << j)], ret);
}
}
if (sign(dp[(1 << n) - 1] + INF) == 0) dp[(1 << n) - 1] = l;
printf("%.10lf\n", dp[(1 << n) - 1] - dp[0]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long x = 0, y = 1000000007;
while (n--) {
long long l, r;
cin >> l >> r;
x = max(l, x);
y = min(r, y);
}
long long res = max(x - y, 0ll);
cout << res << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long b[2 * n];
for (int i = 0, k = 0; i < 2 * n; i++, k += 2) {
b[i] = a[k % n];
}
long long sum = 0, maxsum, x = (n + 1) / 2;
for (int i = 0; i < x; i++) sum += b[i];
maxsum = sum;
for (int i = 0; i < 2 * n - x; i++) {
sum += b[x + i] - b[i];
maxsum = max(sum, maxsum);
}
cout << maxsum;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, w;
cin >> n >> w;
vector<pair<long long int, long long int>> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first;
a[i].second = i + 1;
}
sort(a.begin(), a.end());
long long int sum = 0;
vector<long long int> ans;
for (int i = n - 1; i >= 0; i--)
if (a[i].first + sum <= w) {
sum += a[i].first, ans.push_back(a[i].second);
}
if (sum < (w + 1) / 2) {
cout << "-1"
<< "\n";
return;
}
cout << ans.size() << "\n";
for (auto u : ans) cout << u << " ";
cout << "\n";
return;
}
int main() {
std::ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
long long int suf[2001][2];
long long int pre[2001][2];
long long int sm[2001][2001];
long long int dp[2001][2001];
long long int a[10000];
long long int max(long long int a, long long int b);
long long int func(int index, int l, int flag);
int main() {
int n;
scanf("%d", &n);
int i, j;
for (i = 1; i <= n; ++i) {
sm[i][i] = -LLONG_MAX;
scanf("%lld", &a[i]);
a[i] = a[i] - 1;
}
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j) sm[i][j] = -1;
if (a[1] == 1)
pre[1][1] = 1;
else
pre[1][0] = 1;
for (i = 2; i <= n; ++i) {
if (a[i] == 1) {
pre[i][1] = pre[i - 1][1] + 1;
pre[i][0] = pre[i - 1][0];
} else {
pre[i][1] = pre[i - 1][1];
pre[i][0] = pre[i - 1][0] + 1;
}
}
if (a[n] == 1)
suf[n][1] = 1;
else
suf[n][0] = 1;
for (i = n - 1; i >= 1; --i) {
if (a[i] == 1) {
suf[i][1] = suf[i + 1][1] + 1;
suf[i][0] = suf[i + 1][0];
} else {
suf[i][1] = suf[i + 1][1];
suf[i][0] = suf[i + 1][0] + 1;
}
}
for (i = 1; i <= n; ++i) {
for (j = i + 1; j <= n; ++j) {
if (a[j] == 0) {
sm[i][j] = max(1 + sm[i][j - 1], 1 + suf[i][1] - suf[j][1]);
} else {
sm[i][j] = sm[i][j - 1];
}
}
}
long long int ans = -LLONG_MAX;
for (i = 1; i <= n; ++i) {
for (j = i; j <= n; ++j) {
ans = max(ans, pre[i - 1][0] + sm[i][j] + suf[j + 1][1]);
ans = max(ans, pre[i][0] + suf[i + 1][1]);
ans = max(ans, pre[i - 1][0] + suf[i][1]);
}
}
printf("%lld\n", ans);
return 0;
}
long long int max(long long int a, long long int b) {
if (a > b)
return a;
else
return b;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct timer {
time_t start;
timer() { start = clock(); }
~timer() {
cerr << 1. * (clock() - start) / CLOCKS_PER_SEC << " secs" << endl;
}
};
long long n, K, a[200010], sum;
long long b[200010], bsum[200010];
int ans[200010];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> K;
for (int i = 0; i < (n); i++) cin >> a[i];
long long sum = 0, cur = 0;
for (int i = 0; i < (n); i++) {
if (sum - cur * (n - 1 - i) * a[i] < K) {
ans[i] = 1;
} else
sum += cur * a[i], cur++;
}
for (int i = 0; i < (n); i++)
if (ans[i]) cout << i + 1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n, m;
vector<tuple<int, int, int> > q;
vector<int> w(9, 0);
map<int, bool> mark;
bool cmp1(const tuple<int, int, int> &t1, const tuple<int, int, int> &t2) {
return get<1>(t1) < get<1>(t2);
}
bool cmp2(const tuple<int, int, int> &t1, const tuple<int, int, int> &t2) {
return get<0>(t1) + get<1>(t1) < get<0>(t2) + get<1>(t2);
}
bool cmp3(const tuple<int, int, int> &t1, const tuple<int, int, int> &t2) {
return get<0>(t1) - get<1>(t1) < get<0>(t2) - get<1>(t2);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int r, c;
cin >> r >> c;
q.emplace_back(r, c, 0);
}
sort(q.begin(), q.end());
for (int i = 0; i < m; i++) {
int r, c, v;
tie(r, c, v) = q[i];
if (mark[c]) get<2>(q[i])++;
mark[c] = 1;
}
mark.clear();
for (int i = m - 1; i >= 0; i--) {
int r, c, v;
tie(r, c, v) = q[i];
if (mark[c]) get<2>(q[i])++;
mark[c] = 1;
}
sort(q.begin(), q.end(), cmp1);
mark.clear();
for (int i = 0; i < m; i++) {
int r, c, v;
tie(r, c, v) = q[i];
if (mark[r]) get<2>(q[i])++;
mark[r] = 1;
}
mark.clear();
for (int i = m - 1; i >= 0; i--) {
int r, c, v;
tie(r, c, v) = q[i];
if (mark[r]) get<2>(q[i])++;
mark[r] = 1;
}
sort(q.begin(), q.end(), cmp2);
mark.clear();
for (int i = 0; i < m; i++) {
int r, c, v;
tie(r, c, v) = q[i];
if (mark[r - c]) get<2>(q[i])++;
mark[r - c] = 1;
}
mark.clear();
for (int i = m - 1; i >= 0; i--) {
int r, c, v;
tie(r, c, v) = q[i];
if (mark[r - c]) get<2>(q[i])++;
mark[r - c] = 1;
}
sort(q.begin(), q.end(), cmp3);
mark.clear();
for (int i = 0; i < m; i++) {
int r, c, v;
tie(r, c, v) = q[i];
if (mark[r + c]) get<2>(q[i])++;
mark[r + c] = 1;
}
mark.clear();
for (int i = m - 1; i >= 0; i--) {
int r, c, v;
tie(r, c, v) = q[i];
if (mark[r + c]) get<2>(q[i])++;
mark[r + c] = 1;
}
for (auto &it : q) w[get<2>(it)]++;
for (int i = 0; i <= 8; i++) cout << w[i] << ' ';
cout << '\n';
;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long int o1 = 0, e1 = 0;
for (int i = 0; i < n; i++) {
long long int val;
cin >> val;
if (val & 1) {
o1++;
} else {
e1++;
}
}
int m;
cin >> m;
long long int o2 = 0, e2 = 0;
for (int i = 0; i < m; i++) {
long long int val;
cin >> val;
if (val & 1) {
o2++;
} else {
e2++;
}
}
long long int h1 = o1 * o2 + e1 * e2, ans = h1;
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
int n;
int main() {
scanf("%d", &n);
if (n == 3 || n == 4) {
puts("No solution");
return 0;
}
double v = 5000;
if (n < 50) v = 500;
for (int i = 0; i < n; i++) {
double lx = (v + i * 0.02) * cos(2 * i * pi / n),
ly = (v + i * 0.02) * sin(2 * i * pi / n),
rx = (v + ((i + 1) % n) * 0.02) * cos(2 * (i + 1) * pi / n),
ry = (v + ((i + 1) % n) * 0.02) * sin(2 * (i + 1) * pi / n);
double a = lx, b = ly, c = lx * lx + ly * ly, d = rx, e = ry,
f = rx * rx + ry * ry;
if (fabs(a) < 1e-6) {
swap(a, d);
swap(b, e);
swap(c, f);
}
double y = (a * f - c * d) / (a * e - b * d);
printf("%.6lf %.6lf\n", (c - b * y) / a, y);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
multiset<int> S, s;
multiset<int>::iterator it;
int t[N], p[N];
int n, k, w, mi, sum, ans;
void insert(int r) {
if (mi < w) {
s.insert(p[r]);
sum += (p[r] + 1) / 2;
mi++;
return;
}
it = s.begin();
if (*it < p[r]) {
sum -= (*it + 1) / 2;
sum += *it;
S.insert(*it);
s.erase(s.find(*it));
s.insert(p[r]);
sum += (p[r] + 1) / 2;
return;
}
S.insert(p[r]);
sum += p[r];
}
void del(int l) {
it = s.begin();
if (*it <= p[l]) {
sum -= (p[l] + 1) / 2;
s.erase(s.find(p[l]));
if (S.empty()) {
mi--;
return;
}
it = S.end();
it--;
S.erase(S.find(*it));
s.insert(*it);
sum -= *it;
sum += (*it + 1) / 2;
return;
}
sum -= p[l];
S.erase(S.find(p[l]));
}
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]), t[i] += t[i - 1];
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int l = 1, r = 1; r <= n; r++) {
insert(r);
while (sum > k) del(l++);
ans = max(ans, t[r] - t[l - 1]);
}
printf("%d", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int V, E;
vector<int> plus2[100010], minus2[100010];
long long color[100010];
set<long long> colors;
long long gcd(long long x, long long y) { return x ? gcd(y % x, x) : y; }
void dfs(int x, long long c) {
if (color[x] != 0) return;
color[x] = c;
int i;
for ((i) = 0; (i) < (int)(plus2[x].size()); (i)++) dfs(plus2[x][i], c + 1);
for ((i) = 0; (i) < (int)(minus2[x].size()); (i)++) dfs(minus2[x][i], c - 1);
}
int main(void) {
int i, a, b;
scanf("%d%d", &V, &E);
for ((i) = 0; (i) < (int)(E); (i)++) {
scanf("%d%d", &a, &b);
a--;
b--;
plus2[a].push_back(b);
minus2[b].push_back(a);
}
long long M2 = 1000000;
for ((i) = 0; (i) < (int)(V); (i)++)
if (color[i] == 0) {
dfs(i, M2);
M2 += 1000000;
}
long long g = 0;
for ((a) = 0; (a) < (int)(V); (a)++)
for ((i) = 0; (i) < (int)(plus2[a].size()); (i)++) {
b = plus2[a][i];
long long tmp = color[b] - (color[a] + 1);
if (tmp > 0) g = gcd(g, tmp);
if (tmp < 0) g = gcd(g, -tmp);
}
for ((a) = 0; (a) < (int)(V); (a)++)
for ((i) = 0; (i) < (int)(minus2[a].size()); (i)++) {
b = minus2[a][i];
long long tmp = color[b] - (color[a] - 1);
if (tmp > 0) g = gcd(g, tmp);
if (tmp < 0) g = gcd(g, -tmp);
}
if (g != 0) {
cout << g << endl;
return 0;
}
cout << V << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long n, m, k;
cin >> n >> m >> k;
long long m1 = min(n / k, m);
long long m2 =
((m - m1) % (k - 1) == 0 ? (m - m1) / (k - 1) : (m - m1) / (k - 1) + 1);
cout << m1 - m2 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
int Ans;
int A[300200], B[300200];
long long Sum1, Sum2;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> A[i];
cin >> m;
for (int i = 0; i < m; i++) cin >> B[i];
for (int i = 0; i < n; i++) Sum1 += A[i];
for (int i = 0; i < m; i++) Sum2 += B[i];
if (Sum1 != Sum2) return cout << -1, 0;
int i = 0, j = 0;
long long Stop1 = Sum1, Stop2 = Sum2;
Sum1 = 0;
Sum2 = 0;
while (Sum1 != Stop1 || Sum2 != Stop2) {
if (Sum1 == Sum2) {
if (Sum1 != Stop1) {
Sum1 += A[i];
i++;
}
if (Sum2 != Stop2) {
Sum2 += B[j];
j++;
}
} else {
if (Sum1 > Sum2) {
if (j < m) {
Sum2 += B[j];
j++;
} else
return cout << -1, 0;
} else {
if (i < n) {
Sum1 += A[i];
i++;
} else
return cout << -1, 0;
}
}
Ans += (Sum1 == Sum2);
}
cout << Ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, i, v1, v2;
cin >> t;
while (t--) {
cin >> n;
v1 = -1;
v2 = -1;
for (i = 2; i * i <= n; i++) {
if (n % i == 0) {
v1 = n / i;
v2 = n - v1;
break;
}
}
if (v1 == -1) {
v1 = 1;
v2 = n - 1;
}
cout << v1 << " " << v2 << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, a[51], mn;
int main() {
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a[i];
}
sort(a, a + m);
for (i = 0; i + n - 1 < m; i++) {
if ((a[i + n - 1] - a[i]) < mn || i == 0) {
mn = a[i + n - 1] - a[i];
}
}
cout << mn;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-12;
const int MOD = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 1e5 + 4;
const int maxm = 1e5 + 4;
inline long long rule(long long x) { return (x %= MOD) += x < 0 ? MOD : 0; }
vector<int> words[maxn], G[maxn];
int n, m;
int tag[maxn];
int judge(int a, int b) {
int l = min(words[a].size(), words[b].size());
for (int i = 0; i < l; ++i) {
int x = words[a][i], y = words[b][i];
if (x < y) {
G[y].push_back(x);
return 1;
} else if (x > y) {
tag[x] |= 1;
tag[y] |= 2;
if (tag[x] == 3 || tag[y] == 3) return 0;
return 1;
}
}
if (l == words[a].size()) return 1;
return 0;
}
bool vis[maxn];
void dfs(int u) {
tag[u] |= 1;
for (auto v : G[u])
if (!vis[v]) {
dfs(v);
}
}
int main() {
int ik, i, j, k, kase;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &k);
while (k--) {
scanf("%d", &j);
words[i].push_back(j);
}
}
for (int i = 2; i <= n; ++i) {
if (!judge(i - 1, i)) {
puts("No");
return 0;
}
}
for (int i = 1; i <= m; ++i) {
if (tag[i] == 1 && !vis[i]) dfs(i);
}
for (int i = 1; i <= m; ++i)
if (tag[i] == 3) {
puts("No");
return 0;
}
puts("Yes");
vector<int> ans;
for (int i = 1; i <= m; ++i) {
if (tag[i] == 1) ans.push_back(i);
}
printf("%d\n", int(ans.size()));
for (int i = 0; i < ans.size(); ++i)
printf("%d%c", ans[i], " \n"[i == (ans.size() - 1)]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1), gn(x2), gn(x3);
}
template <class T1, class T2, class T3, class T4>
inline void gn(T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
gn(x1), gn(x2), gn(x3), gn(x4);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
template <class T1, class T2, class T3, class T4>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4) {
printsp(x1), printsp(x2), printsp(x3), println(x4);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int a[100010], dp[100010];
int main() {
int n, k;
gn(n, k);
for (int i = 0; i < n; i++) {
gn(a[i]);
}
if (k == 1) {
println(*min_element(a, a + n));
return 0;
}
if (k > 2) {
println(*max_element(a, a + n));
return 0;
}
dp[n] = 0x3f3f3f3f;
for (int i = n - 1; i >= 0; i--) {
dp[i] = min(dp[i + 1], a[i]);
}
int mn = a[0];
int ans = max(mn, dp[1]);
for (int i = 1; i < n - 1; i++) {
smin(mn, a[i]);
smax(ans, max(mn, dp[i + 1]));
}
println(ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<long long int>;
using vvi = vector<vi>;
using vb = vector<bool>;
using vc = vector<char>;
using vs = vector<string>;
using vld = vector<long double>;
using pii = pair<long long int, long long int>;
using psi = pair<string, long long int>;
using pci = pair<char, long long int>;
using vpii = vector<pii>;
long long int mod = 1e9 + 7;
long long int const maxn = 1e5 + 5;
long long int const inf = 1e18;
long long int add(long long int a, long long int b) {
return ((a % mod) + (b % mod)) % mod;
}
long long int mul(long long int a, long long int b) {
return ((a % mod) * (b % mod)) % mod;
}
long long int powm(long long int x, long long int n, long long int M) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
long long int modinverse(long long int a, long long int m) {
return powm(a, m - 2, m);
}
bool prime(long long int x) {
if (x <= 1) return false;
for (int i = 2; i <= sqrt(x); i++)
if (x % i == 0) return false;
return true;
}
long long int divisor(long long int x) {
long long int cnt = 0;
for (int i = 1; i <= sqrt(x); i++) {
if (x % i == 0) {
if (i != x / i)
cnt += 2;
else
cnt += 1;
}
}
return cnt;
}
vector<long long int> sieve(long long int n) {
bool prim[n + 1];
memset(prim, true, sizeof(prim));
for (long long int p = 2; p * p <= n; p++) {
if (prim[p] == true) {
for (int i = p * p; i <= n; i += p) prim[i] = false;
}
}
vector<long long int> v;
for (int i = 2; i <= n; i++)
if (prim[i]) v.push_back(i);
return v;
}
long long int const N = 1005;
long long int dp1[N][N];
long long int dp2[N][N];
long long int dp3[N][N];
long long int dp4[N][N];
long long int a[N][N];
void solve() {
long long int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dp1[i][j] = a[i][j] + max(dp1[i - 1][j], dp1[i][j - 1]);
}
}
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
dp2[i][j] = a[i][j] + max(dp2[i + 1][j], dp2[i][j + 1]);
}
}
for (int i = n; i >= 1; i--) {
for (int j = 1; j <= m; j++) {
dp3[i][j] = a[i][j] + max(dp3[i + 1][j], dp3[i][j - 1]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = m; j >= 1; j--) {
dp4[i][j] = a[i][j] + max(dp4[i - 1][j], dp4[i][j + 1]);
}
}
long long int ans = 0;
for (int i = 2; i < n; i++) {
for (int j = 2; j < m; j++) {
ans = max(ans,
dp1[i][j - 1] + dp2[i][j + 1] + dp3[i + 1][j] + dp4[i - 1][j]);
ans = max(ans,
dp1[i - 1][j] + dp2[i + 1][j] + dp3[i][j - 1] + dp4[i][j + 1]);
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 1e5 + 5;
int mx[N], p[N];
bool used[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> mx[i], used[i] = false;
p[1] = mx[1];
used[p[1]] = true;
int ind = 1;
bool ok = true;
for (int i = 2; i <= n; ++i) {
while (used[ind]) ind++;
if (!used[mx[i]]) {
p[i] = mx[i];
used[p[i]] = true;
continue;
}
if (ind > mx[i]) {
ok = false;
break;
}
used[ind] = true;
p[i] = ind++;
}
if (!ok) {
cout << "-1\n";
continue;
}
for (int i = 1; i <= n; ++i) cout << p[i] << " ";
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long long a[n];
map<long long, long long> mp;
for (long long i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
for (long long i = 0; i < 14; i++) {
mp[(1 << (i + 1))] += mp[(1 << i)] / 2;
}
if (mp[2048] > 0) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t;
t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, t;
long long int power(long long int a, long long int n) {
if (n == 0) {
return 1;
}
long long int p = power(a, n / 2) % 1000000000;
p = (p * p) % 1000000000;
if (n % 2 == 1) {
p = (p * a) % 1000000000;
}
return p;
}
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int comp(string s, vector<string> &a) {
long long int flag = 1;
for (int i = 0; i < n; i++) {
long long int count = 0;
for (int j = 0; j < m; j++) {
if (s[j] != a[i][j]) {
count++;
}
}
if (count > 1) {
flag = -1;
break;
}
}
return flag;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> t;
while (t--) {
cin >> n >> m;
vector<string> a(n);
;
for (long long int i = 0; i < n; i++) cin >> a[i];
;
long long int flag = 0;
for (int i = 0; i < m; i++) {
string s = a[0];
for (int j = 0; j < 26; j++) {
s[i] = (char)(j + 97);
if (comp(s, a) == 1) {
flag = 1;
cout << s << "\n";
break;
}
}
if (flag == 1) {
break;
}
}
if (flag == 0) {
cout << -1 << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void debug_all() { cerr << "]\n"; }
template <typename T, typename... Types>
void debug_all(T var1, Types... var2) {
cerr << ' ' << var1 << ' ';
debug_all(var2...);
}
long long int binomialCoeff(int n, int k) {
long long int C[n + 1][k + 1];
int i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= min(i, k); j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
return C[n][k];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int tc, n, z, o, ans;
cin >> tc;
while (tc--) {
cin >> n;
vector<long long int> a(n);
z = o = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 0) {
z++;
} else if (a[i] == 1) {
o++;
}
}
ans = o;
for (int i = 1; i <= z; i++) {
ans += o * (binomialCoeff(z, i));
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
const string task = "";
template <class T>
T sqr(T x) {
return x * x;
}
int calc(int n, int m) {
if (n > m) swap(n, m);
if (n == 1) return m < 6;
if (n == 2) return m < 6;
if (n == 3) return m < 6;
if (n == 4) return m < 5;
return 0;
}
int main() {
int n, m, x1, y1, x2, y2;
cin >> n >> m >> x1 >> y1 >> x2 >> y2;
if (calc(abs(x1 - x2) + 1, abs(y1 - y2) + 1))
puts("First");
else
puts("Second");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
bool cmax(T& a, const U& b) {
return a < b ? a = b, 1 : 0;
}
template <class T, class U>
bool cmin(T& a, const U& b) {
return b < a ? a = b, 1 : 0;
}
void _BG(const char* s) { cerr << s << endl; };
template <class T, class... TT>
void _BG(const char* s, T a, TT... b) {
for (int c = 0; *s && (c || *s != ','); ++s) {
cerr << *s;
for (char x : "([{") c += *s == x;
for (char x : ")]}") c -= *s == x;
}
cerr << " = " << a;
if (sizeof...(b)) {
cerr << ", ";
++s;
}
_BG(s, b...);
}
bool RD() { return 1; }
bool RD(char& a) { return scanf(" %c", &a) == 1; }
bool RD(char* a) { return scanf("%s", a) == 1; }
bool RD(double& a) { return scanf("%lf", &a) == 1; }
bool RD(int& a) { return scanf("%d", &a) == 1; }
bool RD(long long& a) { return scanf("%lld", &a) == 1; }
template <class T, class... TT>
bool RD(T& a, TT&... b) {
return RD(a) && RD(b...);
}
void PT(const char& a) { putchar(a); }
void PT(char const* const& a) { fputs(a, stdout); }
void PT(const double& a) { printf("%.16f", a); }
void PT(const int& a) { printf("%d", a); }
void PT(const long long& a) { printf("%lld", a); }
template <char s = ' ', char e = '\n'>
void PL() {
if (e) PT(e);
}
template <char s = ' ', char e = '\n', class T, class... TT>
void PL(const T& a, const TT&... b) {
PT(a);
if (sizeof...(b) && s) PT(s);
PL<s, e>(b...);
}
const int N = 212345;
int n, m, k;
set<int> g[N];
pair<int, int> e[N];
bool die[N];
int ans, QAQ[N];
vector<int> rm;
void chk(int v) {
if (((int)(g[v]).size()) < k && !die[v]) {
rm.push_back(v);
die[v] = 1;
--ans;
}
}
void del(int u, int v) {
g[u].erase(v);
g[v].erase(u);
chk(u);
chk(v);
}
int main() {
RD(n, m, k);
for (int i(0); i < (m); ++i) {
int u, v;
RD(u, v);
--u, --v;
e[i] = {u, v};
g[u].insert(v);
g[v].insert(u);
}
ans = n;
for (int i(0); i < (n); ++i) chk(i);
for (int i((m)-1); i >= (0); --i) {
while (((int)(rm).size())) {
int u = ((rm).back());
(rm).pop_back();
while (((int)(g[u]).size())) del(u, *begin(g[u]));
}
QAQ[i] = ans;
del(e[i].first, e[i].second);
}
for (int i(0); i < (m); ++i) PL(QAQ[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long cs, a, b, q, i, l, r;
long long S[40001];
long long f(long long n) { return n / (a * b) * S[a * b - 1] + S[n % (a * b)]; }
int main() {
cin >> cs;
while (cs--) {
cin >> a >> b >> q;
for (i = 1; i < a * b; i++) {
S[i] = S[i - 1];
if (i % a % b != i % b % a) S[i]++;
}
while (q--) {
cin >> l >> r;
cout << f(r) - f(l - 1) << " ";
}
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int M = 1005;
const long long mod = 1000000007;
const int inf = (1 << 30);
const long long linf = (1LL << 61);
long long u, n, nr, mx, px;
long long desc(long long x) {
long long p = 1LL;
while (x) {
p *= x % 10;
x /= 10;
}
return p;
}
int main() {
ios::sync_with_stdio(false);
cin.tie();
cin >> n;
u = 1LL;
while (u <= n) u *= 10;
u /= 10;
while (u) {
px = n / u;
if (px % 10 == 0) {
px = n % u;
n -= px - 1;
px = n / u;
}
px *= u;
nr = px - 1;
mx = max(mx, desc(nr));
u /= 10;
}
mx = max(mx, desc(n));
cout << mx;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int maxn = 1e5 + 1;
int deg[maxn], odd[maxn], even[maxn], v[maxn], cnt[maxn];
vector<vector<int>> e(maxn, vector<int>());
void dfs(int node) {
if (deg[node] == 1) {
even[node] = 1;
return;
}
v[node] = 1;
for (int i = 0; i < e[node].size(); ++i) {
int child = e[node][i];
if (!v[child]) {
dfs(child);
if (even[child]) odd[node] = 1;
if (odd[child]) even[node] = 1;
}
}
}
void find() {
int res1 = 1;
int res2 = n - 1;
for (int i = 0; i < n; ++i)
if (odd[i] && even[i]) res1 = 3;
for (int i = 0; i < n; ++i)
if (deg[i] == 1) cnt[e[i][0]]++;
for (int i = 0; i < n; ++i)
if (cnt[i] > 0) res2 -= cnt[i] - 1;
cout << res1 << " " << res2 << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
deg[a]++;
deg[b]++;
e[a].push_back(b);
e[b].push_back(a);
}
for (int i = 0; i < n; ++i)
if (deg[i] != 1) {
dfs(i);
break;
}
find();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, l, n, m, s, d;
scanf("%d", &n);
long long c = 0;
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++) {
s = i ^ j;
if (s <= n && s >= j) {
for (k = j; k <= s && k <= n; k++) {
d = s ^ k;
if (d == 0 && (i + j > k && i + k > j && j + k > i)) {
c++;
}
}
}
}
}
printf("%d\n", c);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int left = -1e5, right = 1e5, down = -1e5, top = 1e5;
for (int i = 0; i < n; ++i) {
int x, y, a, b, c, d;
cin >> x >> y >> a >> b >> c >> d;
if (!a) left = max(x, left);
if (!b) top = min(y, top);
if (!c) right = min(x, right);
if (!d) down = max(y, down);
}
if (left <= right && down <= top) {
cout << "1 " << left << " " << down << endl;
} else {
cout << "0" << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long z) {
long long ret = 1;
while (y > 0) {
if (y & 1) ret = (ret * x) % z;
x = (x * x) % z;
y >>= 1;
}
return ret;
}
const long long N = 5e5 + 5;
long long L[N], R[N], cnt = 1;
vector<long long> V[N];
void dfs(long long x, long long p) {
for (auto u : V[x]) {
if (u == p) continue;
L[u] = cnt++;
}
R[x] = cnt++;
reverse((V[x]).begin(), (V[x]).end());
for (auto u : V[x]) {
if (u == p) continue;
dfs(u, x);
}
}
int main() {
long long n;
scanf("%lld", &n);
for (long long i = 1; i <= n - 1; ++i) {
long long x, y;
scanf("%lld%lld", &x, &y);
V[x].push_back(y);
V[y].push_back(x);
}
L[1] = cnt++;
dfs(1, 0);
for (long long i = 1; i <= n; ++i) printf("%lld %lld\n", L[i], R[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using std::vector;
struct rational {
long long n, d;
rational(long long _n = 0, long long _d = 0) : n(_n), d(_d) {}
inline bool operator<(const rational &B) const { return n * B.d < d * B.n; }
};
const int N = 100054;
int n, m, lim;
int a[N], ty[N], assign[N], assign_id[N];
vector<std::pair<int, int> > add[N];
vector<std::pair<rational, int> > multiplies;
inline void down(int &x, const int y) { x > y ? x = y : 0; }
int main() {
int i, id, arg;
long long sum;
scanf("%d%d%d", &n, &m, &lim);
for (i = 1; i <= n; ++i)
scanf("%d", a + i), assign[i] = a[i], assign_id[i] = -1;
for (i = 0; i < m; ++i) switch (scanf("%d%d%d", ty + i, &id, &arg), ty[i]) {
case 1:
if (arg > assign[id]) assign[id] = arg, assign_id[id] = i;
break;
case 2:
add[id].emplace_back(arg, i);
break;
case 3:
multiplies.emplace_back(rational(arg - 1, 1), i);
break;
}
for (i = 1; i <= n; ++i) {
if (~assign_id[i]) add[i].emplace_back(assign[i] - a[i], assign_id[i]);
std::sort(add[i].begin(), add[i].end(),
std::greater<std::pair<int, int> >()),
sum = a[i];
for (const std::pair<int, int> &op : add[i])
multiplies.emplace_back(rational(op.first, sum), op.second),
sum += op.first;
}
std::sort(multiplies.begin(), multiplies.end(),
std::greater<std::pair<rational, int> >());
down(lim, multiplies.size()), printf("%d\n", lim);
std::sort(
multiplies.begin(), multiplies.begin() + lim,
[](const std::pair<rational, int> &A, const std::pair<rational, int> &B) {
return ty[A.second] < ty[B.second];
});
for (i = 0; i < lim; ++i)
printf("%d%c", multiplies[i].second + 1, i == lim - 1 ? 10 : 32);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int x, cur, n, q[100005], a[100005];
int pt, ans = 0, af[500015], as[500015];
int pr[100005], lp[100005];
int main(int argc, const char *argv[]) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &q[i]);
a[q[i]] = i;
}
for (int i = 2; i <= n; ++i) pr[i] = 1;
int j = 2;
while (j <= n) {
if (pr[j] == 1) {
int z = 2 * j;
while (z <= n) {
pr[z] = 0;
z += j;
}
}
++j;
}
lp[2] = 2;
for (int i = 3; i <= n; ++i)
if (pr[i])
lp[i] = i;
else
lp[i] = lp[i - 1];
for (int i = 1; i <= n; ++i) {
cur = a[i];
while (cur > i) {
pt = lp[cur - i + 1];
af[++ans] = cur - pt + 1;
as[ans] = cur;
x = q[af[ans]];
q[af[ans]] = q[as[ans]];
q[as[ans]] = x;
a[q[as[ans]]] = as[ans];
a[q[af[ans]]] = af[ans];
cur = af[ans];
}
}
printf("%d\n", ans);
for (int i = 1; i <= ans; ++i) printf("%d %d\n", af[i], as[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a[550000];
int l[550000], r[550000], last[550000], size[550000];
int n, x, y, tot = 0, cnt = 0;
void find(int x, int fa) {
for (int k = a[x].size() - 1; k >= 0; k--) {
int y = a[x][k];
if (y != fa) {
++cnt;
l[y] = cnt;
}
}
r[x] = ++cnt;
for (int k = 0; k < a[x].size(); k++) {
int y = a[x][k];
if (y != fa) {
find(y, x);
}
}
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
}
l[1] = 1;
cnt = 1;
find(1, -1);
for (int i = 1; i <= n; i++) printf("%d %d\n", l[i], r[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double length(int x1, int x2, int y1, int y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
int main() {
int n, k, x[128], y[128];
cin >> n >> k;
double s1, s2, len1, len2, len3, res = 0.0;
for (int i = 0; i < n; ++i) {
cin >> x[i] >> y[i];
if (!i) continue;
res += length(x[i], x[i - 1], y[i], y[i - 1]);
}
printf("%.8lf\n", res * k / 50.0);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
string s;
cin >> n >> s;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long dp[n][4];
for (long long i = 0; i < n; i++) {
dp[i][0] = dp[i][1] = dp[i][2] = dp[i][3] = 0;
}
for (long long i = 0; i < n; i++) {
if (i != 0) {
for (long long j = 0; j < 4; j++) {
dp[i][j] = dp[i - 1][j];
}
}
if (s[i] == 'h') {
dp[i][0] += a[i];
}
if (s[i] == 'a') {
dp[i][1] = min(a[i] + dp[i][1], dp[i][0]);
}
if (s[i] == 'r') {
dp[i][2] = min(a[i] + dp[i][2], dp[i][1]);
}
if (s[i] == 'd') {
dp[i][3] = min(a[i] + dp[i][3], dp[i][2]);
}
}
long long ans = min({dp[n - 1][0], dp[n - 1][1], dp[n - 1][2], dp[n - 1][3]});
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, b, n, t, a = 1, cnt = 0;
scanf("%lld%lld%lld%lld", &k, &b, &n, &t);
for (int i = 1; i <= n; i++) {
a = a * k + b;
if (a <= t)
cnt = i;
else
break;
}
printf("%lld", n - cnt);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> t[1 << 21];
int lz[1 << 21];
vector<int> get(vector<int> s) {
vector<int> ans;
int sz = s.size();
for (int k = 0; !s.empty() && k < 30; ++k) {
int cnt = -1;
for (int i = 0; i < sz; ++i)
if ((s[i] >> k) & 1) cnt = i;
if (cnt != -1) {
const int vv = s[cnt];
ans.push_back(vv);
swap(s[cnt], s[sz - 1]);
s.pop_back();
--sz;
for (auto &it : s)
if ((it >> k) & 1) it ^= vv;
}
}
return ans;
}
vector<int> operator+(vector<int> a, vector<int> b) {
vector<int> s;
for (auto it : a) s.push_back(it);
for (auto it : b) s.push_back(it);
return get(s);
}
void operator+=(vector<int> &a, vector<int> b) { a = a + b; }
static int s[1 << 20];
void build(int p, int u, int node) {
if (p > u) return void();
if (p == u)
t[node].push_back(s[p] ^ s[p + 1]);
else {
int m = (p + u) / 2;
build(p, m, node << 1);
build(m + 1, u, node << 1 | 1);
t[node] = t[node << 1] + t[node << 1 | 1];
}
}
void update(int p, int u, int pos, int v, int node) {
if (p > u || p > pos || pos > u) return void();
if (p == u)
t[node].back() ^= v;
else {
int m = (p + u) / 2;
if (pos <= m)
update(p, m, pos, v, node << 1);
else
update(m + 1, u, pos, v, node << 1 | 1);
t[node] = t[node << 1] + t[node << 1 | 1];
}
}
vector<int> query(int p, int u, int l, int r, int node) {
if (p > u || l > r) return vector<int>{};
if (l <= p && u <= r) return t[node];
int m = (p + u) / 2;
if (l <= m && m + 1 <= r)
return query(p, m, l, r, node << 1) + query(m + 1, u, l, r, node << 1 | 1);
if (l <= m)
return query(p, m, l, r, node << 1);
else
return query(m + 1, u, l, r, node << 1 | 1);
}
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T first, char end = 0);
inline void writeChar(int first);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) c = getChar();
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T first = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') first = first * 10 + c - '0', c = getChar();
return s == 1 ? first : -first;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int first) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = first;
}
template <class T>
inline void writeInt(T first, char end) {
if (first < 0) writeChar('-'), first = -first;
char s[24];
int n = 0;
while (first || !n) s[n++] = '0' + first % 10, first /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
int main(void) {
srand(time(0));
cout << fixed << setprecision(7);
cerr << fixed << setprecision(7);
int n = readInt();
int m = readInt();
for (int i = 1; i <= n; ++i) s[i] = readInt();
static int t[1 << 20];
auto U = [&](int i, int v) {
for (; i <= n; i += i & (-i)) t[i] ^= v;
};
auto Q = [&](int i) {
int ans = 0;
for (; i; i -= i & (-i)) ans ^= t[i];
return ans;
};
build(1, n - 1, 1);
for (int i = 1; i <= n; ++i) U(i, s[i] ^ s[i - 1]);
while (m--) {
int op = readInt();
int l = readInt(), r = readInt(), k;
if (op == 2) {
vector<int> ans;
if (l < r) ans = query(1, n - 1, l, r - 1, 1);
ans.push_back(Q(r));
writeInt(1 << get(ans).size(), '\n');
} else {
k = readInt();
U(l, k);
if (r < n) U(r + 1, k);
if (l > 1) update(1, n - 1, l - 1, k, 1);
if (r < n) update(1, n - 1, r, k, 1);
}
}
cerr << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms"
<< '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a1 = 0, a2 = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 100) {
a1++;
} else
a2++;
}
if (a1 % 2 != 0) {
cout << "NO" << endl;
} else {
if (a2 % 2 != 0 && a1 < 2) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, i, ans;
scanf("%d", &n);
ans = 2e9;
for (i = 0; i < n; i++) {
int a;
scanf("%d", &a);
if (ans > (a /= i > n - 1 - i ? i : n - 1 - i)) ans = a;
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
string print_iterable(T1 begin_iter, T2 end_iter, int counter) {
bool done_something = false;
stringstream res;
res << "[";
for (; begin_iter != end_iter and counter; ++begin_iter) {
done_something = true;
counter--;
res << *begin_iter << ", ";
}
string str = res.str();
if (done_something) {
str.pop_back();
str.pop_back();
}
str += "]";
return str;
}
vector<int> SortIndex(int size, std::function<bool(int, int)> compare) {
vector<int> ord(size);
for (int i = 0; i < size; i++) ord[i] = i;
sort(ord.begin(), ord.end(), compare);
return ord;
}
template <typename T>
bool MinPlace(T& a, const T& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool MaxPlace(T& a, const T& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename S, typename T>
ostream& operator<<(ostream& out, const pair<S, T>& p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
out << "[";
for (int i = 0; i < (int)v.size(); i++) {
out << v[i];
if (i != (int)v.size() - 1) out << ", ";
}
out << "]";
return out;
}
template <class TH>
void _dbg(const char* name, TH val) {
clog << name << ": " << val << endl;
}
template <class TH, class... TA>
void _dbg(const char* names, TH curr_val, TA... vals) {
while (*names != ',') clog << *names++;
clog << ": " << curr_val << ", ";
_dbg(names + 1, vals...);
}
const int MAXN = 100100;
const int MAXL = 18;
int pp[MAXN];
int anc(int x) {
if (pp[x] != x) pp[x] = anc(pp[x]);
return pp[x];
}
void join(int a, int b, int w) {
a = anc(a), b = anc(b);
pp[a] = b;
}
struct Edge {
int a, b, w;
};
vector<int> aa[MAXN];
vector<int> ids[MAXN];
int idp[MAXN];
int fast_pp[MAXN][MAXL];
int fast_cost[MAXN][MAXL];
int dep[MAXN];
vector<int> ss[MAXN];
void dfs(int v, int p) {
dep[v] = dep[p] + 1;
fast_pp[v][0] = p;
for (int i = 0; i < ((int)((aa[v]).size())); i++) {
int a = aa[v][i];
if (a == p)
idp[v] = ids[v][i];
else
dfs(a, v);
}
}
int lca(int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
for (int l = MAXL - 1; l >= 0; l--)
if (dep[v] - (1 << l) >= dep[u]) v = fast_pp[v][l];
if (u == v) return u;
for (int l = MAXL - 1; l >= 0; l--)
if (fast_pp[u][l] != fast_pp[v][l]) u = fast_pp[u][l], v = fast_pp[v][l];
return fast_pp[u][0];
}
multiset<int>* solve(int v, vector<int>& ans) {
multiset<int>* curr = new multiset<int>();
for (int a : aa[v]) {
if (a == fast_pp[v][0]) continue;
multiset<int>* son = solve(a, ans);
if (son->size() > curr->size()) swap(son, curr);
for (int x : *son) curr->insert(x);
son->clear();
}
for (int x : ss[v]) {
if (x <= 0)
curr->insert(-x);
else
curr->erase(curr->find(x - 1));
}
if (v == 1) return curr;
if (curr->empty())
ans[idp[v]] = 1e9;
else
ans[idp[v]] = *(curr->begin());
return curr;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, M;
cin >> N >> M;
for (int i = 1; i <= N; i++) pp[i] = i;
vector<Edge> edges(M);
for (int i = 0; i < M; i++) {
cin >> edges[i].a >> edges[i].b >> edges[i].w;
}
vector<int> ans(M, -1);
vector<int> ord =
SortIndex(M, [&](int i, int j) { return edges[i].w < edges[j].w; });
for (int i = 0; i < M; i++) {
Edge e = edges[ord[i]];
if (anc(e.a) != anc(e.b)) {
ans[ord[i]] = 0;
join(e.a, e.b, e.w);
aa[e.a].push_back(e.b);
aa[e.b].push_back(e.a);
ids[e.a].push_back(ord[i]);
ids[e.b].push_back(ord[i]);
}
}
dfs(1, 0);
for (int i = 1; i <= N; i++) {
fast_cost[i][0] = edges[idp[i]].w;
}
for (int l = 1; l < MAXL; l++) {
for (int i = 1; i <= N; i++) {
fast_pp[i][l] = fast_pp[fast_pp[i][l - 1]][l - 1];
fast_cost[i][l] =
max(fast_cost[i][l - 1], fast_cost[fast_pp[i][l - 1]][l - 1]);
}
}
for (int i = 0; i < M; i++) {
if (ans[i] == -1) {
Edge e = edges[i];
ss[e.a].push_back(-e.w);
ss[e.b].push_back(-e.w);
int l = lca(e.a, e.b);
ss[l].push_back(e.w + 1);
ss[l].push_back(e.w + 1);
int v = e.a;
for (int z = MAXL - 1; z >= 0; z--)
if (dep[v] - (1 << z) >= dep[l]) {
ans[i] = max(ans[i], fast_cost[v][z]);
v = fast_pp[v][z];
}
v = e.b;
for (int z = MAXL - 1; z >= 0; z--)
if (dep[v] - (1 << z) >= dep[l]) {
ans[i] = max(ans[i], fast_cost[v][z]);
v = fast_pp[v][z];
}
}
}
solve(1, ans);
for (int i = 0; i < M; i++) cout << ans[i] << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, mod = 1e9 + 7, lg = 16 + 2;
int n, q, par[N][lg], sumup[N][lg], tvin[N][lg], sumin[N][lg], cntin[N][lg],
sumst[N], tvst[N], cntst[N], updtv[N], updsum[N], updcnt[N], h[N];
vector<pair<int, int> > gr[N];
long long mrg(int ftv, int fsum, int fcnt, int add) {
return 1ll *
(1ll * ftv + 1ll * fsum * add % mod * 2 % mod +
1ll * add * add % mod * fcnt % mod) %
mod;
}
void getSt(int v, int par = -1) {
for (auto p : gr[v]) {
int u = p.first, w = p.second;
if (u != par) {
getSt(u, v);
updtv[u] = mrg(tvst[u], sumst[u], cntst[u], w),
tvst[v] = (tvst[v] + updtv[u]) % mod;
updsum[u] = (1ll * cntst[u] * w % mod + sumst[u]) % mod,
sumst[v] = (sumst[v] + updsum[u]) % mod;
updcnt[u] = cntst[u], cntst[v] = cntst[v] + updcnt[u];
}
}
cntst[v]++;
}
void getPr(int v, int parent = -1, int wb = -1) {
if (parent != -1) {
h[v] = h[parent] + 1;
par[v][0] = parent, sumup[v][0] = wb;
for (int i = 1; i < lg - 1; i++)
par[v][i] = par[par[v][i - 1]][i - 1],
sumup[v][i] = (sumup[v][i - 1] + sumup[par[v][i - 1]][i - 1]) % mod;
cntin[v][0] = cntst[parent] - updcnt[v],
sumin[v][0] = (sumst[parent] - updsum[v] + mod) % mod;
tvin[v][0] = mrg((tvst[parent] - updtv[v] + mod) % mod, sumin[v][0],
cntin[v][0], wb);
sumin[v][0] = (sumin[v][0] + 1ll * cntin[v][0] * wb % mod) % mod;
for (int i = 1; i < lg - 1; i++) {
cntin[v][i] = (cntin[v][i - 1] + cntin[par[v][i - 1]][i - 1]) % mod;
sumin[v][i] = ((sumin[v][i - 1] + 1ll * sumup[v][i - 1] *
cntin[par[v][i - 1]][i - 1] % mod) %
mod +
sumin[par[v][i - 1]][i - 1] % mod) %
mod;
tvin[v][i] = (tvin[v][i - 1] +
mrg(tvin[par[v][i - 1]][i - 1], sumin[par[v][i - 1]][i - 1],
cntin[par[v][i - 1]][i - 1], sumup[v][i - 1])) %
mod;
}
}
for (auto p : gr[v]) {
int u = p.first, w = p.second;
if (u != parent) getPr(u, v, w);
}
}
bool isAnc(int v, int u) {
int diff = h[v] - h[u];
if (diff <= 0) return false;
for (int i = 0; i < lg - 1; i++)
if (((diff >> i) & 1)) v = par[v][i];
if (v == u) return true;
return false;
}
int AnsAnc(int v, int u) {
int pst = tvst[v], rtr = 0, sumrn = 0;
int diff = h[v] - h[u];
for (int i = lg - 1; i >= 0; i--) {
if (((diff >> i) & 1)) {
rtr = (rtr + mrg(tvin[v][i], sumin[v][i], cntin[v][i], sumrn)) % mod;
sumrn = (sumrn + sumup[v][i]) % mod;
v = par[v][i];
}
}
return (rtr + pst) % mod;
}
int getSum(int v, int u) {
if (h[u] > h[v]) swap(u, v);
int diff = h[v] - h[u], rtr = 0;
for (int i = 0; i < lg - 1; i++) {
if (((diff >> i) & 1)) rtr = (rtr + sumup[v][i]) % mod, v = par[v][i];
}
if (v == u) return rtr;
for (int i = lg - 1; i >= 0; i--) {
if (par[v][i] != par[u][i]) {
rtr = ((rtr + sumup[v][i]) % mod + sumup[u][i]) % mod;
v = par[v][i], u = par[u][i];
}
}
rtr = ((rtr + sumup[v][0]) % mod + sumup[u][0]) % mod;
return rtr;
}
int AnsN(int v, int u) {
int sum = getSum(v, u);
return mrg(tvst[u], sumst[u], cntst[u], sum);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y, w;
cin >> x >> y >> w;
x--, y--;
gr[x].push_back({y, w});
gr[y].push_back({x, w});
}
getSt(0);
getPr(0);
cin >> q;
while (q--) {
int x, y;
cin >> x >> y;
x--, y--;
long long rtr;
if (isAnc(x, y))
rtr = AnsAnc(x, y);
else
rtr = AnsN(x, y);
int mn = AnsAnc(x, 0);
rtr = ((rtr * 2 - mn) % mod + mod) % mod;
cout << rtr << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int n, m = 0, i, j, a[118], b[118], c[118] = {0};
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d%d", &a[i], &b[i]);
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (i != j && a[i] == b[j]) c[i] = 1;
for (i = 1; i <= n; i++)
if (!c[i]) m++;
printf("%d\n", m);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
vector<long long int> v;
set<long long int> st;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
st.insert(x);
}
for (auto x : st) v.push_back(x);
for (long long int i = 1; i < v.size(); i++) {
if (v[i] < 2 * v[i - 1]) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
double r, x1, x2, y1, y2;
cin >> r >> x1 >> y1 >> x2 >> y2;
double dist = hypot(x2 - x1, y2 - y1);
cout << fixed;
if (dist == 0) {
cout << x1 - r / 2 << " " << y1 << " " << r / 2 << endl;
return 0;
}
if (dist >= r) {
cout << setprecision(12) << x1 << " " << y1 << " " << r << endl;
return 0;
}
double R = r + dist;
R /= 2;
double X = x1 - ((double)r / dist) * (x2 - x1);
double Y = y1 - ((double)r / dist) * (y2 - y1);
cout << setprecision(12) << (X + x2) / 2 << " " << (Y + y2) / 2 << " " << R
<< endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
const char nl = '\n';
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using str = string;
str to_string(char c) { return str(1, c); }
str to_string(bool b) { return b ? "true" : "false"; }
str to_string(const char* second) { return (str)second; }
str to_string(str second) { return second; }
template <class A>
str to_string(complex<A> c) {
stringstream ss;
ss << c;
return ss.str();
}
str to_string(vector<bool> v) {
str res = "{";
for (int i = 0; i < (int)v.size(); i++) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
str to_string(bitset<SZ> b) {
str res = "";
for (int i = 0; i < b.size(); i++) res += char('0' + b[i]);
return res;
}
template <class A, class B>
str to_string(pair<A, B> p);
template <class T>
str to_string(T v) {
bool fst = 1;
str res = "{";
for (const auto& x : v) {
if (!fst) res += ", ";
fst = 0;
res += to_string(x);
}
res += "}";
return res;
}
template <class A, class B>
str to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
void DBG() { cerr << "]" << endl; }
template <class H, class... T>
void DBG(H h, T... t) {
cerr << to_string(h);
if (sizeof...(t)) cerr << ", ";
DBG(t...);
}
void solve() {
int n;
cin >> n;
vi a(n);
for (auto& q : a) cin >> q;
vector<vi> cnt(201, vi(n, 0));
vi pos[201];
for (int i = 0; i < n; i++) {
for (int j = 1; j <= 200; j++) {
if (i) cnt[j][i] = cnt[j][i - 1];
}
cnt[a[i]][i]++;
pos[a[i]].push_back(i);
}
int ans = 1;
for (int i = 1; i <= 200; i++) {
int m = pos[i].size();
for (int j = 0; j < m / 2; j++) {
int x = pos[i][j], y = pos[i][m - j - 1];
int ret = 0;
for (int k = 1; k <= 200; k++) {
ret = max(ret, cnt[k][y - 1] - cnt[k][x]);
}
ans = max(ret + 2 * (j + 1), ans);
}
}
cout << ans << nl;
}
signed main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300000008;
bitset<N> flag;
int prim[20000000];
void init(int l, int r) {
flag.set();
int x = 0;
for (int i = 2; i <= r; i++) {
if (flag[i] == 1) {
prim[x++] = i;
}
for (int j = 0; j < x && i * prim[j] <= r; j++) {
flag[i * prim[j]] = 0;
if (0 == i % prim[j]) {
break;
}
}
}
}
int main() {
int l, r;
scanf("%d%d", &l, &r);
init(l, r);
flag[1] = 0;
int cnt = 0;
if (2 >= l && r >= 2) {
cnt++;
}
for (int i = l; i <= r; i++) {
if (flag[i] == 1 && i % 4 == 1) {
cnt++;
}
}
printf("%d\n", cnt);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m;
int count[200005][2];
cin >> m;
while (m--) {
int n, a, b;
long long T;
cin >> n >> T >> a >> b;
vector<pair<int, int> > problems(n + 1);
for (int i = 1; i <= n; i++) {
cin >> problems[i].second;
}
for (int i = 1; i <= n; i++) {
cin >> problems[i].first;
}
sort(problems.begin(), problems.end());
count[0][0] = 0;
count[0][1] = 0;
for (int i = 1; i <= n; i++) {
count[i][problems[i].second] = count[i - 1][problems[i].second] + 1;
count[i][problems[i].second ^ 1] = count[i - 1][problems[i].second ^ 1];
}
long long curr = 0;
int res = 0;
for (int i = 1; i <= n; i++) {
long long spare = problems[i].first - 1 - curr;
curr += problems[i].second ? b : a;
if (spare < 0) continue;
int res1 = i - 1;
if (spare)
for (int type = 0; type <= 1; type++) {
long long currCount = count[n][type] - count[i - 1][type];
long long solvable = min(spare / (type ? b : a), currCount);
res1 += solvable;
spare -= solvable * (type ? b : a);
}
res = max(res, res1);
}
if (T >= curr)
cout << n << '\n';
else
cout << res << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000 + 123;
int n, k;
string s;
bool dp[maxn][maxn];
char good[maxn];
string trace(int i, int j) {
if (i == 0) return "";
int t = j;
for (; t > 0; t -= t & -t) {
int delta = t & -t;
if (dp[i][j - delta]) return trace(i, j - delta);
}
if (dp[i - 1][j]) return trace(i - 1, j) + s[i + j];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> s;
n = (int)s.size();
s = " " + s;
memset(dp, false, sizeof(dp));
int len = 0, k = 0;
int besti;
while (len + (1 << k) < n) {
len += (1 << k);
++k;
}
for (int i = 0; i <= n; i++) dp[0][i] = true;
for (int i = 1; i <= n; i++) {
char best = 'z';
for (int j = 0; j + i <= n && j <= len; j++) {
if (dp[i - 1][j]) best = min(best, s[i + j]);
}
for (int j = 0; j + i <= n && j <= len; j++)
if (best == s[i + j] && dp[i - 1][j]) dp[i][j] = true;
for (int j = 0; j + i <= n && j <= len; j++) {
int t = j;
for (; t > 0; t -= t & -t) {
int delta = t & -t;
if (dp[i][j - delta]) dp[i][j] = true;
}
}
}
cout << trace(n - len, len) << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string st[3] = {" popStack", " popQueue", " popFront"};
int main() {
int n;
cin >> n;
vector<int> vt;
for (int i = 0; i < 4; i++) vt.push_back(0);
vector<int> v;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
v.push_back(t);
}
for (int i = 0; i < n;) {
int cnt = 0;
for (int h = 0; h < 4; h++) vt[h] = 0;
int ii = i;
while (ii < n && v[ii] != 0) {
vt[0] = v[ii];
sort(vt.begin(), vt.end());
ii++;
cnt++;
}
while (i < n && v[i] != 0) {
if (v[i] == vt[3]) {
cout << "pushStack" << endl;
vt[3] = -1;
} else if (v[i] == vt[2]) {
cout << "pushQueue" << endl;
vt[2] = -1;
} else if (v[i] == vt[1]) {
cout << "pushFront" << endl;
vt[1] = -1;
} else {
cout << "pushBack" << endl;
}
i++;
}
if (i < n && v[i] == 0) {
cnt = min(cnt, 3);
cout << cnt;
for (int j = 0; j < cnt; j++) {
cout << st[j];
}
cout << endl;
i++;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
constexpr ll mod = ll(1e9 + 7);
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int TT = 1;
while (TT--) {
ll n_food, n_ppl;
cin >> n_food >> n_ppl;
vector<ll> W(n_food);
for (auto& x : W) cin >> x;
vector<pair<ll, ll>> F(n_ppl);
vector<unordered_set<int>> n_ppl_fav_food(n_food);
for (int i = 0; i < n_ppl; ++i) {
ll a, b;
cin >> a >> b;
--a;
--b;
F[i] = {a, b};
n_ppl_fav_food[a].emplace(i);
n_ppl_fav_food[b].emplace(i);
}
vector<bool> visited(n_food);
vector<int> ans;
queue<int> q;
for (int f = 0; f < n_food; ++f) {
if (n_ppl_fav_food[f].size() <= W[f]) {
visited[f] = true;
q.emplace(f);
}
}
while (q.size()) {
auto f = q.front();
q.pop();
for (auto u : n_ppl_fav_food[f]) {
int other = F[u].first == f ? F[u].second : F[u].first;
n_ppl_fav_food[other].erase(u);
if (!visited[other] && n_ppl_fav_food[other].size() <= W[other]) {
q.emplace(other);
}
ans.emplace_back(u);
}
n_ppl_fav_food[f].clear();
}
reverse(ans.begin(), ans.end());
if (ans.size() == n_ppl) {
cout << "ALIVE" << endl;
for (int x : ans) {
cout << (x + 1) << " ";
}
cout << endl;
} else {
cout << "DEAD" << endl;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long arr[1005][6];
long long brr[6];
long long crr[6];
vector<long long> v;
int main() {
scanf("%I64d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 5; j++) {
scanf("%I64d", &arr[i][j]);
}
}
long long answer = 0;
for (int i = 0; i < n; i++) {
bool can = true;
for (int j = 0; j < n; j++) {
if (can == false) break;
for (int k = j + 1; k < n; k++) {
if (j == i) break;
if (k == i) continue;
for (int l = 0; l < 5; l++) {
brr[l] = arr[j][l] - arr[i][l];
crr[l] = arr[k][l] - arr[i][l];
}
long long bmod = 0;
long long cmod = 0;
long long ddot = 0;
for (int l = 0; l < 5; l++) {
bmod += brr[l] * brr[l];
cmod += crr[l] * crr[l];
ddot += brr[l] * crr[l];
}
if (ddot > 0) {
can = false;
break;
}
}
}
if (can) {
answer++;
v.push_back(i + 1);
}
}
printf("%I64d\n", answer);
for (int i = 0; i < answer; i++) {
printf("%I64d\n", v[i]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double l, r, k;
while (cin >> l >> r >> k) {
if (k == 1)
cout << (l == 1 ? 1 : -1) << endl;
else {
long double tmp = 1;
int f = 1;
while (tmp < l) tmp *= k;
while (tmp <= r) {
if (f)
f = 0;
else
cout << ' ';
cout << (long long)tmp;
tmp *= k;
}
if (f) cout << -1;
puts("");
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
const long long MOD = 1e9 + 7;
const long long INF = LLONG_MAX;
const long long SIZE = 100000;
vector<long long> temp(200005), v;
long long merge(long long l, long long mid, long long r) {
long long cnt = 0;
long long k = l, i = l, j = mid;
while (i < mid && j <= r) {
if (v[i] < v[j]) {
temp[k] = v[i];
i++;
k++;
} else {
cnt += mid - i;
temp[k] = v[j];
j++;
k++;
}
}
while (i < mid) {
temp[k] = v[i];
i++;
k++;
}
while (j <= r) {
temp[k] = v[j];
j++;
k++;
}
for (long long i = l; i < (long long)r + 1; i++) v[i] = temp[i];
return cnt;
}
long long mergesort(long long l, long long r) {
long long cnt = 0;
if (r > l) {
long long mid = (l + r) / 2;
cnt += mergesort(l, mid);
cnt += mergesort(mid + 1, r);
cnt += merge(l, mid + 1, r);
}
return cnt;
}
void solve() {
long long n;
cin >> n;
string s;
cin >> s;
map<char, queue<long long>> make_pair;
for (long long i = 0; i < (long long)n; i++) {
make_pair[s[i]].push(i + 1);
}
reverse(s.begin(), s.end());
v.clear();
for (long long i = 0; i < (long long)n; i++) {
v.push_back(make_pair[s[i]].front());
make_pair[s[i]].pop();
}
long long ans = mergesort(0, n - 1);
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < n; ++j) {
if (i * i * j > n) {
printf("%d %d", i * j, i);
return 0;
}
}
}
printf("-1");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int S = 500005, N = 100005;
char s[N], sr[S];
int m, e, q, l1, r1, l2, r2, ls, sz, tt, po[S], ln[S], l[N], f[N], ch[N][26],
hd[N], nx[N], to[N], rt[N], fa[N][21];
struct nd {
int l, r;
pair<int, int> p;
} t[N * 30];
void ad(int x, int y) { to[++e] = y, nx[e] = hd[x], hd[x] = e; }
void ins(int c) {
int u = ls, x = ch[u][c];
if (x) {
if (l[u] + 1 == l[x]) {
ls = x;
return;
}
l[++sz] = l[u] + 1, f[sz] = f[x], f[x] = sz, ls = sz;
for (int j = 0; j < 26; j++) ch[sz][j] = ch[x][j];
for (; u && ch[u][c] == x; u = f[u]) ch[u][c] = sz;
if (ch[u][c] == x) ch[u][c] = sz;
} else {
for (ls = ++sz, l[sz] = l[u] + 1; u && !ch[u][c]; u = f[u]) ch[u][c] = sz;
int x = ch[u][c];
if (!x) {
ch[u][c] = sz;
return;
}
if (l[u] + 1 == l[x]) {
f[sz] = x;
return;
}
l[++sz] = l[u] + 1, f[sz] = f[x], f[x] = f[ls] = sz;
for (int j = 0; j < 26; j++) ch[sz][j] = ch[x][j];
for (; u && ch[u][c] == x; u = f[u]) ch[u][c] = sz;
if (ch[u][c] == x) ch[u][c] = sz;
}
}
void pu(int x) { t[x].p = max(t[t[x].l].p, t[t[x].r].p); }
int mrg(int x, int y, int L = 1, int R = m) {
if (!x || !y) return x | y;
int z = ++tt;
if (L == R) {
t[z].p = make_pair(t[x].p.first + t[y].p.first, -L);
return z;
}
t[z].l = mrg(t[x].l, t[y].l, L, ((L + R) >> 1)),
t[z].r = mrg(t[x].r, t[y].r, ((L + R) >> 1) + 1, R), pu(z);
return z;
}
void upd(int &x, int v, int L = 1, int R = m) {
if (!x) x = ++tt;
if (L == R) {
t[x].p = make_pair(t[x].p.first + 1, -v);
return;
}
if (v <= ((L + R) >> 1))
upd(t[x].l, v, L, ((L + R) >> 1));
else
upd(t[x].r, v, ((L + R) >> 1) + 1, R);
pu(x);
}
pair<int, int> qr(int x, int l, int r, int L = 1, int R = m) {
if (!x) return make_pair(0, 0);
if (l <= L && r >= R) return t[x].p;
if (r <= ((L + R) >> 1)) return qr(t[x].l, l, r, L, ((L + R) >> 1));
if (l > ((L + R) >> 1)) return qr(t[x].r, l, r, ((L + R) >> 1) + 1, R);
return max(qr(t[x].l, l, r, L, ((L + R) >> 1)),
qr(t[x].r, l, r, ((L + R) >> 1) + 1, R));
}
int gt(int x, int ln) {
for (int i = 20; ~i; i--)
if (l[fa[x][i]] >= ln) x = fa[x][i];
return x;
}
void dfs(int x) {
for (int i = hd[x]; i; i = nx[i])
dfs(to[i]), rt[x] = mrg(rt[x], rt[to[i]]), fa[to[i]][0] = x;
}
int main() {
scanf("%s%d", sr, &m);
for (int i = 1; i <= m; i++) {
scanf("%s", s), ls = 0;
for (int j = 0; s[j]; j++) ins(s[j] - 'a'), upd(rt[ls], i);
}
for (int i = 0, u = 0, s = 0; sr[i]; i++) {
int c = sr[i] - 'a';
while (u && !ch[u][c]) u = f[u], s = l[u];
if (ch[u][c]) ln[i + 1] = ++s, u = ch[u][c], po[i + 1] = u;
}
for (int i = 1; i <= sz; i++) ad(f[i], i);
dfs(0), scanf("%d", &q);
for (int j = 1; j < 21; j++)
for (int i = 1; i <= sz; i++) fa[i][j] = fa[fa[i][j - 1]][j - 1];
while (q--) {
scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
if (ln[r2] < r2 - l2 + 1) {
printf("%d 0\n", l1);
continue;
}
pair<int, int> k = qr(rt[gt(po[r2], r2 - l2 + 1)], l1, r1);
if (k.first)
printf("%d %d\n", -k.second, k.first);
else
printf("%d 0\n", l1);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int MOD = 1e9 + 7;
const int MAXN = 110;
int C[MAXN];
int B[MAXN];
int T[MAXN];
int dp[MAXN][MAXN*MAXN];
int32_t main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
int N;
cin >> N;
for(int i = 1 ; i <= N ; i++)
{
cin >> C[i];
}
for(int i = 2 ; i <= N ; i++)
{
cin >> B[i];
T[i] = T[i-1]+B[i];
}
for(int i = 1 ; i <= N ; i++)
{
T[i] += T[i-1];
}
int Q;
cin >> Q;
int X;
cin >> X;
///Ta-Tb >= X*i
dp[0][0] = 1;
for(int i = 1 ; i <= N ; i++)
{
for(int j = 0 ; j <= 10000 ; j++)
{
for(int k = 0 ; k <= C[i] ; k++)
{
if(j-T[i] >= X*i && j-k >= 0)
{
dp[i][j] += dp[i-1][j-k];
dp[i][j] %= MOD;
}
}
}
}
int res = 0;
for(int i = 0 ; i <= 10000 ; i++)
{
res += dp[N][i];
res %= MOD;
}
cout << res << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int solve() {
int n;
cin >> n;
int a[n];
int minn = INT_MAX;
int maxx = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
minn = a[0];
for (int i = 1; i < n; i++) {
minn = minn & a[i];
}
return minn;
}
int main() {
int n;
cin >> n;
while (n--) {
cout << solve() << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int e[N * 2], nxt[N * 2], now[N], tail = 1, n, m, in[N], out[N], T, vis[N],
oriented[N * 2], ans, cur[N];
void add(int u, int v) {
e[++tail] = v;
nxt[tail] = now[u];
now[u] = tail;
e[++tail] = u;
nxt[tail] = now[v];
now[v] = tail;
}
void init() {
memset(e, 0, sizeof(e));
memset(nxt, 0, sizeof(nxt));
memset(now, 0, sizeof(now));
memset(in, 0, sizeof(in));
memset(out, 0, sizeof(out));
memset(vis, 0, sizeof(vis));
memset(oriented, 0, sizeof(oriented));
tail = 1;
n = m = ans = 0;
}
void dfs(int x) {
vis[x] = 1;
for (int &i = cur[x]; i; i = nxt[i])
if (!oriented[i] && !oriented[i ^ 1]) {
oriented[i] = 1;
printf("%d %d\n", x, e[i]);
dfs(e[i]);
break;
}
}
int main() {
scanf("%d", &T);
while (T--) {
init();
scanf("%d%d", &n, &m);
for (int i = 1, x, y; i <= m; i++) {
scanf("%d%d", &x, &y);
add(x, y);
in[x]++, in[y]++;
}
for (int i = 1; i <= n; i++)
if ((in[i] & 1) == 0) ans++;
printf("%d\n", ans);
for (int i = 1; i <= n; i++) cur[i] = now[i];
for (int i = 1; i <= n; i++)
if ((in[i] & 1) == 1) dfs(i);
for (int i = 1; i <= n; i++)
if (cur[i]) dfs(i);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<int> V(n);
for (int i = 0; i < n; ++i) scanf("%d", &V[i]);
double ret = 0;
for (int i = 0; i < m; ++i) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
--a;
--b;
if (c == 0) continue;
double tmp = (V[a] + V[b]) / double(c);
ret = max(ret, tmp);
}
printf("%.9lf", ret);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 60;
int n, k, dp[maxn], sum[maxn], A[maxn];
int main() {
cin >> n;
sum[0] = 0;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
reverse(A, A + n);
for (int i = 0; i < n; i++) {
sum[i + 1] = A[i] + sum[i];
}
dp[0] = 0;
for (int i = 1; i < n + 1; i++) {
int mx = 0;
for (int j = 0; j < i; j++) {
mx = max(mx, A[j] + sum[j] - dp[j]);
}
dp[i] = mx;
}
cout << sum[n] - dp[n] << ' ' << dp[n] << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("input.txt");
ofstream fout("output.txt");
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
long long t, q;
cin >> t;
unordered_map<long long, long long> mps;
for (int i = 0; i < t; ++i) {
long long x;
cin >> x;
mps[i + 1] = x;
}
cin >> q;
long long ans = 0, prevh = 0;
while (q--) {
long long w, h;
cin >> w >> h;
cout << max((ans + prevh), mps[w]) << "\n";
ans = max((ans + prevh), mps[w]);
prevh = h;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10;
const long long mod = 1e9 + 7;
vector<long long> v;
map<long long, long long> m;
void solve() {
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back(x);
m[x]++;
}
sort(v.begin(), v.end());
v.resize(distance(v.begin(), unique(v.begin(), v.end())));
long long l = 0, r = v.size() - 1;
long long cl = m[v[l]], cr = m[v[r]];
long long ans = v[r] - v[l];
long long d = 0;
while (k && l < r) {
long long c = 1;
d = 0;
if (cl <= cr) {
if (k >= (cl * (v[l + 1] - v[l]))) {
k -= cl * (v[l + 1] - v[l]);
l++;
cl += m[v[l]];
} else {
d = k / cl;
k = 0;
}
} else {
c = 2;
if (k >= (cr * (v[r] - v[r - 1]))) {
k -= cr * (v[r] - v[r - 1]);
r--;
cr += m[v[r]];
} else {
d = k / cr;
k = 0;
}
}
}
ans = v[r] - v[l];
ans -= d;
ans = max(0LL, ans);
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<int> g[100001], vert;
void bfs(int s) {
queue<int> q;
q.push(s);
while (q.size()) {
int j = q.front();
q.pop();
vector<int> vec;
for (auto v : vert) {
if (g[j].find(v) == g[j].end()) {
q.push(v);
vec.push_back(v);
}
}
for (auto h : vec) {
vert.erase(h);
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
g[u].insert(v);
g[v].insert(u);
}
for (int i = 1; i <= n; i++) {
vert.insert(i);
}
int ans = 0;
while (vert.size()) {
auto it = vert.begin();
int v = *it;
vert.erase(it);
bfs(v);
ans++;
}
cout << ans - 1 << endl;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.