solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
map<char, int> mp;
string str;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> str;
int l = str.size();
if (l % 2) {
cout << "-1" << endl;
return 0;
}
for (int i = 0; i < l; i++) {
mp[str[i]]++;
}
int avgdu = (mp['D'] + mp['U']) / 2;
int cnt1 = abs(avgdu - mp['D']) + abs(avgdu - mp['U']);
int avglr = (mp['L'] + mp['R']) / 2;
int cnt2 = abs(avglr - mp['L']) + abs(avglr - mp['R']);
int cnt = (cnt1 + cnt2) / 2;
cout << cnt << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int INF = 0x3f3f3f3f;
const double eps = 1e-10;
int a[N];
long long dfs(int l, int r, int h) {
if (l == r) return 1;
int hh = INF;
for (int i = l; i <= r; i++) {
hh = min(hh, a[i]);
}
long long sum = hh - h;
for (int i = l; i <= r; i++) {
if (a[i] == hh) continue;
int j = i;
while (a[j + 1] > hh) j++;
sum += dfs(i, j, hh);
i = j;
}
return min((long long)r - l + 1, sum);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
cout << dfs(1, n, 0) << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
int n;
pair<double, int> c[10000];
struct point {
double x, y;
} p[600][5];
int dblcmp(double x) {
if (fabs(x) < eps) return 0;
return x > 0 ? 1 : -1;
}
double cross(point& p1, point& p2, point& p3) {
return (p2.x - p1.x) * (p3.y - p1.y) - (p2.y - p1.y) * (p3.x - p1.x);
}
double dot(point aa, point bb) { return aa.x * bb.x + aa.y * bb.y; }
double segP(point p1, point p2, point p3) {
if (dblcmp(p2.x - p3.x))
return (p1.x - p2.x) / (p3.x - p2.x);
else
return (p1.y - p2.y) / (p3.y - p2.y);
}
double polyUnion() {
int i, j, ii, jj, ta, tb, r, d;
double z, w, s, sum, tc, td;
point tmp1, tmp2;
sum = 0;
for (i = 0; i < n; ++i)
for (ii = 0; ii < 4; ++ii) {
r = 0;
c[r++] = make_pair(0., 0);
c[r++] = make_pair(1., 0);
for (j = 0; j < n; ++j)
if (i - j)
for (jj = 0; jj < 4; ++jj) {
ta = dblcmp(cross(p[i][ii], p[i][ii + 1], p[j][jj]));
tb = dblcmp(cross(p[i][ii], p[i][ii + 1], p[j][jj + 1]));
if (!ta && !tb) {
tmp1.x = p[j][jj + 1].x - p[j][jj].x;
tmp1.y = p[j][jj + 1].y - p[j][jj].y;
tmp2.x = p[i][ii + 1].x - p[i][ii].x;
tmp2.y = p[i][ii + 1].y - p[i][ii].y;
if (dblcmp(dot(tmp1, tmp2)) > 0 && j < i) {
c[r++] = make_pair(segP(p[j][jj], p[i][ii], p[i][ii + 1]), 1);
c[r++] =
make_pair(segP(p[j][jj + 1], p[i][ii], p[i][ii + 1]), -1);
}
} else if (ta >= 0 && tb < 0) {
tc = cross(p[j][jj], p[j][jj + 1], p[i][ii]);
td = cross(p[j][jj], p[j][jj + 1], p[i][ii + 1]);
c[r++] = make_pair(tc / (tc - td), 1);
} else if (ta < 0 && tb >= 0) {
tc = cross(p[j][jj], p[j][jj + 1], p[i][ii]);
td = cross(p[j][jj], p[j][jj + 1], p[i][ii + 1]);
c[r++] = make_pair(tc / (tc - td), -1);
}
}
sort(c, c + r);
z = min(max(c[0].first, 0.), 1.);
d = c[0].second;
s = 0;
for (j = 1; j < r; ++j) {
w = min(max(c[j].first, 0.), 1.);
if (!d) s += w - z;
d += c[j].second;
z = w;
}
tmp1.x = tmp1.y = 0;
sum += cross(tmp1, p[i][ii], p[i][ii + 1]) * s;
}
return 0.5 * sum;
}
int main() {
int i, j;
double area, tmp;
while (scanf("%d", &n) != EOF) {
area = 0;
for (i = 0; i < n; ++i) {
for (j = 0; j < 4; ++j) scanf("%lf %lf", &p[i][j].x, &p[i][j].y);
p[i][4] = p[i][0];
tmp = 0;
for (j = 1; j <= 4; ++j)
tmp += p[i][j - 1].x * p[i][j].y - p[i][j - 1].y * p[i][j].x;
area += fabs(tmp);
if (dblcmp(tmp) < 0) swap(p[i][1], p[i][3]);
}
printf("%.10lf\n", 0.5 * area / polyUnion());
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
const double PI = acos(-1.0);
const int DIR = 4;
const int X[] = {1, 0, -1, 0};
const int Y[] = {0, 1, 0, -1};
const int N = (int)2e5 + 228;
using namespace std;
int n, a[N], q;
long long t[N << 2], mx[N << 2], keep[N << 2];
void build(int v, int tl, int tr, long long cur) {
if (tl == tr) {
mx[v] = 0ll + a[tl] - cur;
t[v] = a[tl];
return;
}
int mid = (tl + tr) >> 1;
build(v << 1, tl, mid, cur);
cur += t[v << 1];
build(v << 1 | 1, mid + 1, tr, cur);
t[v] = t[v << 1] + t[v << 1 | 1];
mx[v] = max(mx[v << 1], mx[v << 1 | 1]);
}
void push(int v, int tl, int tr) {
mx[v << 1] += keep[v];
mx[v << 1 | 1] += keep[v];
keep[v << 1] += keep[v];
keep[v << 1 | 1] += keep[v];
keep[v] = 0;
}
void upd1(int id, int v, int tl, int tr, int val, long long cur) {
if (tl == tr) {
t[v] = val;
mx[v] = 0ll + val - cur;
return;
}
push(v, tl, tr);
int mid = (tl + tr) >> 1;
if (id <= mid)
upd1(id, v << 1, tl, mid, val, cur);
else
upd1(id, v << 1 | 1, mid + 1, tr, val, cur + t[v << 1]);
t[v] = t[v << 1] + t[v << 1 | 1];
mx[v] = max(mx[v << 1], mx[v << 1 | 1]);
}
void upd2(int l, int r, int v, int tl, int tr, int val) {
if (tl > r || tr < l) return;
if (tl >= l && tr <= r) {
mx[v] += val;
keep[v] += val;
return;
}
push(v, tl, tr);
int mid = (tl + tr) >> 1;
upd2(l, r, v << 1, tl, mid, val);
upd2(l, r, v << 1 | 1, mid + 1, tr, val);
t[v] = t[v << 1] + t[v << 1 | 1];
mx[v] = max(mx[v << 1], mx[v << 1 | 1]);
}
int get(int v, int tl, int tr) {
if (mx[v] < 0) return -1;
if (tl == tr) {
if (mx[v] == 0) return tl;
return -1;
}
push(v, tl, tr);
int mid = (tl + tr) >> 1;
int res = -1;
if (mx[v << 1] >= 0) res = get(v << 1, tl, mid);
if (res == -1 && mx[v << 1 | 1] >= 0) res = get(v << 1 | 1, mid + 1, tr);
return res;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
build(1, 1, n, 0);
for (int i = 1; i <= q; i++) {
int x, y;
scanf("%d%d", &x, &y);
upd1(x, 1, 1, n, y, 0);
upd2(x + 1, n, 1, 1, n, a[x] - y);
a[x] = y;
printf("%d\n", get(1, 1, n));
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int K = 3e6 + 7;
const int mod = 1e9 + 7;
long long vis[K], sum[K], cnt[K], ans = 1e18;
int main(void) {
int n, x, y;
cin >> n >> x >> y;
for (int i = 1, a; i <= n; i++) scanf("%d", &a), cnt[a]++, sum[a] += a;
for (int i = 1; i <= 3000000; i++) cnt[i] += cnt[i - 1], sum[i] += sum[i - 1];
for (int i = 2, k = x / y; i <= 1000000; i++)
if (!vis[i]) {
long long tmp = 0;
for (int l = i, mx = 2000000 + i; l <= mx; l += i) {
vis[l] = 1;
int mid = l - k - 1;
if (mid <= l - i)
tmp += ((cnt[l] - cnt[l - i]) * l - (sum[l] - sum[l - i])) * y;
else
tmp += (cnt[mid] - cnt[l - i]) * x +
((cnt[l] - cnt[mid]) * l - (sum[l] - sum[mid])) * y;
}
ans = min(tmp, ans);
}
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int a[5050];
int n, k;
map<int, int> m;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
m[a[i]] = 1;
}
int q, money, ans;
cin >> q;
for (int i = 1; i <= q; i++) {
ans = 1e9;
cin >> money;
for (int j = 1; j <= n; j++) {
if (money % a[j] == 0) {
ans = money / a[j];
}
if (a[j] > money) continue;
for (int d1 = 1; d1 <= k; d1++) {
if (money - d1 * a[j] <= 0) break;
for (int d2 = 1; d1 + d2 <= k; d2++) {
if ((money - d1 * a[j]) % d2 == 0 &&
m.count((money - d1 * a[j]) / d2)) {
ans = min(ans, d1 + d2);
}
}
}
}
if (ans > k) {
cout << "-1" << endl;
} else {
cout << ans << endl;
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, d;
int p;
cin >> a >> d;
cin >> p;
double x = 4 * a;
for (int i = 0; i < p; i++) {
double t = (i + 1) * d;
double t2 = t / x;
double t3 = ceil(t2);
double n = t3 - 1;
double z, y;
if (t >= x * n && t <= x * n + a) {
y = 0;
z = t - (x * n);
printf("%0.9f %0.9f", z, y);
cout << endl;
} else if (t >= x * n + a && t <= x * n + 2 * a) {
z = a;
y = t - (x * n) - a;
printf("%0.9f %0.9f", z, y);
cout << endl;
} else if (t >= x * n + 2 * a && t <= x * n + 3 * a) {
y = a;
z = a - (t - (x * n) - (2 * a));
printf("%0.9f %0.9f", z, y);
cout << endl;
} else {
z = 0;
y = a - (t - (x * n) - (3 * a));
printf("%0.9f %0.9f", z, y);
cout << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct hz {
int x, y, r;
};
int main() {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
int ans = 0, n;
vector<hz> v;
if (x1 > x2) swap(x1, x2);
if (y1 > y2) swap(y1, y2);
cin >> n;
v.resize(n);
for (int i = 0; i < n; i++) cin >> v[i].x >> v[i].y >> v[i].r;
for (int i = x1; i <= x2; i++) {
bool f = false, g = false;
for (int j = 0; j < n; j++) {
if (!f && (v[j].x - i) * (v[j].x - i) + (v[j].y - y1) * (v[j].y - y1) <=
v[j].r * v[j].r) {
f = true;
}
if (!g && (v[j].x - i) * (v[j].x - i) + (v[j].y - y2) * (v[j].y - y2) <=
v[j].r * v[j].r) {
g = true;
}
}
if (f) ans++;
if (g) ans++;
}
for (int i = y1 + 1; i < y2; i++) {
bool f = false, g = false;
for (int j = 0; j < n; j++) {
if (!f && (v[j].x - x1) * (v[j].x - x1) + (v[j].y - i) * (v[j].y - i) <=
v[j].r * v[j].r) {
f = true;
}
if (!g && (v[j].x - x2) * (v[j].x - x2) + (v[j].y - i) * (v[j].y - i) <=
v[j].r * v[j].r) {
g = true;
}
}
if (f) ans++;
if (g) ans++;
}
cout << (x2 - x1 + 1) * 2 + (y2 - y1 - 1) * 2 - ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cout << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const long long sz = 1e5 + 5;
const long long mod = 1e9 + 7;
const long double PI = acos(-1);
const long double eps = 1e-10;
const long long INF = 1e18 + 5;
long long power(long long n, long long k, long long m) {
long long ans = 1;
while (k) {
if (k & 1) {
ans = (ans * n) % m;
k--;
} else {
n = (n * n) % m;
k /= 2;
}
}
return ans;
}
long long add(long long x, long long y) {
long long res = x + y;
res %= mod;
res += mod;
res %= mod;
return res;
}
long long mul(long long x, long long y) {
long long res = x * y;
res %= mod;
res += mod;
res %= mod;
return res;
}
long long NC2(long long n) {
long long res = mul(n * (n + 1) / 2, 1LL);
return res;
}
void solver() {
string s;
cin >> s;
long long n = s.size();
long long dp[n + 1];
dp[n] = 0;
long long pot = 1, x = 1;
for (int i = int(n) - 1; i >= 0; i--) {
dp[i] = add(dp[i + 1], mul(pot, x));
pot = mul(pot, 10);
x++;
}
long long ans = 0;
for (int i = 0; i < int(n); i++) {
long long val = s[i] - '0';
ans = add(ans, mul(mul(NC2(i), val), power(10LL, n - i - 1, mod)));
ans = add(ans, mul(val, dp[i + 1]));
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
long long T = 1;
for (int i = 1; i < int(T + 1); i++) {
solver();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int test;
cin >> test;
while (test--) {
long long int n, b, m, c = 0, prev_i, x, top = 0, prev_top = 0;
cin >> n;
if (n % 4 == 0)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct event {
int pos, l, r, tp;
};
event E[110];
int x[110], y[110], sj[5010], cnt, val[10], A[110], sum[110], n;
bool cmp(event a, event b) { return a.pos < b.pos; }
int calc(int a, int k) {
int ans = 1;
while (k) {
if (k % 2) ans = (long long)ans * a % 998244353;
a = (long long)a * a % 998244353;
k /= 2;
}
return ans;
}
int get_S(int tp, int n) {
if (tp == 1)
return n * ((long long)n + 1) / 2 % 998244353;
else
return (long long)n * (2 * n + 1) % 998244353 * (n + 1) % 998244353 *
calc(6, 998244353 - 2) % 998244353;
}
bool check(int a, int b, int x) {
if (a > b) swap(a, b);
return a + x >= b - x;
}
int get_sj(int id1, int id2) {
int lef = 0, righ = 100000000, ch = 0;
while (lef <= righ) {
int mid = (lef + righ) / 2;
if (check(x[id1], x[id2], mid) && check(y[id1], y[id2], mid)) {
ch = mid;
righ = mid - 1;
} else
lef = mid + 1;
}
return ch;
}
int solve(int now) {
int diff = 0;
for (int i = 1; i <= n; i++) {
int t1 = y[i] - now, t2 = y[i] + now;
A[++diff] = t1;
A[++diff] = t2 + 1;
}
sort(A + 1, A + diff + 1);
diff = unique(A + 1, A + diff + 1) - A - 1;
int tot = 0;
for (int i = 1; i <= n; i++) {
E[++tot] = (event){x[i] - now, y[i] - now, y[i] + now, 1};
E[++tot] = (event){x[i] + now + 1, y[i] - now, y[i] + now, -1};
}
sort(E + 1, E + tot + 1, cmp);
int res = 0;
for (int i = 1; i <= tot; i++) {
int t1 = lower_bound(A + 1, A + diff + 1, E[i].l) - A, t2;
t2 = lower_bound(A + 1, A + diff + 1, E[i].r + 1) - A;
for (int j = t1; j <= t2 - 1; j++) sum[j] += E[i].tp;
int len = 0;
for (int j = 1; j <= diff; j++)
if (sum[j]) len += A[j + 1] - A[j];
res = (res + len * ((long long)E[i + 1].pos - E[i].pos) % 998244353) %
998244353;
}
return res;
}
int main() {
int t;
scanf("%d%d", &n, &t);
for (int i = 1; i <= n; i++) scanf("%d%d", &x[i], &y[i]);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) sj[++cnt] = get_sj(i, j);
sj[++cnt] = t + 1;
sj[++cnt] = 0;
sort(sj + 1, sj + cnt + 1);
cnt = unique(sj + 1, sj + cnt + 1) - sj - 1;
int res = 0;
for (int i = 1; i <= cnt; i++) {
if (sj[i] == t + 1) break;
for (int j = 1; j <= 3; j++) val[j] = solve(sj[i] + j - 1);
int A, B, C, tmp;
A = (((long long)val[1] - 2 * val[2] + val[3]) % 998244353 + 998244353) %
998244353 * calc(2, 998244353 - 2) % 998244353;
B = ((val[2] - val[1] - 3LL * A) % 998244353 + 998244353) % 998244353;
C = ((val[1] - A - B) % 998244353 + 998244353) % 998244353;
if (sj[i + 1] == t + 1) {
int x = t - sj[i] + 1;
tmp = ((long long)A * x % 998244353 * x % 998244353 +
(long long)B * x % 998244353 + C) %
998244353;
res = (res + tmp * ((long long)t + 1) % 998244353) % 998244353;
}
tmp = ((long long)A * get_S(2, sj[i + 1] - sj[i]) % 998244353 +
(long long)B * get_S(1, sj[i + 1] - sj[i]) % 998244353 +
C * ((long long)sj[i + 1] - sj[i])) %
998244353;
res = (res - tmp + 998244353) % 998244353;
}
printf("%d\n", res);
return 0;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
int i, n, x, m, a[3000], c[3000], b[3000];
int main() {
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
cin >> b[i];
}
sort(a, a + n);
sort(b, b + n);
int f, ans = 1e9 + 1, tempx;
for (int i = 0; i < n; i++) {
if (a[0] == b[i]) continue;
if (a[0] < b[i])
x = b[i] - a[0];
else
x = b[i] - a[0] + m;
for (int j = 0; j < n; j++) c[j] = (a[j] + x) % m;
sort(c, c + n);
f = 0;
for (int j = 0; j < n; j++)
if (c[j] != b[j]) {
f = 1;
break;
}
if (f == 0) ans = min(ans, x);
}
if (ans == 1e9 + 1)
cout << 0;
else
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 25;
bool win(int d1, int a1, int d2, int a2) {
if (d1 > a2 && a1 > d2) return true;
return false;
}
bool draw(int d, int a, int dd, int aa) {
if (d == aa && a == dd) return true;
return false;
}
int main(int argc, char *argv[]) {
ios ::sync_with_stdio(false);
cin.tie(NULL);
int d0, d1, d2, d3, a0, a1, a2, a3;
cin >> d0 >> a0 >> d1 >> a1 >> d2 >> a2 >> d3 >> a3;
bool w1 = win(d0, a1, d2, a3);
bool w2 = win(d0, a1, d3, a2);
if (w1 && w2) {
cout << "Team 1" << '\n';
return 0;
}
bool w3 = win(d1, a0, d2, a3);
bool w4 = win(d1, a0, d3, a2);
if (w3 && w4) {
cout << "Team 1" << '\n';
return 0;
}
bool x1 = win(d2, a3, d0, a1);
bool x2 = win(d3, a2, d0, a1);
if (!x1 && !x2) {
cout << "Draw" << '\n';
return 0;
}
bool x3 = win(d3, a2, d1, a0);
bool x4 = win(d2, a3, d1, a0);
if (!x3 && !x4) {
cout << "Draw" << '\n';
return 0;
}
cout << "Team 2" << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct subject {
long long a, b, c;
int idx;
};
int N, M, TK;
subject s[64];
map<long long, int> mp[64];
long long dp[64][128][64];
pair<int, long long> path[64][128][64];
void scan() {
cin >> N >> M >> TK;
for (int i = 0; i < M; ++i) {
cin >> s[i].a >> s[i].b >> s[i].c;
s[i].idx = i + 1;
}
}
bool f(subject t1, subject t2) { return t1.c < t2.c; }
void solve() {
sort(s, s + M, f);
for (int i = 0; i < M; ++i) {
for (long long j = 0; j <= s[i].b - s[i].a; ++j) {
for (int k = N; k >= 2; --k) {
if (mp[k - 1].count(j + s[i].a - TK)) {
int idx = mp[k - 1][j + s[i].a - TK];
if (dp[i][j][k] <
dp[idx][j + s[i].a - TK - s[idx].a][k - 1] + j + s[i].a) {
dp[i][j][k] =
dp[idx][j + s[i].a - TK - s[idx].a][k - 1] + j + s[i].a;
path[i][j][k] = make_pair(idx, j + s[i].a - TK);
}
}
if ((j + s[i].a) % TK == 0 && mp[k - 1].count((j + s[i].a) / TK)) {
int idx = mp[k - 1][(j + s[i].a) / TK];
if (dp[i][j][k] <
dp[idx][(j + s[i].a) / TK - s[idx].a][k - 1] + j + s[i].a) {
dp[i][j][k] =
dp[idx][(j + s[i].a) / TK - s[idx].a][k - 1] + j + s[i].a;
path[i][j][k] = make_pair(idx, (j + s[i].a) / TK);
}
}
}
dp[i][j][1] = j + s[i].a;
path[i][j][1] = make_pair(-1, -1);
}
if (s[i].c != s[i + 1].c) {
for (int ni = 0; ni < M; ++ni)
if (s[i].c == s[ni].c)
for (int j = 0; j <= s[ni].b - s[ni].a; ++j)
for (int k = N; k >= 1; --k)
if (dp[ni][j][k]) {
if (!mp[k].count(j + s[ni].a))
mp[k][j + s[ni].a] = ni;
else {
int idx = mp[k][j + s[ni].a];
if (dp[idx][j + s[ni].a - s[idx].a] < dp[ni][j])
mp[k][j + s[ni].a] = ni;
}
}
}
}
int ri = -1;
long long rj = -1;
for (int i = 0; i < M; ++i) {
for (long long j = s[i].a; j <= s[i].b; ++j) {
if ((ri == -1 || rj == -1)) {
if (dp[i][j - s[i].a][N]) {
ri = i;
rj = j;
}
} else if (dp[ri][rj - s[ri].a][N] < dp[i][j - s[i].a][N] &&
dp[ri][rj - s[ri].a][N]) {
ri = i;
rj = j;
}
}
}
if (ri == -1) {
printf("NO\n");
return;
}
printf("YES\n");
int cur = N;
vector<pair<int, long long> > out;
while (ri != -1) {
out.push_back(make_pair(s[ri].idx, rj));
rj -= s[ri].a;
pair<int, long long> tmp = path[ri][rj][cur--];
ri = tmp.first;
rj = tmp.second;
}
for (int i = out.size() - 1; i >= 0; --i)
cout << out[i].first << " " << out[i].second << endl;
}
int main() {
scan();
solve();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string array[10000];
int ans = 0;
int num[10000];
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) cin >> array[i] >> num[i];
vector<int> S(n);
int x = 0;
for (int i = S.size() - 1; i >= 0 && x < num[0]; i--, x++) S[i] = 1;
do {
vector<int> W(n);
for (int i = 0; i < n; i++) {
if (S[i])
W[i] = array[0][i] - '0';
else {
if (array[0][i] == '0')
W[i] = 1;
else
W[i] = 0;
}
}
bool f = 0;
for (int i = 0; i < m; i++) {
int con = 0;
for (int j = 0; j < n; j++) {
if (W[j] == (array[i][j] - '0')) con++;
if (con > num[i]) break;
}
if (con != num[i]) {
f = 1;
break;
}
}
if (!f) ans++;
} while (next_permutation(S.begin(), S.end()));
cout << ans << endl;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w, m, t = 101;
cin >> w >> m;
if (w == 2) {
cout << "YES" << endl;
return 0;
}
while (m > 0 && t--) {
if (m % w == 0)
;
else if ((m + 1) % w == 0)
m++;
else if ((m - 1) % w == 0)
m--;
else {
cout << "NO" << endl;
return 0;
}
m /= w;
}
if (t < 0 || m)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9;
int n, m, a[N];
vector<int> b[N];
long long cost(int x, int y) {
long long ans(0);
for (int p : b[x]) {
if (p != 1 && a[p - 1] != x) ans += abs(a[p - 1] - x) - abs(a[p - 1] - y);
if (p != m && a[p + 1] != x) ans += abs(a[p + 1] - x) - abs(a[p + 1] - y);
}
return ans;
}
int arr[N], cnt;
int quickSelect(int l, int r, int k) {
int m = arr[rand() % (r - l + 1) + l];
int i(l), j(r);
while (true) {
while (arr[i] < m) ++i;
while (arr[j] > m) --j;
if (i >= j) break;
swap(arr[i++], arr[j--]);
}
if (i == j) {
if (i == k) return *max_element(arr + l, arr + k + 1);
++i, --j;
}
if (j >= k) return quickSelect(l, j, k);
return quickSelect(i, r, k);
}
long long calc(int x) {
cnt = 0;
long long delta(0);
for (int p : b[x]) {
if (p != 1 && a[p - 1] != x)
arr[++cnt] = a[p - 1], delta += abs(a[p - 1] - x);
if (p != m && a[p + 1] != x)
arr[++cnt] = a[p + 1], delta += abs(a[p + 1] - x);
}
if (cnt) {
int y = quickSelect(1, cnt, cnt / 2 + 1);
for (int i = 1; i <= cnt; ++i) delta -= abs(y - arr[i]);
}
return delta;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
srand(time(NULL));
cin >> n >> m;
for (int i = 1; i <= m; ++i) cin >> a[i], b[a[i]].push_back(i);
long long ans(0);
for (int i = 1; i < m; ++i) ans += abs(a[i] - a[i + 1]);
long long ma(0);
for (int x = 1; x <= n; ++x)
if (!b[x].empty()) ma = max(ma, calc(x));
cout << ans - ma;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, h, i = 1;
cin >> n >> d >> h;
if (d > h * 2 || (n > 2 && d < 2)) {
cout << -1 << endl;
} else {
while (i <= h) cout << i++ << ' ' << i << endl;
if (i <= d) cout << 1 << ' ' << ++i << endl;
while (i <= d) cout << i++ << ' ' << i << endl;
int r = 1 + (d == h && h > 1);
while (i < n) cout << r << ' ' << ++i << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > grafo[5050];
int n, m;
long long t;
unsigned int caminho[5050][5050];
int dp[5050][5050];
long long solve(int u, int k) {
if (k == 0) return u == n ? 0 : t + 1;
if (dp[u][k] != 0) return dp[u][k];
long long ret = t + 1;
for (auto x : grafo[u]) {
int v = x.second;
int w = x.first;
long long opc = solve(v, k - 1) + w;
if (opc < ret) {
ret = opc;
caminho[u][k] = v;
}
}
return dp[u][k] = ret;
}
int main() {
scanf("%d %d %lld", &n, &m, &t);
for (int i = 0; i < m; i++) {
int v1, v2;
long long peso;
scanf("%d %d %lld", &v1, &v2, &peso);
grafo[v1].push_back(pair<int, int>(peso, v2));
}
memset(dp, 0, sizeof dp);
for (int cidades = n; cidades > 0; cidades--) {
long long dist = solve(1, cidades);
if (dist <= t) {
printf("%d\n", cidades + 1);
int v = 1;
for (int j = cidades; j > 0; j--) {
printf("%d ", v);
v = caminho[v][j];
}
printf("%d\n", n);
break;
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
map<int, int> m;
set<pair<int, int>, greater<pair<int, int>>> s;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
m[x]++;
}
for (auto it = m.begin(); it != m.end(); it++) {
s.insert({it->second, it->first});
}
auto it = s.begin();
int maxi = it->first;
int mct = 0;
while (it != s.end()) {
if (it->first == maxi)
mct++;
else
break;
it++;
}
n -= maxi * mct;
int res = mct - 1;
res += n / (maxi - 1);
cout << res << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::pair<T, U> operator+(const std::pair<T, U>& l, const std::pair<T, U>& r) {
return {l.first + r.first, l.second + r.second};
}
typedef void (*callback_function)(void);
const long long INF64 = 1e18;
const long long INF32 = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
{
long long n;
cin >> n;
char correct[2][n][n];
for (long long k = (0); k < (2); k++)
for (long long i = (0); i < (n); i++)
for (long long j = (0); j < (n); j++) {
correct[k][i][j] = char('0' + (i + j + k) % 2);
}
long long d[4][2], dist;
char a[n][n];
for (long long t = (0); t < (4); t++) {
for (long long i = (0); i < (n); i++)
for (long long j = (0); j < (n); j++) cin >> a[i][j];
for (long long k = (0); k < (2); k++) {
dist = 0;
for (long long i = (0); i < (n); i++)
for (long long j = (0); j < (n); j++)
dist += (a[i][j] != correct[k][i][j]);
d[t][k] = dist;
}
}
long long res = INF32, r;
for (long long i = (0); i < (3); i++)
for (long long j = (i + 1); j < (4); j++) {
r = d[i][0] + d[j][0];
for (long long k = (0); k < (4); k++)
if (k != i && k != j) r += d[k][1];
res = min(res, r);
}
cout << res << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
vector<int>::iterator it, it2;
int mi = -1;
int main() {
bool e = true;
int i, k;
int sum;
for (i = 2; i < 500000; i++) {
e = true;
for (it = v.begin(); it != v.end() && *it <= i / (*it); it++) {
if (i % *it == 0) {
e = false;
}
}
if (e == true) v.push_back(i);
}
int a, a2;
scanf("%d", &a);
for (it = v.begin(); it != v.end() && *it <= a / 2; it++) {
if (a % *it == 0) {
a2 = a - *it;
it2 = it;
}
}
for (it = v.begin(); it != v.end() && *it < a2; it++) {
sum = ((a2 / (*it)) + 1) * (*it);
if (sum <= a) {
if (mi == -1 || mi > a2 / (*it) * (*it)) {
mi = a2 / (*it) * (*it) + 1;
}
}
}
printf("%d", mi == -1 ? a2 + 1 : mi);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a, b;
a = (sqrt(9 + (8 * (n + k))) - 3) / 2;
b = n - a;
cout << b;
return 0;
}
| 2 |
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int a[200200], pos[200200];
int edge[200200];
const int MOD = 998244353;
ll pw(ll a, ll e){
if (!e) return 1;
ll ret = pw(a, e/2);
if (e&1) return (ret*ret%MOD)*a%MOD;
return ret*ret%MOD;
}
ll INV(ll x){
return pw(x, MOD-2);
}
int main(){
int n, k;
scanf("%d %d", &n, &k);
for (int i=0;i<n;i++){
scanf("%d", a+i);
pos[a[i]] = i;
}
fill(edge, edge+n-1, -1);
int cnt = 0;
if (pos[n-1]<n-1) edge[pos[n-1]] = 0, cnt++;
if (pos[n-1]>0) edge[pos[n-1]-1] = 1;
for (int i=n-2;i>=0;i--){
if (pos[i]<n-1 && edge[pos[i]]==-1){
if (pos[i+1] <= pos[a[pos[i]+1]+1])edge[pos[i]] = 0, cnt++;
else edge[pos[i]] = 1;
}
if (pos[i]>0 && edge[pos[i]-1]==-1){
if (pos[a[pos[i]-1]+1] <= pos[i+1]) edge[pos[i]-1] = 0, cnt++;
else edge[pos[i]-1] = 1;
}
//printf("%d: %d %d\n", i, edge[pos[i]], edge[pos[i]-1]);
}
//for (int i=0;i<n-1;i++) printf("%d ", edge[i]);
ll ans = 0;
vector<ll> ncr(n+1);
ncr[0] = 1;
for (int i=1;i<=n;i++){
ncr[i] = (ncr[i-1]*(k-i+1))%MOD;
ncr[i] = (ncr[i]*INV(i))%MOD;
}
ll ncr2 = 1;
for (int i=0;i<=cnt;i++){
if (i){
ncr2 = (ncr2*(cnt-i+1))%MOD;
ncr2 = (ncr2*INV(i))%MOD;
}
if (n-i>k) continue;
//printf("%lld %lld\n", ncr[n-i], ncr2);
ans = (ans+ncr[n-i]*ncr2)%MOD;
}
printf("%lld\n", ans);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n, vs[N];
long long res = INT_MIN;
vector<int> tr[N];
pair<long long, long long> dfs(int curr, int par) {
if (tr[curr].size() == 1 && tr[curr][0] == par) {
return {vs[curr], vs[curr]};
}
long long mx = INT_MIN, mx2 = INT_MIN, sm = vs[curr];
for (int& ch : tr[curr]) {
if (ch != par) {
pair<long long, long long> chres = dfs(ch, curr);
sm += chres.first;
if (chres.second >= mx) {
mx2 = mx;
mx = chres.second;
} else if (chres.second > mx2) {
mx2 = chres.second;
}
}
}
if (mx > INT_MIN && mx2 > INT_MIN) {
res = max(res, mx + mx2);
}
return {sm, max(sm, mx)};
}
int main() {
scanf("%d", &n);
for (int i = (1), _i = (n); i <= _i; ++i) {
scanf("%d", &vs[i]);
}
for (int i = (1), _i = (n - 1); i <= _i; ++i) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
tr[u].push_back(v);
tr[v].push_back(u);
}
dfs(1, 0);
if (res == INT_MIN) {
printf("Impossible");
} else {
cout << res;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
double p[20], dp[1 << 20], ans[20];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0, tmp = n; i < n; i++) {
scanf("%lf", p + i);
if (p[i] == 0.0) tmp--;
k = min(k, tmp);
}
dp[0] = 1.0;
for (int msk = 0; msk < (1 << n); msk++) {
double sum = 0;
int cnt = n;
bool ok = true;
for (int i = 0; i < n; i++) {
if (!(msk & (1 << i))) {
sum += p[i];
cnt--;
}
}
for (int i = 0; i < n; i++) {
if (!(msk & (1 << i)) && p[i] > 0.0) {
dp[msk | (1 << i)] += dp[msk] * (p[i] / sum);
} else if ((msk & (1 << i)) && cnt == k) {
ans[i] += dp[msk];
}
}
}
for (int i = 0; i < n; i++) printf("%.10f ", ans[i]);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n, a[3], b[3];
while (cin >> n) {
for (int i = 0; i < 3; ++i) {
cin >> a[i] >> b[i];
n -= a[i];
}
for (int i = 0; i < 3; ++i) {
int t = min(n, b[i] - a[i]);
a[i] += t;
n -= t;
}
for (int i = 0; i < 3; i++) {
if (i != 2)
cout << a[i] << ' ';
else
cout << a[i] << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string input;
cin >> input;
string str1 = input.substr(0, 2);
string str2 = input.substr(3, 2);
float minutes = stof(str2);
float hours = stof(str1);
if (minutes > 60) {
exit(0);
}
if (hours > 24) {
exit(0);
}
if (minutes >= 60) {
minutes -= 60;
}
if (hours >= 12) {
hours -= 12;
}
hours = (hours / 12) * 360;
hours += (((minutes / 60) * 360) / 12);
minutes = minutes * 6;
cout << hours << " " << minutes << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
list<long int> x, y, z;
for (int i = 0; i < t; i++) {
long int in;
cin >> in;
x.push_back(in);
}
x.sort();
for (int i = 0; i < t - 1; i++) {
long int in;
cin >> in;
y.push_back(in);
}
y.sort();
list<long int>::iterator i1 = x.begin(), i2 = y.begin();
while (*i1 == *i2 && i2 != y.end()) i1++, i2++;
cout << *i1 << endl;
for (int i = 0; i < t - 2; i++) {
long int in;
cin >> in;
z.push_back(in);
}
z.sort();
i1 = y.begin(), i2 = z.begin();
while (*i1 == *i2 && i2 != z.end()) i1++, i2++;
cout << *i1 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
vector<int> vc[200011];
map<int, int> id;
int A[200001], B[200011], cnt[200011], lft[200011];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
id.clear();
for (int i = (1); i < (n + 1); ++i) {
cin >> A[i];
id[A[i]] = 1;
vc[i].clear();
}
int cc = 0;
for (auto &v : id) v.second = ++cc;
vc[cc + 1].clear();
for (int i = (1); i < (cc + 2); ++i) B[i] = cnt[i] = lft[i] = 0;
for (int i = (1); i < (n + 1); ++i) {
A[i] = id[A[i]];
vc[A[i]].push_back(i);
}
int res = 0;
for (int i = cc; i >= 1; i--) {
res = max(res, (int)vc[i].size());
B[i] = vc[i].size();
if (i == cc) continue;
int k = 0;
for (int j = (0); j < (vc[i].size()); ++j) {
if (vc[i][j] < vc[i + 1][0]) res = max(res, j + 1 + B[i + 1]);
while (k < vc[i + 1].size() && vc[i + 1][k] < vc[i][j]) k++;
res = max(res, (int)vc[i + 1].size() - k + j + 1);
}
if (vc[i + 1][0] > vc[i][vc[i].size() - 1])
B[i] += B[i + 1];
else {
for (int k = (0); k < (vc[i + 1].size()); ++k)
if (vc[i + 1][k] > vc[i][vc[i].size() - 1]) B[i]++;
}
}
cout << n - res << endl;
}
}
| 13 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int gcd(int m, int n) { return n ? gcd(n, m % n) : m; }
int a[1005];
int b[1005];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < n; ++i) scanf("%d", &b[i]);
sort(a, a + n);
sort(b, b + n);
for (int i = 0; i < n; ++i) printf("%d ", a[i]);
cout << endl;
for (int i = 0; i < n; ++i) printf("%d ", b[i]);
cout << endl;
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 7;
const int BASE = 1 << 30;
const int INF = 1e9 + 7;
struct segment_tree {
vector<pair<int, int>> values;
vector<pair<int, int>> nxt;
vector<pair<int, int>> add;
int size;
segment_tree() {
size = -1;
newVertex();
}
void newVertex() {
++size;
values.push_back({0, -1});
nxt.push_back({-1, -1});
add.push_back({0, -1});
}
pair<int, int> best(pair<int, int> lhs, pair<int, int> rhs) {
if (lhs.first < rhs.first) return lhs;
return rhs;
}
void push(int v) {
int l = nxt[v].first;
int r = nxt[v].second;
if (l == -1) {
newVertex();
nxt[v].first = l = size;
}
if (r == -1) {
newVertex();
nxt[v].second = r = size;
}
values[l] = best(values[l], add[v]);
values[r] = best(values[r], add[v]);
add[l] = best(add[l], add[v]);
add[r] = best(add[r], add[v]);
add[v] = {INF, -1};
}
pair<int, int> minn(int l, int r, int v = 0, int b = 0, int e = BASE - 1) {
if (r < b || e < l) return {INF, -1};
if (l <= b && e <= r) return values[v];
push(v);
int mid = (b + e) / 2;
pair<int, int> lVal = minn(l, r, nxt[v].first, b, mid);
pair<int, int> rVal = minn(l, r, nxt[v].second, mid + 1, e);
values[v] = best(values[nxt[v].first], values[nxt[v].second]);
return best(lVal, rVal);
}
void change(int l, int r, pair<int, int> val, int v = 0, int b = 0,
int e = BASE - 1) {
if (r < b || e < l) return;
if (l <= b && e <= r) {
add[v] = val;
values[v] = val;
return;
}
push(v);
int mid = (b + e) / 2;
change(l, r, val, nxt[v].first, b, mid);
change(l, r, val, nxt[v].second, mid + 1, e);
values[v] = best(values[nxt[v].first], values[nxt[v].second]);
}
};
vector<pair<int, int>> segments[MAXN];
int dp[MAXN];
int prv[MAXN];
bool ok[MAXN];
void solve() {
segment_tree tree;
int n, m;
cin >> n >> m;
map<int, int> scaled;
vector<int> sorted;
for (int i = 1; i <= m; ++i) {
int h, l, r;
cin >> h >> l >> r;
segments[h].push_back({l, r});
sorted.push_back(l);
sorted.push_back(r);
}
sort(sorted.begin(), sorted.end());
int last = -1;
int cnt = 0;
for (int i = 0; i < sorted.size(); ++i) {
if (sorted[i] != last) {
scaled[sorted[i]] = ++cnt;
last = sorted[i];
}
}
for (int h = 1; h <= n; ++h) {
for (auto& [l, r] : segments[h]) {
l = scaled[l];
r = scaled[r];
}
}
for (int h = 1; h <= n; ++h) {
dp[h] = INF;
for (auto [l, r] : segments[h]) {
auto [val, ind] = tree.minn(l, r);
if (val + h - 1 < dp[h]) {
dp[h] = val + h - 1;
prv[h] = ind;
}
}
for (auto [l, r] : segments[h]) {
tree.change(l, r, {dp[h] - h, h});
}
}
auto [ans, ind] = tree.minn(0, BASE - 1);
cout << ans + n << '\n';
while (ind != 0) {
ok[ind] = true;
ind = prv[ind];
}
for (int i = 1; i <= n; ++i) {
if (!ok[i]) cout << i << ' ';
}
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int T;
T = 1;
while (T--) solve();
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
int p[1000005], r[1000005], h[1000005];
string s;
void fix_index(int *b, int *e) {
int pkm1, pk, np, i, d, m;
pkm1 = p[*b + t];
m = e - b;
d = 0;
np = b - r;
for (i = 0; i < m; i++) {
if (((pk = p[*b + t]) != pkm1) && !(np <= pkm1 && pk < np + m)) {
pkm1 = pk;
d = i;
}
p[*(b++)] = np + d;
}
}
bool comp(int i, int j) { return p[i + t] < p[j + t]; }
void suff_arr() {
int i, j, bc[256];
t = 1;
for (i = 0; i < 256; i++) bc[i] = 0;
for (i = 0; i < n; i++) ++bc[int(s[i])];
for (i = 1; i < 256; i++) bc[i] += bc[i - 1];
for (i = 0; i < n; i++) r[--bc[int(s[i])]] = i;
for (i = n - 1; i >= 0; i--) p[i] = bc[int(s[i])];
for (t = 1; t < n; t *= 2) {
for (i = 0, j = 1; i < n; i = j++) {
while (j < n && p[r[j]] == p[r[i]]) ++j;
if (j - i > 1) {
sort(r + i, r + j, comp);
fix_index(r + i, r + j);
}
}
}
}
void lcp() {
int tam = 0, i, j;
for (i = 0; i < n; i++)
if (p[i] > 0) {
j = r[p[i] - 1];
while (s[i + tam] == s[j + tam]) ++tam;
h[p[i] - 1] = tam;
if (tam > 0) --tam;
}
h[n - 1] = 0;
}
int k;
long long qnts[26];
int main(void) {
cin >> s >> k;
s += '$';
n = s.size();
suff_arr();
int ini = 1, fim = n - 1;
int dig = 0;
string ans = "";
if ((long long)((long long)(n) * (long long)(n - 1)) / 2 < k) {
printf("No such line.\n");
return 0;
}
while (1) {
memset(qnts, 0, sizeof qnts);
for (int i = ini; i < fim + 1; i++)
if (r[i] + dig < n - 1) {
qnts[s[r[i] + dig] - 'a'] += (n - (r[i] + dig) - 1);
}
int letra = 0;
for (int i = 0; i < 26; i++) {
if (qnts[i] < k) {
k -= qnts[i];
} else {
letra = i;
break;
}
}
ans += letra + 'a';
int c = -1, t = -1;
for (int i = ini; i < fim + 1; i++)
if (r[i] + dig < n) {
if (s[r[i] + dig] - 'a' == letra) {
if (c == -1) c = i;
t = i;
}
}
ini = c, fim = t;
if (fim - ini + 1 >= k)
break;
else
k -= (fim - ini + 1);
dig++;
}
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int N;
int ans0, ans1;
void binary() {
int l = 1, r = N, c1 = 0, c0 = 0, pls = 0;
putchar('?');
putchar(' ');
for (int i = 1; i <= N; i++) putchar('0');
putchar('\n');
fflush(stdout);
scanf("%d", &c1);
c0 = N - c1;
while (l <= r) {
int m = (l + r) >> 1;
putchar('?');
putchar(' ');
for (int i = 1; i <= m; i++) putchar('0');
for (int i = m + 1; i <= r; i++) putchar('1');
for (int i = r + 1; i <= N; i++) putchar('0');
putchar('\n');
fflush(stdout);
int r1 = 0, r0 = 0, l1 = 0, l0 = 0, x;
scanf("%d", &x);
x -= pls;
r1 = (r - m + c1 - x) / 2;
r0 = r - m - r1;
l1 = c1 - r1;
l0 = c0 - r0;
if (r1 && r0) {
l = m + 1;
c1 = r1;
c0 = r0;
pls += l1;
} else if (l1 && l0) {
r = m;
c1 = l1;
c0 = l0;
pls += r1;
} else {
if (l1) ans1 = l;
if (l0) ans0 = l;
if (r1) ans1 = r;
if (r0) ans0 = r;
if (ans1 && ans0) return;
}
}
}
int main() {
scanf("%d", &N);
binary();
printf("! %d %d\n", ans0, ans1);
fflush(stdout);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long a, b;
cin >> a >> b;
long long ans = 0;
while (b > 0) {
ans += a / b;
a %= b;
swap(a, b);
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110000;
char str[MAXN];
int cnt;
bool gender[2];
int adj, noun, verb;
inline int ID(char str[]) {
int len = strlen(str);
char tmp[MAXN];
if (len >= 6) {
strcpy(tmp, str + len - 6);
if (0 == strcmp(tmp, "initis")) return 5;
if (0 == strcmp(tmp, "inites")) return 6;
}
if (len >= 5) {
strcpy(tmp, str + len - 5);
if (0 == strcmp(tmp, "liala")) return 2;
}
if (len >= 4) {
strcpy(tmp, str + len - 4);
if (0 == strcmp(tmp, "lios")) return 1;
if (0 == strcmp(tmp, "etra")) return 4;
}
if (len >= 3) {
strcpy(tmp, str + len - 3);
if (0 == strcmp(tmp, "etr")) return 3;
}
return -1;
}
int main() {
while (scanf("%s", str) != EOF) {
cnt++;
int id = ID(str);
if (-1 == id) {
puts("NO");
return 0;
}
switch (id) {
case 1: {
gender[0] = true;
if (gender[1]) {
puts("NO");
return 0;
}
adj++;
if (noun || verb) {
puts("NO");
return 0;
}
break;
}
case 2: {
gender[1] = true;
if (gender[0]) {
puts("NO");
return 0;
}
adj++;
if (noun || verb) {
puts("NO");
return 0;
}
break;
}
case 3: {
gender[0] = true;
if (gender[1]) {
puts("NO");
return 0;
}
if (noun) {
puts("NO");
return 0;
}
noun++;
if (verb) {
puts("NO");
return 0;
}
break;
}
case 4: {
gender[1] = true;
if (gender[0]) {
puts("NO");
return 0;
}
if (noun) {
puts("NO");
return 0;
}
noun++;
if (verb) {
puts("NO");
return 0;
}
break;
}
case 5: {
gender[0] = true;
if (gender[1]) {
puts("NO");
return 0;
}
verb++;
break;
}
case 6: {
gender[1] = true;
if (gender[0]) {
puts("NO");
return 0;
}
verb++;
break;
}
}
}
if (cnt > 1 && !noun) {
puts("NO");
return 0;
}
puts("YES");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int N = 1e5 + 5e4 + 2;
const int inf = 2e9;
const long long linf = 4e18;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
int n, k;
cin >> n >> k;
vector<int> alice, bob, common;
for (int i = 0; i < n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a && b)
common.push_back(t);
else if (a)
alice.push_back(t);
else if (b)
bob.push_back(t);
}
sort(alice.begin(), alice.end());
sort(bob.begin(), bob.end());
priority_queue<int, vector<int>, greater<int>> q;
for (int i = 0; i < common.size(); i++) q.push(common[i]);
for (int i = 0; i < min(alice.size(), bob.size()); i++)
q.push(alice[i] + bob[i]);
if (q.size() < k) {
cout << -1;
return 0;
}
int ans = 0;
while (k--) {
ans += q.top();
q.pop();
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int cnt[N];
vector<int> f, s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int flag = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
cnt[x]++;
if (cnt[x] == 1)
f.push_back(x);
else if (cnt[x] == 2)
s.push_back(x);
else
flag = 1;
}
if (flag)
cout << "NO" << endl;
else {
cout << "YES" << endl;
sort(f.begin(), f.end());
cout << f.size() << endl;
for (int i = 0; i < f.size(); i++) cout << f[i] << " ";
cout << endl;
sort(s.begin(), s.end(), greater<int>());
cout << s.size() << endl;
for (int i = 0; i < s.size(); i++) cout << s[i] << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool debug = false;
int k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
vector<pair<long long, long long>> v;
set<pair<long long, long long>> ans;
long long cx, cy;
int c;
bool ck(int i, int j) {
pair<long long, long long> pp = {cx, cy};
for (; i <= j;) {
pair<long long, long long> t = {v[i].first + v[j].first,
v[i].second + v[j].second};
if (pp == t) {
i++;
j--;
continue;
}
c++;
if (c > k) return 0;
if (t > pp)
j--;
else
i++;
}
return 1;
}
int main() {
scanf("%d%d", &n, &k);
if (n <= k) {
puts("-1");
return 0;
}
for (int i = 0, x, y; i < n; i++) {
scanf("%d%d", &x, &y);
v.push_back({x, y});
}
sort(v.begin(), v.end());
for (int i = 0; i < k + 1; i++) {
for (int j = n - 1; j > n - 1 - k - 1; j--)
if (i <= j) {
cx = v[i].first + v[j].first;
cy = v[i].second + v[j].second;
c = 0;
if (c <= k && ck(0, n - 1)) {
ans.insert({cx, cy});
}
}
}
printf("%d\n", ans.size());
for (auto x : ans) printf("%lf %lf\n", x.first * 0.5, x.second * 0.5);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
bool vowel(char a) {
a = toupper(a);
if ((a == 'A') || (a == 'E') || (a == 'I') || (a == 'O') || (a == 'U'))
return 1;
return 0;
}
long long int n, m, q, a, p, b, c, sum = 0, cnt = 0;
long long int arr[123456];
map<long long int, bool> mp;
string str;
int main() {
cin >> a >> b >> n;
if (a < 0) a *= -1;
if (b < 0) b *= -1;
if ((n == a + b) || ((n > a + b) && ((n - (a + b)) % 2 == 0)))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, u, v, vis[502], tim[100005], ttm, root;
vector<long long> adj[502];
vector<pair<long long, long long> > cycle;
pair<long long, long long> p;
bool cy = false, fn = false;
void dfs(long long node) {
if (vis[node] == 2 || cy) return;
if (vis[node] == 1) {
cy = true;
root = node;
return;
}
vis[node] = 1;
for (auto x : adj[node]) dfs(x);
if (!cy) vis[node] = 2;
}
void dfs2(long long node) {
if (vis[node] == 2 || cy) return;
if (vis[node] == 1) {
cy = true;
root = node;
return;
}
vis[node] = 1;
for (auto x : adj[node]) {
pair<long long, long long> tmp = {node, x};
if (p == tmp) continue;
dfs2(x);
}
if (!cy) vis[node] = 2;
}
void print(long long node) {
if (node == root && cycle.size()) {
fn = true;
return;
}
for (auto x : adj[node]) {
if (fn) return;
if (vis[x] != 1) continue;
cycle.push_back({node, x});
if (fn) return;
print(x);
}
}
bool check() {
memset(vis, 0, sizeof(vis));
cy = false;
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs2(i);
if (cy == false)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
adj[u].push_back(v);
}
for (long long i = 1; i <= n; i++) {
if (vis[i]) continue;
dfs(i);
if (root != 0) break;
}
print(root);
if (!cycle.size()) {
cout << "YES" << endl;
return 0;
}
for (auto x : cycle) {
p = x;
if (check()) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1024;
int n, k;
long long l, r;
double dp[MAXN][MAXN];
inline double getP(long long l, long long r) {
long long cnt = 0, p = 1, tl, tr;
while (p <= r) {
tl = p;
tr = p * 2 - 1;
tl = max(tl, l);
tr = min(tr, r);
if (tl <= tr) cnt += tr - tl + 1;
if (p > r / 10) break;
p *= 10;
}
return 1.0 * cnt / (r - l + 1);
}
int main() {
while (cin >> n) {
for (int i = 0; i <= n; ++i) memset(dp[i], 0, sizeof(dp[0][0]) * (n + 1));
dp[0][0] = 1.0;
for (int i = 1; i <= n; ++i) {
cin >> l >> r;
double p = getP(l, r);
for (int j = 0; j <= i; ++j) {
if (j > 0) dp[i][j] += p * dp[i - 1][j - 1];
dp[i][j] += (1.0 - p) * dp[i - 1][j];
}
}
cin >> k;
double ans = 0.0;
for (int j = 0; j <= n; ++j) {
if (j * 100 >= k * n) ans += dp[n][j];
}
printf("%.10lf\n", ans);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500;
int n, m, k, o, t, l, ll, ans;
int x[2];
char s[maxn];
string st, sm;
bool flag;
int main() {
scanf("%d\n", &n);
l = 100000;
ans = 0;
ll = 0;
for (int i = 0; i < n; i++) {
gets(s);
st = s;
x[0] = x[1] = o = t = 0;
sm = "";
flag = false;
for (int j = 0; st[j] != ']'; j++) {
if (st[j] == ':') o++;
if (o < 2 && '0' <= st[j] && st[j] <= '9') x[o] = x[o] * 10 + st[j] - '0';
if (st[j] == 'p') t = 720;
if (st[j] == 'a' || st[j] == 'p') o++;
}
if (x[0] == 12) x[0] = 0;
t += (x[0] - 1) * 60 + x[1];
if (l > t || l == t && ll == 10) {
flag = true;
ans++;
}
if (flag) ll = 1;
if (!flag && l == t) ll++;
if (!flag && l < t) ll = 1;
l = t;
}
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e5 + 7;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
long long n, inp[MAX];
cin >> n;
for (long long i = 0; i < n; i++) cin >> inp[i];
long long curmin = 1e18, mins[MAX];
for (long long i = n - 1; i >= 0; i--)
curmin = min(curmin, inp[i]), mins[i] = curmin;
for (long long i = 0; i < n; i++) {
long long lo = i + 1, hi = n - 1, mid;
while (lo <= hi) {
mid = (lo + hi) >> 1;
if (mins[mid] < inp[i])
lo = mid + 1;
else
hi = mid - 1;
}
cout << (lo - 1) - i - 1;
(i == n - 1) ? cout << '\n' : cout << ' ';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
using namespace ::std;
const int maxn = 1e5 + 500;
const int inf = 1e9 + 800;
const int mod = 1e9 + 7;
map<pair<string, int>, pair<string, long long> > ml;
pair<string, long long> KojChej(string sn, const int y) {
string rn = sn;
if (ml.count(make_pair(sn, y)) != 0) {
return ml[make_pair(sn, y)];
}
if (sn.size() == 1) {
int n = sn[0] - '0';
int res = 0;
while (n >= 0 && (n != 0 || y != 0)) {
res++;
n -= max((int)n, y);
}
if (n < 0) n += 10;
sn[0] = n + '0';
ml[make_pair(rn, y)] = make_pair(sn, res);
return make_pair(sn, res);
}
int a = sn[0] - '0';
string b = sn.substr(1, sn.size() - 1);
long long ans = 0;
for (int i = a; i >= 0; i--) {
pair<string, long long> p = KojChej(b, max(i, y));
ans += p.second;
b = p.first;
}
sn = "9" + b;
ml[make_pair(rn, y)] = make_pair(sn, ans);
return make_pair(sn, ans);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string n;
cin >> n;
cout << KojChej(n, 0).second;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[100010];
int32_t main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
long long ans = 1e9;
for (long long i = 1; i <= n; i++) {
long long cnt = 0;
for (long long j = 1; j <= n; j++) {
long long temp = a[j] * (abs(i - j) + abs(j - 1) + abs(i - 1) +
abs(1 - i) + abs(1 - j) + abs(j - i));
cnt += temp;
}
ans = min(ans, cnt);
}
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[200100], pos;
long long ans;
map<int, int> cnt;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == m) pos = i;
}
int x = 0, y = 0;
cnt[0]++;
for (int i = pos - 1; i >= 1; i--) {
if (a[i] > m)
x++;
else
y++;
cnt[x - y]++;
}
int bal = 0;
ans += cnt[0];
for (int i = pos + 1; i <= n; i++) {
if (a[i] > m)
bal++;
else
bal--;
ans += cnt[-bal];
}
bal = 0;
ans += cnt[1];
for (int i = pos + 1; i <= n; i++) {
if (a[i] > m)
bal++;
else
bal--;
ans += cnt[-bal + 1];
}
cout << ans << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000000 + 7;
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long powe(long long x, long long y) {
x = x % mod, y = y % (mod - 1);
long long ans = 1;
while (y > 0) {
if (y & 1) {
ans = (1ll * x * ans) % mod;
}
y >>= 1;
x = (1ll * x * x) % mod;
}
return ans;
}
void fun() {}
long long ncr(long long n, long long r) {
long long res = 1;
if (r > n) return 0;
if (r > n - r) r = n - r;
for (long long i = 0; i < r; i++) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
fun();
long long ttt = 1;
while (ttt--) {
string s, t;
cin >> s >> t;
set<long long> st;
long long n = s.length(), m = t.length();
long long h[26] = {0}, k[26] = {0};
for (long long i = 0; i < n; i++) h[s[i] - 'a']++;
for (long long i = 0; i < m; i++) k[t[i] - 'a']++;
for (long long i = 0; i < 26; i++)
if ((h[i] == 0 and k[i] > 0) or (h[i] < k[i])) return cout << 0, 0;
long long i = 0, j = 0;
s = s + '$';
set<char> sett;
for (; i < n;) {
if (s[i] != t[j]) {
st.insert(i);
sett.insert(s[i]);
long long k = i;
while (s[k] == s[k - 1]) {
st.insert(k - 1);
k--;
}
i++;
} else
i++, j++;
if (i >= n) break;
}
if (sett.size() != 1) return cout << 0, 0;
cout << st.size() << "\n";
for (long long i : st) cout << i + 1 << ' ';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
namespace thecold {
inline int read() {
int res = 0;
bool flag = false;
char c = getchar();
while (!isdigit(c)) flag = (c == '-'), c = getchar();
while (isdigit(c)) res = res * 10 + (c ^ 48), c = getchar();
return !flag ? res : -res;
}
const int Max_n = 1e5 + 30;
const int base = 131;
struct node {
int nex, to, val;
node(int a, int b, int c) { nex = a, to = b, val = c; }
node() {}
} edge[Max_n << 1];
int head[Max_n], tot, pre[Max_n], s, t, n, m;
unsigned long long mi[Max_n];
inline void add_edge(const int x, const int y, const int z) {
edge[++tot] = node(head[x], y, z), head[x] = tot;
edge[++tot] = node(head[y], x, z), head[y] = tot;
}
const int Max_m = 1e7 + 5;
int root[Max_m], cnt, son[Max_m][2];
unsigned long long val[Max_m];
inline void push_up(const int now) {
val[now] = val[son[now][0]] + val[son[now][1]];
}
void build(int &now, const int l, const int r, const int va) {
now = ++cnt;
if (l == r) return val[now] = mi[l] * va, void();
int mid = (l + r) >> 1;
build(son[now][0], l, mid, va), build(son[now][1], mid + 1, r, va);
push_up(now);
}
const int Max_l = 1e5 + 20;
void change(int &now, const int lst, const int l, const int r, const int ql,
const int qr, const int one, const int zero) {
if (l > qr || r < ql) return now = lst, void();
int mid = (l + r) >> 1;
if (ql <= l && r <= qr) {
if (ql == l) {
if (l == r) return now = one, void();
now = ++cnt;
change(son[now][0], son[lst][0], l, mid, ql, qr, son[one][0],
son[zero][0]);
change(son[now][1], son[lst][1], mid + 1, r, ql, qr, son[one][1],
son[zero][1]);
return push_up(now);
}
return now = zero, void();
}
now = ++cnt;
change(son[now][0], son[lst][0], l, mid, ql, qr, son[one][0], son[zero][0]);
change(son[now][1], son[lst][1], mid + 1, r, ql, qr, son[one][1],
son[zero][1]);
push_up(now);
}
bool cmp(const int now, const int lst, const int l, const int r) {
if (val[now] == val[lst]) return false;
if (l == r) return val[now] > val[lst];
int mid = (l + r) >> 1;
if (val[son[now][0]] != val[son[lst][0]])
return cmp(son[now][0], son[lst][0], l, mid);
return cmp(son[now][1], son[lst][1], mid + 1, r);
}
const int jzp = 1e9 + 7;
inline int add(const int x, const int y) {
int ret = x + y;
if (ret >= jzp) ret -= jzp;
return ret;
}
int m2[Max_n];
int calc(const int now, const int l, const int r) {
if (!val[now]) return 0;
if (l == r) return m2[Max_l - l];
int mid = (l + r) >> 1;
return add(calc(son[now][0], l, mid), calc(son[now][1], mid + 1, r));
}
struct God {
int id, rt;
God(int a, int b) { id = a, rt = b; }
God() {}
inline bool operator<(const God &a) const { return cmp(rt, a.rt, 0, Max_l); }
};
priority_queue<God> zzz;
bool vis[Max_n];
int query(const int now, const int l, const int r, const int beg,
const int one) {
if (!val[now]) return beg;
if (val[now] == val[one]) return l - 1;
if (l == r) return val[now] ? beg - 1 : beg;
int mid = (l + r) >> 1;
if (r != beg) {
if (mid >= beg) return query(son[now][0], l, mid, beg, son[one][0]);
int ret = query(son[now][1], mid + 1, r, beg, son[one][1]);
if (ret == mid) return query(son[now][0], l, mid, mid, son[one][0]);
return ret;
}
int ret = query(son[now][1], mid + 1, r, beg, son[one][1]);
if (ret == mid) return query(son[now][0], l, mid, mid, son[one][0]);
return ret;
}
int used = 1, dis[Max_n];
inline void dijie() {
zzz.push(God(s, root[0]));
while (!zzz.empty()) {
int now = zzz.top().id;
zzz.pop();
if (vis[now]) continue;
vis[now] = true;
for (int i = head[now]; i; i = edge[i].nex) {
int nex = edge[i].to, va = Max_l - edge[i].val;
if (vis[nex]) continue;
int lim = query(dis[now], 0, Max_l, va, root[1]);
change(root[++used], dis[now], 0, Max_l, lim, va, root[1], root[0]);
if (cmp(root[used], dis[nex], 0, Max_l)) continue;
dis[nex] = root[used], pre[nex] = now;
zzz.push(God(nex, dis[nex]));
}
}
}
int st[Max_n], tp;
inline void main() {
mi[0] = m2[0] = 1;
for (int i = 1; i <= 1e5 + 20; ++i)
mi[i] = mi[i - 1] * base, m2[i] = 2ll * m2[i - 1] % jzp;
n = read(), m = read();
for (int i = 1; i <= m; ++i) {
int ui = read(), vi = read(), ti = read();
add_edge(ui, vi, ti);
}
s = read(), t = read();
build(root[0], 0, Max_l, 0), build(root[1], 0, Max_l, 1);
for (int i = 1; i <= n; ++i) dis[i] = root[1];
dis[s] = root[0];
dijie();
if (!vis[t]) return puts("-1"), void();
printf("%d\n", calc(dis[t], 0, Max_l));
int now = t;
while (now != s) st[++tp] = now, now = pre[now];
st[++tp] = s;
printf("%d\n", tp);
while (tp) printf("%d ", st[tp--]);
}
} // namespace thecold
int main() {
thecold::main();
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
long long mo = 1e9 + 7;
long long poi[10001], F[10001], nxt[10001], dep[1001], f[1001][1001], tmp[1001],
ans, n, k, x, y, cnt;
bool vis[1001];
inline void add(long long x, long long y) {
poi[++cnt] = y;
nxt[cnt] = F[x];
F[x] = cnt;
}
inline void dfs(long long x) {
vis[x] = 1;
f[x][0] = 1;
f[x][k + 1] = 1;
for (long long i = F[x]; i; i = nxt[i]) {
long long ne = poi[i];
if (vis[ne]) continue;
dep[ne] = dep[x] + 1;
dfs(ne);
for (long long j = 0; j <= 2 * k; j++) tmp[j] = 0;
for (long long j = 0; j <= 2 * k; j++)
for (long long t = 0; t <= 2 * k + 1; t++) {
if (j + t <= 2 * k)
tmp[min(j, t + 1)] += f[x][j] * f[ne][t], tmp[min(j, t + 1)] %= mo;
else
tmp[max(j, t + 1)] += f[x][j] * f[ne][t], tmp[max(j, t + 1)] %= mo;
}
for (long long j = 0; j <= 2 * k; j++) f[x][j] = tmp[j];
}
}
int main() {
scanf("%lld %lld", &n, &k);
if (k == 0) return puts("1") & 0;
for (long long i = 1; i <= n - 1; i++) {
scanf("%lld %lld", &x, &y);
add(x, y);
add(y, x);
}
dfs(1);
for (long long i = 0; i <= k; i++) ans += f[1][i], ans %= mo;
printf("%lld", ans);
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
inline int setBit(int N, int pos) { return N = N | (1 << pos); }
inline int resetBit(int N, int pos) { return N = N & ~(1 << pos); }
inline bool checkBit(int N, int pos) { return (bool)(N & (1 << pos)); }
int main() {
int k;
scanf("%d", &k);
int n, m = -1;
n = 5;
while (n < k) {
if (k % n == 0) {
m = k / n;
break;
}
n++;
}
if (m < 5) {
cout << -1 << endl;
return 0;
}
int x;
char v[] = {'a', 'e', 'i', 'o', 'u'};
for (int i = 0; i < n; i++) {
x = i % 5;
for (int j = x; j < m + x; j++) {
cout << v[j % 5];
}
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400010;
pair<int, int> a[maxn], b[maxn];
int tot, cnt[110];
double qpow(double a, int x) {
double res = 1.0;
while (x) {
if (x & 1) res = res * a;
a = a * a;
x >>= 1;
}
return res;
}
int main() {
int N, M, i, j, A, H, L, R;
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%d%d%d%d", &A, &H, &L, &R);
b[++tot] = make_pair(A - H, L);
b[++tot] = make_pair(A, -L);
b[++tot] = make_pair(A + 1, R);
b[++tot] = make_pair(A + H + 1, -R);
}
for (int i = 1; i <= M; i++) scanf("%d%d", &a[i].first, &a[i].second);
sort(a + 1, a + M + 1);
sort(b + 1, b + tot + 1);
double ans = 0;
int pos = 1;
for (int i = 1; i <= M; i++) {
while (pos <= tot && b[pos].first <= a[i].first) {
if (b[pos].second > 0) cnt[b[pos].second]++;
if (b[pos].second < 0) cnt[-b[pos].second]--;
pos++;
}
double p = a[i].second;
for (int j = 1; j <= 100; j++) p *= qpow(0.01 * (100 - j), cnt[j]);
ans += p;
}
printf("%.12lf\n", ans);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n, q;
long long a, b;
vector<long long> c, v;
const long long inf = 1LL << 62;
void init() {
cin >> n >> q;
c.clear();
v.clear();
c.resize(n);
v.resize(n);
for (int i = 0; i < n; i++) cin >> v[i];
for (int i = 0; i < n; i++) cin >> c[i];
}
long long memo[MAXN];
bool vis[MAXN];
long long solve() {
long long ans = -inf;
vector<long long> best2(2, -1);
for (int i = 0; i < MAXN; i++) memo[i] = -inf, vis[i] = 0;
for (int i = 0; i < n; i++) {
long long v1 = v[i] * b;
if (!vis[c[i]]) {
vis[c[i]] = 1;
long long Obest = -inf;
for (int k = 0; k < 2; k++)
if (best2[k] != -1 && best2[k] != c[i])
Obest = max(Obest, memo[best2[k]]);
v1 = max(v1, v1 + Obest);
memo[c[i]] = v1;
goto hl;
}
{
long long v2 = memo[c[i]] + v[i] * a;
long long Obest = -inf;
for (int k = 0; k < 2; k++)
if (best2[k] != -1 && best2[k] != c[i])
Obest = max(Obest, memo[best2[k]]);
v1 = max(v1, v1 + Obest);
memo[c[i]] = max(memo[c[i]], max(v1, v2));
}
hl:;
ans = max(ans, memo[c[i]]);
bool ok = 1;
for (int k = 0; k < 2; k++)
if (best2[k] == c[i]) ok = 0;
if (best2[1] == -1)
swap(best2[1], best2[0]);
else if (best2[0] != -1 && memo[best2[0]] > memo[best2[1]])
swap(best2[1], best2[0]);
if (ok)
for (int k = 0; k < 2; k++)
if (best2[k] == -1 || memo[c[i]] > memo[best2[k]]) {
best2[k] = c[i];
break;
}
}
return ans;
}
int main() {
init();
while (q--) {
cin >> a >> b;
cout << max(0LL, solve()) << endl;
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int nn = 100005;
const double eps = 1e-10;
struct point {
double x, y;
} a[nn], b[nn];
int n, m, t, l[nn], r[nn];
int h[nn], p[nn];
double R, c[nn];
inline double cp(const point &x, const point &y, const point &z) {
return (x.x - z.x) * (y.y - z.y) - (x.y - z.y) * (y.x - z.x);
}
inline double dis(const point &x, const point &y) {
return sqrt((x.x - y.x) * (x.x - y.x) + (x.y - y.y) * (x.y - y.y));
}
inline bool cmp(const point &x, const point &y) {
double z = cp(x, y, a[1]);
if (z > eps) return 1;
if (z < -eps) return 0;
return dis(x, a[1]) < dis(y, a[1]);
}
void init() {
scanf("%d%lf", &n, &R);
for (int i = 1; i <= n; ++i) {
scanf("%lf%lf", &a[i].x, &a[i].y);
if (a[i].y < a[1].y || (a[i].y < a[1].y + eps && a[i].x < a[1].x))
swap(a[i], a[1]);
}
sort(a + 2, a + n + 1, cmp);
b[m = 1] = a[1];
for (int i = 2; i <= n; ++i) {
for (; m > 1 && cp(a[i], b[m], b[m - 1]) > -eps; --m)
;
b[++m] = a[i];
}
}
inline void change(int x, int y) {
swap(p[h[x]], p[h[y]]);
swap(h[x], h[y]);
}
void up(int x) {
for (; x > 1 && c[h[x]] > c[h[x >> 1]]; x >>= 1) change(x, x >> 1);
}
void down(int x) {
for (int y = x << 1; y <= t; x = y, y = x << 1) {
if (y < t && c[h[y]] < c[h[y + 1]]) ++y;
if (c[h[x]] < c[h[y]])
change(x, y);
else
break;
}
}
inline void calc(int x) {
point y = b[l[x]], z = b[r[x]];
c[x] = dis(y, z) * dis(b[x], y) * dis(b[x], z) / (2 * abs(cp(y, z, b[x])));
up(p[x]);
}
inline double count(int x, int y) {
double z = 2 * asin(dis(b[x], b[y]) / (2 * R));
return R * R / 2 * (z - sin(z));
}
void work() {
for (int i = 1; i <= m; ++i) {
h[i] = p[i] = i;
l[i] = i - 1, r[i] = i + 1;
}
t = m;
l[1] = m;
r[m] = 1;
for (int i = 1; i <= m; ++i) calc(i);
while (c[h[1]] > R) {
int i = h[1];
l[r[i]] = l[i];
r[l[i]] = r[i];
change(1, t--);
down(1);
calc(l[i]);
calc(r[i]);
}
int j = h[1];
double s = count(j, l[j]) + count(j, r[j]);
for (int i = r[j]; r[i] != j; i = r[i])
s += abs(cp(b[i], b[r[i]], b[j])) / 2 + count(i, r[i]);
printf("%.10lf\n", s);
}
int main() {
init();
work();
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
long long int T = 1, inf = 10000000000;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
while (T--) {
long long int n, sz, ans = 0, blag = 0, u, mn, ev = 0, mx, mini, i, v, q, p,
j, k, w, h, l, m, x, y, od = 0, total = 0, cc = 0,
pp = 0, flag = 0, klag = 0, sum = 0;
string s, s1 = "YES", s2 = "NO";
bool ok = 0;
n = 11;
cin >> s;
if (stoll(s, nullptr, 10) <= 9) {
cout << s;
break;
}
sz = s.size();
string s3(sz - 1, '9');
s3 = '0' + s3;
for (i = 1; i < 10; i++) {
s3[0]++;
if (s3 > s) {
for (j = sz - 1; j > 0; j--) {
s3[j]--;
if (s3 <= s) {
flag = 1;
break;
} else {
s3[j]++;
}
}
if (flag == 0) {
s3[0]--;
}
break;
}
}
if (s3[0] == '0') {
s3.erase(0, 1);
}
cout << s3 << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int N = 4e5 + 54;
int n, m, l, c, x, a[N], a1, a2, a3, f, sum;
int main() {
for (scanf("%*d"); ~scanf("%d", &m);) {
n = -1, l = c = a1 = a2 = a3 = 0, f = 1;
for (int i = 1; i <= m; i++, c++) {
scanf("%d", &x);
if (x != l) a[++n] = c, l = x, c = 0;
}
a[++n] = c;
sum = a[1];
a1 = a[1];
for (int i = 2; i <= n; i++) {
if ((sum += a[i]) > m / 2) break;
(f ? a2 : a3) += a[i];
if (f && a2 > a1) f = 0;
}
if (a1 && a2 && a3 && a1 < a2 && a1 < a3)
printf("%d %d %d\n", a1, a2, a3);
else
puts("0 0 0");
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int Min = 105;
for (int i = 1; i <= n; i++) {
if (k >= a[i] && a[i]) Min = min(Min, abs(i - m));
}
cout << Min * 10 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v[100005];
long long int n;
vector<long long int> ed;
long long int dfs(long long int i, long long int p) {
long long int sum = 1;
for (long long int j = 0; j < v[i].size(); ++j) {
long long int node = v[i][j];
if (node == p) continue;
long long int tot = dfs(node, i);
sum += tot;
ed.push_back(tot * (n - tot));
}
return sum;
}
void solve() {
cin >> n;
for (long long int i = 1; i < n + 1; ++i) v[i].clear();
for (long long int i = 0; i < n - 1; ++i) {
long long int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
long long int m;
cin >> m;
vector<long long int> prime;
for (long long int i = 0; i < m; ++i) {
long long int x;
cin >> x;
prime.push_back(x);
}
ed.clear();
long long int sum = dfs(1, 0);
sort(prime.begin(), prime.end());
sort(ed.begin(), ed.end());
if (m > (n - 1)) {
vector<long long int> temp;
for (long long int i = 0; i < n - 2; ++i) {
temp.push_back(prime[i]);
}
long long int pw = 1;
for (long long int i = n - 2; i < m; ++i) pw = (pw * prime[i]) % 1000000007;
temp.push_back(pw);
prime = temp;
} else if (m < n - 1) {
long long int diff = n - 1 - m;
for (long long int i = 0; i < diff; ++i) prime.push_back(1);
sort(prime.begin(), prime.end());
}
long long int ans = 0;
for (long long int i = 0; i < n - 1; ++i) {
ed[i] = (ed[i]) % 1000000007;
long long int temp = (prime[i] * (ed[i])) % 1000000007;
ans = (ans + temp) % 1000000007;
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
solve();
}
return (0);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, m;
cin >> n >> m;
bool *stat = new bool[n + 1];
for (long i = 0; i < n + 1; i++) stat[i] = false;
map<long, long> *amel = new map<long, long>[n + 1];
long sq;
for (long i = 0; i < m; i++) {
long req;
char sign;
cin >> sign >> req;
int org_req = req;
if (sign == '-' && stat[req]) {
stat[req] = false;
sq = (long)sqrt(req);
for (long d = 2; d < sq + 1; d++)
if (req % d == 0) {
amel[d].erase(org_req);
while (req % d == 0) req = req / d;
}
if (req != 1) amel[req].erase(org_req);
cout << "Success" << endl;
continue;
}
if (sign == '-' && !stat[req]) {
cout << "Already off" << endl;
continue;
}
if (sign == '+' && stat[req]) {
cout << "Already on" << endl;
continue;
}
if (req == 1) {
stat[1] = true;
cout << "Success" << endl;
continue;
}
bool is_d = false;
sq = (long)sqrt(req);
for (long d = 2; d < sq + 1; d++) {
if (req % d == 0) {
while (req % d == 0) req = req / d;
if (!(amel[d].empty())) {
is_d = true;
cout << "Conflict with " << (*(amel[d].begin())).first << endl;
break;
}
}
}
if (!is_d)
if (req != 1)
if (!(amel[req].empty())) {
is_d = true;
cout << "Conflict with " << (*(amel[req].begin())).first << endl;
}
if (!is_d) {
cout << "Success" << endl;
req = org_req;
stat[org_req] = true;
for (long d = 2; d < sq + 1; d++)
if (req % d == 0) {
amel[d][org_req] = org_req;
while (req % d == 0) req = req / d;
}
if (req != 1) amel[req][org_req] = org_req;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct Problem {
int score1, score2, time1, time2;
double fail, ratio;
long long int s1, s2;
bool operator<(const Problem& T) const { return ratio < T.ratio; }
} P[2005];
long long int dp[2005][2005], MX_score, score, tmp;
double MN_penal, E[2005][2005], penal;
int n, m;
void Update(int x, int y, long long int S, double P) {
if (y > m) return;
if (dp[x][y] < S || (dp[x][y] == S && E[x][y] > P)) {
dp[x][y] = S;
E[x][y] = P;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (0); i < (n); i++) {
scanf("%d%d%d%d%lf", &P[i].score1, &P[i].score2, &P[i].time1, &P[i].time2,
&P[i].fail);
tmp = (int)(P[i].fail * 1000000 + 0.5);
P[i].s1 = (long long int)(P[i].score1) * 1000000;
P[i].s2 = (long long int)(P[i].score2) * (1000000 - tmp);
if (tmp == 1000000)
P[i].ratio = (1e100);
else
P[i].ratio = P[i].time2 * tmp * 1.0 / (1000000 - tmp);
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
sort(P, P + n);
for (int i = (0); i < (n); i++)
for (int j = (0); j <= (m); j++) {
score = dp[i][j];
penal = E[i][j];
if (score == -1) continue;
Update(i + 1, j, score, penal);
Update(i + 1, j + P[i].time1, score + P[i].s1, penal + P[i].time1);
double new_penal =
P[i].time1 + P[i].fail * penal + (1 - P[i].fail) * (j + P[i].time2);
Update(i + 1, j + P[i].time1 + P[i].time2, score + P[i].s1 + P[i].s2,
new_penal);
}
MX_score = 0;
MN_penal = (1e100);
for (int j = (0); j <= (m); j++)
if (dp[n][j] > MX_score || (dp[n][j] == MX_score && MN_penal > E[n][j])) {
MX_score = dp[n][j];
MN_penal = E[n][j];
}
printf("%.12f %.12f\n", MX_score * 1.0 / 1000000, MN_penal);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0), cout.precision(10);
int n, m, fx = 1000, fy = 1000, rx = 0, ry = 0;
cin >> n >> m;
char c[120][120] = {};
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> c[i][j];
if (c[i][j] == 'B') {
fx = min(fx, j);
fy = min(fy, i);
rx = max(rx, j);
ry = max(ry, i);
}
}
}
cout << (fy + ry + 2) / 2 << " " << (fx + rx + 2) / 2 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long c[10];
int main() {
int n;
scanf("%d", &n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
c[i % 9]++;
ans -= n / i;
}
for (int i = 0; i < 9; i++)
for (int j = 0; j < 9; j++) ans += c[i] * c[j] * c[(i * j) % 9];
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
long long n, m, k, x, y, l, r, ans, a[N], L[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < (int)(n); ++i) cin >> a[i];
for (int i = 0; i < (int)(n); ++i) {
l = 1, r = ans;
while (l <= r) {
m = ceil((l + r) / 2);
if (a[L[m]] < a[i])
l = m + 1;
else
r = m - 1;
}
k = l;
L[k] = i;
if (k > ans) ans = k;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > d;
int32_t main() {
ios_base::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
vector<long long> v(n);
vector<long long> d(1e4 + 7);
for (int i = 0; i < n; ++i) {
cin >> v[i];
++d[v[i]];
}
long long a = 0;
for (int i = 0; i <= 1e4 + 2; ++i) {
for (int j = i; j <= 1e4 + 2; ++j) {
int mask = i ^ j;
if (__builtin_popcount(mask) == k) {
if (i == j)
a += (d[i] * (d[i] - 1)) / 2;
else
a += d[i] * d[j];
}
}
}
cout << a;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int plane[30][30];
int bias = 10;
char s[20];
bool eval() {
for (int i = bias; i < bias + 10; i++)
for (int j = bias; j < bias + 10; j++) {
int s1(0), s2(0), s3(0), s4(0);
for (int k = -2; k <= 2; k++) {
s1 += plane[i + k][j];
s2 += plane[i][j + k];
s3 += plane[i + k][j + k];
s4 += plane[i + k][j - k];
}
if (s1 >= 9 || s2 >= 9 || s3 >= 9 || s4 >= 9) return true;
}
return false;
}
int main() {
memset(plane, 0, sizeof(plane));
for (int i = 0; i < 10; i++) {
scanf("%s", &s);
for (int j = 0; j < 10; j++) {
if (s[j] == 'X')
plane[i + bias][j + bias] = 2;
else if (s[j] == '.')
plane[i + bias][j + bias] = 1;
}
}
bool ans = eval();
if (ans)
printf("YES\n");
else
printf("NO\n");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1e5 + 5;
int w[NMAX], nr1, nr0;
int main()
{
int n, q, i;
cin >> n >> q;
for(i = 1; i <= n; ++i){
cin >> w[i];
nr1 += (w[i] == 1);
nr0 += (w[i] == 0);
}
int t, k;
for(i = 1; i <= q; ++i){
cin >> t >> k;
if(t == 1){
if(w[k] == 1){
--nr1;
++nr0;
}
else{
++nr1;
--nr0;
}
w[k] = 1 - w[k];
}
else {
if(k <= nr1)
cout << "1\n";
else cout << "0\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const long long inf = 1LL << 60;
const int N = 50010;
const int K = 15;
int n, k, a[N][K];
int v[K];
struct Node {
int Minv[K], Maxv[K], sz;
bool operator<(const Node& x) const {
for (int i = 1; i <= k; ++i)
if (Maxv[i] > x.Maxv[i]) return 0;
return 1;
}
};
set<Node> s;
int read() {
int w(0), f(0);
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') f = 1, c = getchar();
while (c >= '0' && c <= '9') w = w * 10 + c - '0', c = getchar();
return f ? -w : w;
}
int main() {
n = read(), k = read();
for (int i = 1; i <= n; ++i) {
Node now;
for (int j = 1; j <= k; ++j) {
a[i][j] = read(), v[j] = a[i][j];
now.Minv[j] = a[i][j];
now.Maxv[j] = a[i][j];
}
now.sz = 1;
set<Node>::iterator x = s.lower_bound(now), y;
while (x != s.end()) {
bool fg = 0;
for (int j = 1; j <= k; ++j)
if (v[j] > x->Minv[j]) {
fg = 1;
break;
}
if (fg) {
for (int j = 1; j <= k; ++j) {
now.Minv[j] = min(now.Minv[j], x->Minv[j]);
now.Maxv[j] = max(now.Maxv[j], x->Maxv[j]);
}
now.sz += x->sz;
y = x;
y++;
s.erase(x);
x = y;
} else
break;
}
s.insert(now);
printf("%d\n", s.rbegin()->sz);
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int MAXP = 2000 + 100;
int t[MAXP], c[MAXP], r[MAXP];
struct SuffixArray {
char T[MAXP];
int p[MAXP], n;
void countSort(int k) {
int m = max(255, n), i;
for (i = 0; i <= m; ++i) c[i] = 0;
for (i = 0; i < n; ++i) c[((p[i] + (k)) < (n) ? (r[p[i] + (k)]) : 0)]++;
for (i = 1; i <= m; ++i) c[i] += c[i - 1];
for (i = n - 1; i >= 0; i--)
t[--c[((p[i] + (k)) < (n) ? (r[p[i] + (k)]) : 0)]] = p[i];
for (i = 0; i < n; ++i) p[i] = t[i];
}
void buildSA() {
n = strlen(T);
T[n++] = '$';
T[n] = '\0';
for (int i = 0; i < n; ++i) {
r[i] = T[i];
p[i] = i;
}
int f, i;
for (int k = 1; k < n; k *= 2) {
countSort(k);
countSort(0);
f = t[p[0]] = 0;
for (i = 1; i < n; ++i) {
t[p[i]] = (((p[i] + (0)) < (n) ? (r[p[i] + (0)]) : 0) ==
((p[i - 1] + (0)) < (n) ? (r[p[i - 1] + (0)]) : 0) &&
((p[i] + (k)) < (n) ? (r[p[i] + (k)]) : 0) ==
((p[i - 1] + (k)) < (n) ? (r[p[i - 1] + (k)]) : 0))
? f
: ++f;
}
for (i = 0; i < n; ++i) r[i] = t[i];
if (f == n - 1) break;
}
}
int findLowerBound(char* S, int m) {
int lo = 0, hi = n - 1;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (strncmp(T + p[mid], S, m) >= 0)
hi = mid;
else
lo = mid + 1;
}
return strncmp(T + p[lo], S, m) != 0 ? -1 : lo;
}
int findUpperBound(char* S, int m) {
int lo = 0, hi = n - 1;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (strncmp(T + p[mid], S, m) > 0)
hi = mid;
else
lo = mid + 1;
}
if (strncmp(T + p[hi], S, m) != 0) hi--;
assert(strncmp(T + p[hi], S, m) == 0);
return hi;
}
int occurences(char* S, int m) {
int L, R;
if ((L = findLowerBound(S, m)) == -1) return 0;
R = findUpperBound(S, m);
return R - L + 1;
}
void printSA() {
printf("Suffix Array of %s\n", T);
for (int i = 0; i < n; ++i) printf("%d: %s\n", i, T + p[i]);
}
} S, P[10];
int n;
int L[10], R[10];
int main() {
while (scanf("%s", S.T) != EOF) {
scanf("%d", &n);
S.buildSA();
for (int i = 0; i < n; ++i) {
scanf("%s %d %d", P[i].T, L + i, R + i);
P[i].buildSA();
}
int i, j, k, f, g, res = 0;
set<string> used;
for (i = 0; i < S.n - 1; ++i) {
for (j = 1; j <= S.n - 1 - i; ++j) {
f = 1;
string s = "";
for (k = 0; k < j; ++k) s.push_back(S.T[i + k]);
if (used.find(s) != used.end()) continue;
used.insert(s);
for (k = 0; k < n && f == 1; ++k) {
g = P[k].occurences(S.T + i, j);
f &= (L[k] <= g && g <= R[k]);
}
res += f;
if (f) {
}
}
}
printf("%d\n", res);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t1, t2, x1, x2, t0;
cin >> t1 >> t2 >> x1 >> x2 >> t0;
if (t1 == t2) {
cout << x1 << ' ' << x2 << endl;
return 0;
}
if (t2 == t0) {
cout << 0 << ' ' << x2 << endl;
return 0;
}
double diff = 1e222;
long long by = -1, yy1, yy2;
for (long long y1 = 0; y1 <= x1; ++y1) {
long long up = t1 * y1 - t0 * y1;
long long y2;
if (up >= 0) {
if (y1 == 0) {
y2 = x2;
} else {
y2 = 0;
}
} else {
y2 = (-up + (t2 - t0) - 1) / (t2 - t0);
y2 = min(y2, x2);
}
double curDiff = (double)(t1 * y1 + t2 * y2) / (y1 + y2) - t0;
if (curDiff < -1e-7) continue;
if ((fabs(curDiff - diff) < 1e-7)) {
if (y2 + y1 > by) {
diff = curDiff;
by = y2 + y1;
yy1 = y1;
yy2 = y2;
}
} else if (curDiff < diff) {
diff = curDiff;
by = y2 + y1;
yy1 = y1;
yy2 = y2;
}
}
cout << yy1 << ' ' << yy2 << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> a;
vector<long long> val, cnt;
vector<long long> dist;
vector<vector<int>> par;
void dfs(int x, int p) {
par[x][0] = p;
for (int i = 1; i < 25; ++i) par[x][i] = par[par[x][i - 1]][i - 1];
for (auto [u, w] : a[x]) {
if (u == p) continue;
dist[u] = dist[x] + w;
dfs(u, x);
cnt[x] += cnt[u];
}
int pr = x;
for (int i = 24; i >= 0; --i) {
if (dist[x] - dist[par[pr][i]] <= val[x]) {
pr = par[pr][i];
}
}
cnt[par[x][0]]++;
cnt[par[pr][0]]--;
}
int main() {
ios::sync_with_stdio(false);
cout.tie(nullptr);
cin.tie(nullptr);
int n;
cin >> n;
a.resize(n + 5, vector<pair<int, int>>());
val.resize(n + 5);
cnt.resize(n + 5, 0);
dist.resize(n + 5, 0);
par.resize(n + 5, vector<int>(25, 0));
for (int i = 1; i <= n; ++i) cin >> val[i];
for (int i = 2; i <= n; ++i) {
int p, w;
cin >> p >> w;
a[i].push_back({p, w});
a[p].push_back({i, w});
}
dfs(1, 0);
for (int i = 1; i <= n; ++i) cout << cnt[i] << " ";
cout << '\n';
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
void SieveOfEratosthenes(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p]) cout << p << " ";
}
long long int fact_mod(long long int x) {
long long int res = x;
while (x--) {
if (x == 0) break;
res = (res * x) % mod;
}
return res;
}
long long int pw_mod(long long int a, long long int b) {
long long int res = 1;
while (b != 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return res;
}
int pos[8000100] = {0};
void kmp(string s) {
int n = (int)s.length(), i;
for (i = 0; i < n + 1; i++) pos[i] = 0;
for (i = 1; i < n; i++) {
int j = pos[i - 1];
while (j > 0 && s[i] != s[j]) j = pos[j - 1];
if (s[i] == s[j]) j++;
pos[i] = j;
}
}
long long int mod_lo = 1e9 + 7;
int dp[205][205][205];
bool vis[205][205][205];
void cf_solve() {}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
string t;
cin >> t;
assert((int)(t).size() == 2);
if (t[0] == t[1]) {
int cnt = 0;
for (char c : s)
if (c == t[0]) cnt++;
cnt = min(cnt + k, n);
cout << cnt * (cnt - 1) / 2 << endl;
return 0;
}
function<int(int, int, int)> go = [&](int pos, int rem, int cnt) -> int {
if (pos == n) {
return 0;
}
if (vis[pos][rem][cnt]) return dp[pos][rem][cnt];
vis[pos][rem][cnt] = 1;
int &ans = dp[pos][rem][cnt];
if (s[pos] == t[0]) {
ans = max(ans, go(pos + 1, rem, cnt + 1));
if (rem) ans = max(ans, cnt + go(pos + 1, rem - 1, cnt));
} else if (s[pos] == t[1]) {
ans = max(ans, cnt + go(pos + 1, rem, cnt));
if (rem) ans = max(ans, go(pos + 1, rem - 1, cnt + 1));
} else {
ans = max(ans, go(pos + 1, rem, cnt));
if (rem) {
ans = max(ans, cnt + go(pos + 1, rem - 1, cnt));
ans = max(ans, go(pos + 1, rem - 1, cnt + 1));
}
}
return ans;
};
cout << go(0, k, 0) << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int t, n, col[(1<<16)];
vector<int> g[(1<<16)], perm;
void solve(vector<int> & cur) {
int cs = cur.size();
if(cs == 1) {
perm.push_back(cur[0]);
return;
}
vector<bool> in_cur, which_half, vis;
vector<int> nxt, lower_half;
for(int i = 0; i<(1<<n); i++) {
in_cur.push_back(false);
which_half.push_back(false);
vis.push_back(false);
nxt.push_back(0);
}
for(int i = 0; i<cs; i++) {
in_cur[cur[i]] = true;
vis[i] = false;
}
int init1 = cur[0], init2;
for(int i: g[init1]) {
if(in_cur[i]) {
init2 = i;
}
}
queue<int> q;
q.push(init1), q.push(init2);
vis[init1] = vis[init2] = true;
which_half[init1] = false, which_half[init2] = true;
nxt[init1] = init2, nxt[init2] = init1;
while(!q.empty()) {
int x = q.front();
q.pop();
if(!which_half[x]) {
lower_half.push_back(x);
}
for(int i: g[x]) {
if(in_cur[i]) {
if(!vis[i]) {
which_half[i] = which_half[x];
q.push(i);
vis[i] = true;
}
if(vis[i] && (which_half[i]^which_half[x])) {
nxt[x] = i, nxt[i] = x;
}
}
}
}
solve(lower_half);
for(int i = 0; i<lower_half.size(); i++) {
perm.push_back(nxt[perm[i]]);
}
}
int main() {
cin >> t;
while(t--) {
cin >> n;
for(int i = 0, u, v; i < (n<<(n-1)); i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
vector<int> cur;
for(int i = 0; i<(1<<n); i++) {
cur.push_back(i);
}
solve(cur);
for(int p: perm) {
cout << p << " ";
}
cout << endl;
set<int> pow2;
for(int i = 1; i <= 16; i *= 2) {
pow2.insert(i);
}
if(!pow2.count(n)) {
cout << -1 << endl;
} else {
for(int i = 0; i < (1<<n); i++) {
for(int j = 0; j < n; j++) {
if(i & (1<<j)) {
col[perm[i]] ^= j;
}
}
}
for(int i = 0; i<(1<<n); i++) {
cout << col[i] << " ";
col[i] = 0;
}
cout << endl;
}
perm.clear();
for(int i = 0; i<(1<<n); i++) {
g[i].clear();
}
}
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
template <class t>
t lcm(t a, t b) {
return ((a * b) / __gcd(a, b));
}
bool isprime(long long num) {
if (num == 1) return false;
long long limit = sqrt(num);
if (num == 2) return true;
if (num % 2 == 0) return false;
for (long long i = 3; i <= limit; i += 2) {
if (num % i == 0) {
return false;
}
}
return true;
}
long long n, k;
vector<long long> arr;
long long grundyOdd[8] = {0, 1, 0, 1, 2, 0, 2, 0};
void input() {
cin >> n >> k;
arr.resize(n);
for (long long i = 0; i < n; i++) cin >> arr[i];
}
long long grundy(long long ip) {
if (k % 2 == 0) {
if (ip < 3)
return ip;
else if (ip % 2 == 0)
return 1LL;
else
return 0LL;
} else {
if (ip < 8)
return grundyOdd[ip];
else if (ip % 2 != 0)
return 0LL;
else {
long long num = grundy(ip / 2);
if (num == 0LL)
return 1LL;
else if (num == 1LL)
return 2LL;
else
return 1LL;
}
}
}
int main() {
input();
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans = ans ^ grundy(arr[i]);
}
if (ans != 0LL)
cout << "Kevin";
else
cout << "Nicky";
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000;
void print(const vector<vector<long long> >& mat) {
for (int i = 0; i < mat.size(); i++) {
for (int j = 0; j < mat[0].size(); j++) printf("%3I64d ", mat[i][j]);
printf("\n");
}
printf("\n");
}
vector<vector<long long> > solve(const vector<vector<long long> >& mat, int K) {
int R = mat.size(), C = mat[0].size();
vector<vector<long long> > diag(R, vector<long long>(C)),
hor(R, vector<long long>(C)), ver(R, vector<long long>(C)),
horW(R, vector<long long>(C)), verW(R, vector<long long>(C)),
tri(R, vector<long long>(C)), triW(R, vector<long long>(C));
if (K < 1) return triW;
long long sum = 0;
for (int jj = 0; jj < R + C - 1; jj++) {
int i = 0, j = jj;
while (j >= C) j--, i++;
sum = 0;
for (; i < R && j >= 0; i++, j--) diag[i][j] = sum += mat[i][j];
for (j++, i--; i >= K && j + K < C; j++, i--)
diag[i][j] -= diag[i - K][j + K];
}
for (int i = 0; i < R; i++) {
sum = 0;
for (int j = 0; j < C; j++) hor[i][j] = sum += mat[i][j];
for (int j = C - 1; j >= K; j--) hor[i][j] -= hor[i][j - K];
}
for (int j = 0; j < C; j++) {
sum = 0;
for (int i = 0; i < R; i++) ver[i][j] = sum += mat[i][j];
for (int i = R - 1; i >= K; i--) ver[i][j] -= ver[i - K][j];
}
for (int i = 0; i < R; i++) {
sum = 0;
for (int j = 0; j < K - 1; j++) sum += mat[i][j] * (j + 1);
for (int j = K - 1; j < C; j++) {
horW[i][j] = sum += mat[i][j] * K;
sum -= hor[i][j];
}
}
for (int j = 0; j < C; j++) {
sum = 0;
for (int i = 0; i < K - 1; i++) sum += mat[i][j] * (i + 1);
for (int i = K - 1; i < R; i++) {
verW[i][j] = sum += mat[i][j] * K;
sum -= ver[i][j];
}
}
sum = 0;
for (int i = K - 2; i >= 0; i--)
for (int j = K - i - 1; j < K - 1; j++) sum += mat[i][j];
for (int i = K - 1; i < R; i++) {
long long newSum = sum += hor[i][K - 1] - mat[i][K - 1];
for (int j = K - 1; j < C; j++) {
tri[i][j] = newSum += ver[i][j];
newSum -= diag[i][j - K + 1];
}
sum -= diag[i][0] - mat[i - K + 1][K - 1];
}
sum = 0;
for (int i = K - 2; i >= 0; i--)
for (int j = K - i - 1, w = 1; j < K; j++, w++) sum += mat[i][j] * w;
for (int i = K - 1; i < R; i++) {
sum += horW[i][K - 1];
long long newSum = sum - verW[i][K - 1];
for (int j = K - 1; j < C; j++) {
triW[i][j] = newSum += verW[i][j];
newSum -= tri[i][j];
}
sum -= tri[i][K - 1];
}
return triW;
}
vector<vector<long long> > rotate90(const vector<vector<long long> >& mat) {
int R = mat.size(), C = mat[0].size();
vector<vector<long long> > ret(C, vector<long long>(R));
for (int i = 0; i < R; i++)
for (int j = 0; j < C; j++) ret[C - j - 1][i] = mat[i][j];
return ret;
}
vector<vector<long long> > rotate270(const vector<vector<long long> >& mat) {
return rotate90(rotate90(rotate90(mat)));
}
vector<vector<long long> > shiftUp(const vector<vector<long long> >& mat) {
int R = mat.size(), C = mat[0].size();
vector<vector<long long> > ret(R, vector<long long>(C));
for (int i = 0; i < R - 1; i++)
for (int j = 0; j < C; j++) ret[i][j] = mat[i + 1][j];
return ret;
}
vector<vector<long long> > shiftLeft(const vector<vector<long long> >& mat) {
int R = mat.size(), C = mat[0].size();
vector<vector<long long> > ret(R, vector<long long>(C));
for (int i = 0; i < R; i++)
for (int j = 0; j < C - 1; j++) ret[i][j] = mat[i][j + 1];
return ret;
}
void add(vector<vector<long long> >& me,
const vector<vector<long long> >& her) {
int R = me.size(), C = her[0].size();
for (int i = 0; i < R; i++)
for (int j = 0; j < C; j++) me[i][j] += her[i][j];
return;
}
int main() {
int R, C, K;
scanf("%d%d%d", &R, &C, &K);
vector<vector<long long> > mat(R, vector<long long>(C)), ret = mat;
for (int i = 0; i < R; i++)
for (int j = 0; j < C; j++) scanf("%I64d", &mat[i][j]);
const int du[] = {0, 0, 1, 1};
const int dl[] = {0, 1, 1, 0};
const int dk[] = {0, 1, 2, 1};
for (int i = 0; i < 4; i++) {
vector<vector<long long> > temp = solve(mat, K - dk[i]);
mat = rotate90(mat);
for (int j = 0; j < i; j++) temp = rotate270(temp);
if (dl[i]) temp = shiftLeft(temp);
if (du[i]) temp = shiftUp(temp);
add(ret, temp);
}
pair<long long, pair<int, int> > ans(-1e18, make_pair(0, 0));
for (int i = K - 1; i + K - 1 < R; i++)
for (int j = K - 1; j + K - 1 < C; j++)
ans = max(ans, make_pair(ret[i][j], make_pair(i + 1, j + 1)));
printf("%d %d\n", ans.second.first, ans.second.second);
return 0;
}
| 17 |
#include <bits/stdc++.h>
int main(int argc, char *argv[], char *envp[]) {
int n = 0;
scanf("%d", &n);
int tab[n];
int max = -1, max2 = -1, indice = 0, i = 0;
for (i = 0; i < n; i++) {
scanf("%d", &tab[i]);
if (max < tab[i]) {
max2 = max;
max = tab[i];
indice = i;
} else if (max2 < tab[i]) {
max2 = tab[i];
}
}
printf("%d %d\n", indice + 1, max2);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
int big = pow(10, 9) + 7, size = 200000;
int tt;
cin >> tt;
vector<ll> dp(size+1);
dp[0] = 1;
for (int i = 0; i < size; i++)
{
if (i + 9 < size)
dp[i + 9] = (dp[i + 9] + dp[i]) % big;
if (i + 10 < size)
dp[i + 10] = (dp[i + 10] + dp[i]) % big;
}
for (int i = 1; i < size; i++)
{
dp[i] = (dp[i] + dp[i - 1]) % big;
}
while (tt--)
{
string s;
ll m, ans = 0;
cin >> s >> m;
ans = s.size();
vector<ll> num(10);
for (int i = 0; i < s.size(); i++)
{
int n = s[i] - '0';
num[n]++;
}
for (int i = 0; i < 10; i++)
{
if (m < (10 - i))
continue;
ans = (ans + num[i] * dp[m - (10 - i)]) % big;
}
cout << ans << "\n";
}
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long arr[n];
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
long long mv = 0;
for (int i = 0; i < n; i++) {
mv += abs(i + 1 - arr[i]);
}
cout << mv << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans++;
if (a[i] > 8) {
if (i + 1 < n) a[i + 1] += (a[i] - 8);
k -= 8;
} else {
k -= a[i];
}
if (k <= 0) break;
}
if (k <= 0)
cout << ans << endl;
else
cout << "-1" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long mod = 1000000007;
vector<int> inp(200001, 0);
vector<int> outp(200001, 0);
vector<int> dead(200001, 0);
vector<int> tree[200001];
vector<int> rev_tree[200001];
vector<int> vis(200001, 0);
unsigned long long dfs(int x) {
unsigned long long ret = 1;
for (int i = 0; i < tree[x].size(); i++) {
int j = tree[x][i];
if (vis[j] == 1) continue;
vis[j] = 1;
ret += dfs(j);
}
return ret;
}
unsigned long long rdfs(int x) {
unsigned long long ret = 1;
for (int i = 0; i < rev_tree[x].size(); i++) {
int j = rev_tree[x][i];
if (vis[j] == 1) continue;
vis[j] = 1;
ret += rdfs(j);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
if (x == y) {
dead[x] = 1;
inp[x]++;
outp[x]++;
continue;
}
inp[x]++;
outp[y]++;
tree[y].push_back(x);
rev_tree[x].push_back(y);
rev_tree[y].push_back(x);
}
unsigned long long ans = 1;
for (int i = 1; i <= 2 * n; i++) {
if (dead[i] == 1 && vis[i] == 0) {
vis[i] = 1;
unsigned long long temp = dfs(i);
}
}
for (int i = 1; i <= 2 * n; i++) {
if (inp[i] == 0 && outp[i] > 0 && vis[i] == 0) {
vis[i] = 1;
unsigned long long temp = dfs(i);
ans = (ans * temp) % mod;
}
}
for (int i = 1; i <= 2 * n; i++) {
if (inp[i] == 0 && outp[i] == 0) continue;
if (vis[i] == 0) {
vis[i] = 1;
rdfs(i);
ans = (ans * 2) % mod;
}
}
cout << ans << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int nx = 5e4 + 5;
inline void chmax(int& a, int b) { a = (a < b) ? b : a; }
namespace trie {
int nxt[256 * 16 + 1][2];
int timer = 0;
void reset() {
memset(nxt, 0, sizeof nxt);
timer = 0;
}
void add(const int& x) {
int v = 0;
for (int i = 15; i >= 0; --i) {
int val = (((x) >> (i)) & 1);
if (nxt[v][val] == 0) nxt[v][val] = ++timer;
v = nxt[v][val];
}
}
int query(const int& x) {
int ans = 0;
int v = 0;
for (int i = 15; i >= 0; --i) {
int desired = (((x) >> (i)) & 1) ^ 1;
if (nxt[v][desired] == 0) {
v = nxt[v][desired ^ 1];
} else {
ans |= (1 << i);
v = nxt[v][desired];
}
}
return ans;
}
} // namespace trie
namespace variables {
int n;
int q;
int a[nx];
vector<int> g[nx];
int dep[nx];
int par[nx];
int nxt[nx];
int bestSignificantEight[nx][256];
} // namespace variables
using namespace variables;
void dfs(int v, int p = -1) {
if (dep[v] >= 256) {
trie::reset();
int u = v;
int dist = 0;
while (dist <= 255) {
trie::add(a[u] ^ dist);
++dist;
u = par[u];
}
nxt[v] = u;
for (int val = 0; val < 201; ++val) {
bestSignificantEight[v][val] = trie::query(val << 8);
}
}
for (auto& c : g[v]) {
if (c == p) continue;
dep[c] = dep[v] + 1;
par[c] = v;
dfs(c, v);
}
}
void solve() {
cin >> n >> q;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
g[u].emplace_back(v);
g[v].emplace_back(u);
}
dep[1] = 1;
dfs(1);
while (q--) {
int u, v;
cin >> u >> v;
int oldv = v;
int ans = 0;
int coefficient = 0;
while (nxt[v] != 0 && dep[nxt[v]] >= dep[u]) {
int maximal = bestSignificantEight[v][coefficient];
chmax(ans, maximal);
++coefficient;
v = nxt[v];
}
while (v != u) {
chmax(ans, a[v] ^ (dep[oldv] - dep[v]));
v = par[v];
}
chmax(ans, a[u] ^ (dep[oldv] - dep[u]));
cout << ans << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 24 |
#include <bits/stdc++.h>
const int maxn = 1e5 + 3;
int n, sqrtn, D, a[maxn], ma[maxn], r[maxn], b[maxn], sb[maxn], qb[maxn], qbl;
long long X;
long long getNextX() {
X = (X * 37ll + 10007ll) % 1000000007ll;
return X;
}
void initAB() {
for (int i = 0; i < n; ++i) a[i] = i + 1;
for (int i = 0; i < n; ++i) std::swap(a[i], a[getNextX() % (i + 1)]);
for (int i = 0; i < n; ++i) r[a[i]] = i;
ma[0] = a[0];
for (int i = 1; i < n; ++i) ma[i] = std::max(ma[i - 1], a[i]);
for (int i = 0; i < D; ++i) b[i] = 1;
for (int i = 0; i < n; ++i) std::swap(b[i], b[getNextX() % (i + 1)]);
for (int i = 0; i < n; ++i)
if (b[i]) qb[qbl++] = i;
sb[0] = b[0];
for (int i = 1; i < n; ++i) sb[i] = sb[i - 1] + b[i];
}
int brute(int i) {
int c = 0;
for (int j = 0; j < qbl && qb[j] <= i; ++j) c = std::max(c, a[i - qb[j]]);
return c;
}
int guess(int i, int s) {
if (!sb[i]) return 0;
if (sb[i] == i + 1) return ma[i];
for (int v = n; v >= n - s && v > 0; --v)
if (i - r[v] >= 0 && b[i - r[v]]) return v;
return -1;
}
int main() {
scanf("%d%d%lld", &n, &D, &X);
sqrtn = sqrt(n);
initAB();
for (int i = 0, k; i < n; ++i) {
k = guess(i, 20);
if (k < 0) k = brute(i);
printf("%d\n", k);
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int a[1000006];
int ans;
int solve(int idx, int depth) {
if (depth == 0) return a[idx];
int left = solve(idx * 2, depth - 1);
int right = solve(idx * 2 + 1, depth - 1);
int cur = max(left, right);
ans += cur - left + cur - right;
return cur + a[idx];
}
int main() {
int n;
cin >> n;
memset(a, 0, sizeof(a));
for (int i = 2; i < (1 << (n + 1)); ++i) cin >> a[i];
ans = 0;
solve(1, n);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool is_accute(vector<int> a, vector<int> b, vector<int> c) {
for (int i = 0; i < 5; ++i) b[i] -= a[i], c[i] -= a[i];
int ans = 0;
for (int i = 0; i < 5; ++i) ans += b[i] * c[i];
return ans > 0;
}
bool is_good[2000] = {0};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
if (n > 100) cout << 0 << '\n', exit(0);
vector<vector<int>> A(n, vector<int>(5));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 5; ++j) cin >> A[i][j];
}
int ans = n;
for (int i = 0; i < n; ++i) {
bool found = false;
for (int j = 0; j < n and not found; ++j) {
for (int k = 0; k < n and not found; ++k) {
if (i == j or j == k or k == i) continue;
found |= is_accute(A[i], A[j], A[k]);
}
}
is_good[i] = found;
ans -= found;
}
cout << ans << '\n';
for (int i = 0; i < n; ++i)
if (is_good[i] == 0) cout << i + 1 << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int D, MOD, C[N][N], a[N][N], coe[N], now;
namespace Calc {
int Add(int x, int y) { return (x += y) >= MOD ? x - MOD : x; }
int Dec(int x, int y) { return (x -= y) < 0 ? x + MOD : x; }
int Mul(int x, int y) { return 1LL * x * y % MOD; }
int Kissme(int x, int y) {
if (!x) return !y;
int c = 1;
while (y) {
if (y & 1) c = Mul(c, x);
x = Mul(x, x);
y >>= 1;
}
return c;
}
} // namespace Calc
void Init(void) {
using namespace Calc;
C[0][0] = 1;
for (int i = 1; i <= D; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) C[i][j] = Add(C[i - 1][j], C[i - 1][j - 1]);
}
for (int i = 0; i <= D; i++) {
for (int j = 0; j <= D; j++) a[i][j] = Mul(C[D][i], Kissme(j, D - i));
a[i][D + 1] = i == 2;
}
for (int i = 0; i <= D; i++) {
int pit = i;
while (!a[pit][i]) ++pit;
for (int j = i; j <= D + 1; j++) swap(a[pit][j], a[i][j]);
int inv = Kissme(a[i][i], MOD - 2);
for (int j = 0; j <= D; j++)
if (j != i) {
int G = Mul(a[j][i], inv);
for (int k = i; k <= D + 1; k++)
a[j][k] = Dec(a[j][k], Mul(G, a[i][k]));
}
}
for (int i = 0; i <= D; i++) {
coe[i] = Mul(a[i][D + 1], Kissme(a[i][i], MOD - 2));
}
now = 3;
}
int Add(int e1, int e2) {
printf("+ %d %d %d\n", e1, e2, ++now);
return now;
}
int Pow(int e) {
printf("^ %d %d\n", e, ++now);
return now;
}
int Multi(int e, int x) {
int c = 0;
while (x) {
if (x & 1) {
if (!c)
c = e;
else
c = Add(c, e);
}
e = Add(e, e);
x >>= 1;
}
return c;
}
int Square(int e) {
int c = 0;
for (int i = 0; i <= D; i++, e = Add(e, 3)) {
if (!coe[i]) continue;
int x = Pow(e);
if (!c)
c = Multi(x, coe[i]);
else
c = Add(c, Multi(x, coe[i]));
}
return c;
}
int main(void) {
scanf("%d%d", &D, &MOD);
Init();
int Sx = Square(1);
int Sy = Square(2);
int Spxy = Square(Add(1, 2));
Sx = Multi(Sx, MOD - 1);
Sy = Multi(Sy, MOD - 1);
int ans = Multi(Add(Add(Sx, Sy), Spxy), MOD + 1 >> 1);
printf("f %d\n", ans);
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> g[200005];
long long int dp[200005], siz[200005];
void dfs(int now, int fa) {
siz[now] = 1;
for (int i = 0; i < g[now].size(); i++) {
int v = g[now][i];
if (v == fa) continue;
dfs(v, now);
siz[now] += siz[v];
}
dp[1] += siz[now];
}
void dfs2(int now, int fa) {
for (int i = 0; i < g[now].size(); i++) {
int v = g[now][i];
if (v == fa) continue;
dp[v] = dp[now] - siz[v] + n - siz[v];
dfs2(v, now);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
dfs2(1, 0);
long long int ans = 0;
for (int i = 1; i <= n; i++) ans = max(ans, dp[i]);
printf("%lld\n", ans);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int AX = 20 + 6;
struct Node {
int x, y;
} a[AX], b[AX];
int check(int i, int j) {
if (a[i].x == b[j].x && a[i].y != b[j].y) return a[i].x;
if (a[i].x != b[j].x && a[i].y == b[j].y) return a[i].y;
if (a[i].x == b[j].y && a[i].y != b[j].x) return a[i].x;
if (a[i].x != b[j].y && a[i].y == b[j].x) return a[i].y;
return 0;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i].x >> a[i].y;
}
for (int i = 0; i < m; i++) {
cin >> b[i].x >> b[i].y;
}
map<int, int> mp;
map<int, int> mp_aa;
map<int, int> mp_b;
map<int, int> mp_bb;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int tmp = check(i, j);
if (tmp && tmp != mp_aa[i]) {
mp[i]++;
mp_aa[i] = tmp;
}
}
if (mp[i] > 1) return 0 * printf("-1\n");
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int tmp = check(j, i);
if (tmp && tmp != mp_bb[i]) {
mp_b[i]++;
mp_bb[i] = tmp;
}
}
if (mp_b[i] > 1) return 0 * printf("-1\n");
}
int ans = 0;
int val = 0;
for (int i = 0; i < n; i++) {
if (mp[i] == 1 && val != mp_aa[i]) {
val = mp_aa[i];
ans++;
}
}
if (ans > 1) return 0 * printf("0\n");
ans = 0;
val = 0;
for (int i = 0; i < m; i++) {
if (mp_b[i] == 1 && val != mp_bb[i]) {
val = mp_bb[i];
ans++;
}
}
if (ans > 1) return 0 * printf("0\n");
for (int i = 0; i < n; i++) {
if (mp[i] == 1) {
for (int j = 0; j < m; j++) {
int tmp = check(i, j);
if (tmp) {
return 0 * printf("%d\n", tmp);
}
}
}
}
for (int i = 0; i < m; i++) {
if (mp_b[i] == 1) {
for (int j = 0; j < n; j++) {
int tmp = check(i, j);
if (tmp) {
return 0 * printf("%d\n", tmp);
}
}
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 100;
bool is_prime[N];
int main() {
vector<int> primes;
for (int i = 2; i < N; ++i) {
is_prime[i] = 1;
}
for (int i = 2; i < N; ++i) {
if (is_prime[i]) {
for (long long j = 2 * i; j < N; j += i) {
is_prime[j] = 0;
}
primes.push_back(i);
}
}
long long x2;
cin >> x2;
long long min_x1 = x2;
for (int i = 0; i < primes.size(); ++i) {
int p = primes[i];
if (x2 % p == 0) {
long long to = x2 - p + 1;
if (to < 3) {
to = 3;
}
if (to < p) {
to = p + 1;
}
if (to < min_x1) min_x1 = to;
}
}
int min_x0 = min_x1;
for (int i = 0; i < primes.size(); ++i) {
int p = primes[i];
int add = p - min_x1 % p;
if (add == p) add = 0;
int from = min_x1 + add;
if (from <= x2) {
int to = from - p + 1;
if (to < 3) to = 3;
if (to < p) to = p + 1;
if (to < min_x0) {
min_x0 = to;
}
}
}
cout << min_x0;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s, ss[10001];
map<string, int> mp;
vector<int> e[10001];
bool vis[10001];
int main() {
int num = 0, x, y;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
cin >> s;
if (!mp[s]) ss[++num] = s, mp[s] = num;
x = mp[s];
cin >> s;
if (!mp[s]) ss[++num] = s, mp[s] = num;
y = mp[s];
e[x].push_back(y);
e[y].push_back(x);
}
printf("%d\n", num);
for (int i = 1; i <= num; i++) {
int cnt = 0, ans = 0, sum = 0;
memset(vis, 0, sizeof(vis));
for (int j = 0; j < e[i].size(); j++) vis[e[i][j]] = 1;
vis[i] = 1;
for (int j = 1; j <= num; j++) {
if (!vis[j]) {
sum = 0;
for (int k = 0; k < e[j].size(); k++) {
if (vis[e[j][k]]) sum++;
}
if (sum > cnt)
cnt = sum, ans = 1;
else if (sum == cnt)
ans++;
}
}
cout << ss[i] << " " << ans << endl;
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s;
cin >> n >> s;
int a[5000], b[5000];
for (int i = 0; i < n; i++) cin >> a[i];
b[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; i--) b[i] = max(b[i + 1], a[i]);
int ans = 0;
for (int i = 0; i < n; i++) ans = max(ans, (s / a[i]) * (b[i] - a[i]));
ans += s;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int m, k;
cin >> m >> k;
long long int z[m];
for (long long int i = 0; i < m; i++) {
cin >> z[i];
}
sort(z, z + m);
long long int i = 1, diff = 1, a[k], check = 1;
a[0] = z[0];
while (i < m) {
if (z[i] != z[i - 1]) {
diff++;
a[check] = z[i];
check++;
}
i++;
}
if (diff > k) {
cout << "-1\n";
} else {
cout << m * k << endl;
for (i = 1; i <= m; i++) {
for (long long int j = 0; j < k; j++) {
cout << a[j % check] << " ";
}
}
cout << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test;
cin >> test;
while (test--) {
long long int n, m, mn = 1, mx = 1, x, y, d;
cin >> n >> x >> y;
cout << min(max(x + y - n + 1, 1LL), n) << " " << min(x + y - 1, n) << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long double T = 0.00000001;
long double f(vector<pair<long double, long double> > &v, long double m) {
long double maxS = 0;
for (int i = 0; i < v.size(); i++) {
maxS = max(maxS, fabs(v[i].first - m) / v[i].second);
}
return maxS;
}
int main() {
cout.precision(20);
int n;
cin >> n;
vector<pair<long double, long double> > v(n);
for (int i = 0; i < n; i++) cin >> v[i].first;
for (int i = 0; i < n; i++) cin >> v[i].second;
sort(v.begin(), v.end());
long double l = v[0].first;
long double r = v[v.size() - 1].first;
while (r - l > T) {
if (f(v, r) > f(v, l)) {
r -= (r - l) / 10;
} else {
l += (r - l) / 10;
}
}
cout << min(f(v, l), f(v, r));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1E9 + 7;
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<pair<int, int> > t;
int sum = 0;
if ((n == 5 || n == 6) && m == 3) {
cout << -1 << endl;
return 0;
}
for (int i = (1); i <= (m); ++i) {
t.push_back(pair<int, int>(i, -sum));
sum += i + 1;
}
int z = n - m;
for (__typeof((t).begin()) it = ((t).begin()); it != (t).end(); ++it)
cout << it->first << " " << it->second << endl;
int duzo = 1000000;
for (int i = (0); i <= (z - 1); ++i) {
cout << -t[i].first + duzo << " " << t[i].second << endl;
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
int a[101][101];
int b[101];
int main() {
int n;
scanf("%d", &n);
memset(b, 0, sizeof(b));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
if (i != j) b[i] |= a[i][j];
}
}
for (int i = 1; i < n; i++) printf("%d ", b[i]);
printf("%d\n", b[n]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int primes[] = {2, 3, 5, 7};
int pot[] = {2, 4, 8, 16, 32, 64, 3, 9, 27, 81, 5, 25, 7, 49};
int isDiv[101];
void sieve() {
int cnt = 0;
int ans = 0;
for (int i = 2; i < 101; i++) {
if (isDiv[i]) continue;
cnt++;
cout << i << endl;
string s;
cin >> s;
if (s == "no") {
for (int j = 2 * i; j < 101; j += i) {
isDiv[j] = 1;
}
} else {
ans++;
}
if (cnt == 20) break;
}
cout << (ans > 1 ? "composite" : "prime") << endl;
}
int main() {
ios_base::sync_with_stdio(false);
sieve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, p, a[300005][2];
bool chk(int x, int y) {
for (int i = 1; i <= m; ++i)
if (a[i][0] != x && a[i][0] != y && a[i][1] != x && a[i][1] != y) return 0;
return 1;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &a[i][0], &a[i][1]);
if (a[i][0] != a[1][0] && a[i][0] != a[1][1] && a[i][1] != a[1][0] &&
a[i][1] != a[1][1])
p = i;
}
if (chk(a[1][0], a[1][1]) || chk(a[1][0], a[p][0]) || chk(a[1][0], a[p][1]) ||
chk(a[1][1], a[p][0]) || chk(a[1][1], a[p][1]))
puts("YES");
else
puts("NO");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int money, c1, c2, id;
friend bool operator<(node a, node b) { return a.money > b.money; }
} a[200005];
bool vis[200005];
priority_queue<node> Q[4];
int main() {
for (int i = 1; i <= 3; i++)
while (!Q[i].empty()) Q[i].pop();
int n, m, t;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].money);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].c1);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].c2);
a[i].id = i;
if (a[i].c1 == 1 || a[i].c2 == 1) Q[1].push(a[i]);
if (a[i].c1 == 2 || a[i].c2 == 2) Q[2].push(a[i]);
if (a[i].c1 == 3 || a[i].c2 == 3) Q[3].push(a[i]);
}
scanf("%d", &m);
memset(vis, false, sizeof(vis));
while (m--) {
scanf("%d", &t);
L:
node temp;
if (!Q[t].empty()) {
temp = Q[t].top();
Q[t].pop();
} else {
printf("-1 ");
continue;
}
if (vis[temp.id]) goto L;
printf("%d", temp.money);
vis[temp.id] = true;
if (m != 0)
printf(" ");
else
printf("\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
template <class A, class B, class C>
struct triple {
A first;
B second;
C third;
triple(A, B, C);
triple();
};
template <class A, class B, class C>
triple<A, B, C>::triple(A a, B b, C c) {
first = a;
second = b;
third = c;
}
template <class A, class B, class C>
triple<A, B, C>::triple() {}
template <class A, class B, class C>
triple<A, B, C> make_triple(A a, B b, C c) {
triple<A, B, C> t(a, b, c);
return t;
}
template <class A, class B, class C>
bool operator<(triple<A, B, C> a, triple<A, B, C> b) {
if (a.first != b.first) return a.first < b.first;
if (a.second != b.second) return a.second < b.second;
if (a.third != b.third) return a.third < b.third;
}
template <class T>
T inline sqr(T a) {
return a * a;
}
const long double PI = 3.141592653589793;
const long double E = 2.71828182845904523;
const long long LLINF = 9000000009000000099;
const long long INF = 2009000099;
const long long MOD = 1000000008;
using namespace std;
bool cmp(string a, string b) { return a + b < b + a; }
int main() {
ios::sync_with_stdio(0);
long long n, p;
cin >> n;
vector<string> s(n);
for (int i = 0; i < n; ++i) cin >> s[i];
sort(s.begin(), s.end(), cmp);
for (int i = 0; i < n; ++i) cout << s[i];
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
long long n, d, b, a[N], Ans, sum[N], cnt1, cnt2;
int main() {
cin >> n >> d >> b;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
for (int i = 1; i <= n / 2; i++) {
long long x = sum[min(n, i + i * d)] - cnt1 * b;
if (x >= b) cnt1++;
x = sum[n] - sum[max(0LL, n - i - i * d)] - cnt2 * b;
if (x >= b) cnt2++;
}
Ans = n / 2 - min(cnt1, cnt2);
cout << Ans << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
struct Nod {
int val;
Nod *L, *R;
Nod(int i) : val(i), L(NULL), R(NULL) {}
};
int x[200005];
char c[200005];
int t[200005];
map<int, int> u;
int v[200005];
void rfs(Nod *a) {
if (a->L != NULL) {
a->L->val = max(a->L->val, a->val);
a->R->val = max(a->R->val, a->val);
}
}
int get(Nod *a, int s, int d, int x) {
rfs(a);
int mid = (s + d) >> 1;
if (x <= mid && a->L != NULL) return get(a->L, s, mid, x);
if (x > mid && a->R != NULL) return get(a->R, mid + 1, d, x);
return a->val;
}
void upd(Nod *a, int s, int d, int l, int r, int x) {
rfs(a);
if (l > d || s > r || l > r) return;
if (s >= l && r >= d) {
a->val = max(a->val, x);
return;
}
int mid = (s + d) >> 1;
if (a->L == NULL) {
a->L = new Nod(a->val);
a->R = new Nod(a->val);
}
upd(a->L, s, mid, l, r, x);
upd(a->R, mid + 1, d, l, r, x);
}
void parc(Nod *a) {
if (a != NULL) {
parc(a->L);
cout << a->val << ' ';
parc(a->R);
}
}
int main() {
ios_base::sync_with_stdio(false);
int n, q, y;
cin >> n >> q;
for (int i = 0; i < q; ++i) {
cin >> x[i] >> y >> c[i];
t[i] = x[i];
}
t[q] = 0;
t[q + 1] = n + 1;
sort(t, t + q + 2);
for (int i = 0; i < q + 2; ++i) {
u[t[i]] = i;
v[i] = t[i];
}
Nod *treev, *treeh;
treev = new Nod(0);
treeh = new Nod(0);
int a, b;
for (int i = 0; i < q; ++i) {
a = u[x[i]];
b = q - a + 1;
if (c[i] == 'L') {
y = get(treeh, 1, q, b);
cout << v[a] - v[y] << '\n';
upd(treev, 1, q, y + 1, a, b);
upd(treeh, 1, q, b, b, a);
} else {
y = get(treev, 1, q, a);
cout << v[q - y + 1] - v[a] << '\n';
upd(treeh, 1, q, y + 1, b, a);
upd(treev, 1, q, a, a, b);
}
}
return 0;
}
| 14 |
Subsets and Splits