solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int k = 0; k < t; k++) {
int n;
cin >> n;
string s;
cin >> s;
int cnt = 0;
for (int i = 0; i < n; ++i) {
cnt += s[i] != '?' ? 1 : 0;
}
if (cnt == 0) s[0] = 'R';
for (int i = 1; i < n; ++i) {
if (s[i] == '?' && s[i - 1] != '?') {
s[i] = (s[i - 1] == 'R' ? 'B' : 'R');
}
}
for (int i = n - 2; i >= 0; i--) {
if (s[i] == '?' && s[i + 1] != '?') {
s[i] = (s[i + 1] == 'R' ? 'B' : 'R');
}
}
cout << s << endl;
}
}
| 1 |
#include <bits/stdc++.h>
const long long N = 1e6 + 5;
const long long M = 2e6 + 5;
const long long P = 1e9 + 7;
long long n, m, cnt;
std::vector<long long> E[N][10], Q[N];
long long dis[N], g[N];
long long digit[N], tot;
void add_edge(long long u, long long v, long long dis) {
tot = 0;
while (dis) digit[++tot] = dis % 10, dis /= 10;
long long tmp = u;
for (long long j = tot; j > 1; j--) E[u][digit[j]].push_back(++cnt), u = cnt;
E[u][digit[1]].push_back(v);
for (long long j = tot; j > 1; j--) E[v][digit[j]].push_back(++cnt), v = cnt;
E[v][digit[1]].push_back(tmp);
}
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while ('0' > ch or ch > '9') f = ch == '-' ? -1 : 1, ch = getchar();
while ('0' <= ch and ch <= '9') x = x * 10 + ch - 48, ch = getchar();
return x * f;
}
signed main() {
cnt = n = read(), m = read();
for (long long i = 1, u, v; i <= m; i++)
u = read(), v = read(), add_edge(u, v, i);
g[1] = 1;
long long tail = 1;
Q[1].push_back(1);
for (long long head = 1; head <= tail; head++) {
for (long long z = 0; z < 10; z++) {
auto t = Q[head].begin();
while (t != Q[head].end()) {
auto x = *t;
for (auto y : E[x][z]) {
if (g[y]) continue;
dis[y] = (dis[x] * 10LL + z) % P;
g[y] = 1, Q[tail + 1].push_back(y);
}
++t;
}
if (Q[tail + 1].size()) ++tail;
}
}
for (long long i = 2; i <= n; i++) printf("%lld\n", dis[i]);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 1e5 + 1;
int n;
int s[sz];
vector<int> prime;
void sieve() {
for (int i = 2; i <= n; i++) {
if (s[i] == 0) {
prime.push_back(i);
for (int j = i; j <= n; j += i) s[j] = i;
}
}
}
int ask(int type, int x) {
if (type == 0)
cout << "A " << x << endl;
else if (type == 1)
cout << "B " << x << endl;
else {
cout << "C " << x << endl;
return 0;
}
int res;
cin >> res;
return res;
}
void solve() {
cin >> n;
sieve();
fill(s, s + sz, 0);
bool gff = 0;
int l = 0, r = 0;
vector<int> fact;
int c = 0;
int cur_st = n;
int sq = sqrt(n) + 1;
for (int x : prime) {
int res = ask(1, x);
int cnt1 = 0, cnt2 = 0;
for (int i = x; i <= n; i += x) {
if (s[i] != 0 && s[i] < x) cnt1++;
if (s[i] == 0) cur_st--;
cnt2++;
s[i] = x;
}
if (res > cnt2 - cnt1) {
fact.push_back(x);
if (!gff) {
gff = 1;
r = c - 1;
}
}
if (!gff && (c - l >= sq || c == 0)) {
res = ask(0, 1);
if (cur_st < res) {
r = c;
gff = 1;
} else {
l = c;
}
}
c++;
}
if (!gff) {
r = c - 1;
gff = 1;
}
int res = ask(0, 1);
if (res == 1) {
ask(2, 1);
return;
}
for (int i = l; i <= r; i++) {
int res = ask(0, prime[i]);
if (res == 1) {
fact.push_back(prime[i]);
break;
}
}
int ans = 1;
for (int x : fact) {
long long cur = (long long)x * x;
while (cur <= n && ask(0, cur) == 1) cur *= x;
cur /= x;
ans *= cur;
}
ask(2, ans);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q = 1;
for (; q > 0; q--) {
solve();
}
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long a, b, k = 0;
cin >> a >> b;
long long c = a * 100 + (b * 10);
while (a * 100 + (b * 10) > 219 && b > 1) {
if (k % 2 == 0) {
long long o = 0;
if (a < 1) {
b = b - 22;
} else if (a < 2) {
a--;
b = b - 12;
} else {
a = a - 2;
b = b - 2;
}
} else {
if (b < 12) {
a = a - 2;
b = b - 2;
} else if (b < 22) {
a = a - 1;
b = b - 12;
} else {
b = b - 22;
}
}
k++;
}
if (k % 2 == 0) {
cout << "Hanako";
} else {
cout << "Ciel";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3 * 1e5 + 10;
vector<int> adj[N];
long long pt[N], f[N];
long long M = -1e18, cnt;
void dfs(int u, int pr) {
f[u] = pt[u];
for (auto v : adj[u]) {
if (v != pr) {
dfs(v, u);
f[u] += max(0LL, f[v]);
}
}
}
long long update_dfs(int u, int pr) {
long long sum = pt[u];
for (int v : adj[u]) {
if (v != pr) {
sum += update_dfs(v, u);
}
}
if (sum == M) {
cnt++;
return 0;
}
return max(0LL, sum);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> pt[i];
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1, 0);
for (int i = 1; i <= n; i++) M = max(f[i], M);
update_dfs(1, 0);
cout << M * cnt << " " << cnt << "\n";
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int INF = 1e9 + 7;
vector<int> tree;
void update(int idx, int l, int r, int pos) {
if (l == r) {
tree[idx] = 1;
return;
}
int m = (l + r) / 2;
if (pos <= m)
update(2 * idx, l, m, pos);
else
update(2 * idx + 1, m + 1, r, pos);
tree[idx] = tree[2 * idx] + tree[2 * idx + 1];
}
int query(int idx, int l, int r, int pos) {
if (l == r) return l;
int m = (l + r) / 2;
if (pos < tree[2 * idx])
return query(2 * idx, l, m, pos);
else
return query(2 * idx + 1, m + 1, r, pos - tree[2 * idx]);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
tree.resize(4 * n);
vector<int> data(n);
vector<pair<int, int>> a(n);
vector<pair<int, int>> q;
vector<pair<int, int>> q_data;
map<pair<int, int>, int> mp;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
a[i] = {-x, i};
data[i] = x;
}
sort(a.begin(), a.end());
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int k, pos;
cin >> k >> pos;
q.push_back({k - 1, pos - 1});
q_data.push_back({k - 1, pos - 1});
}
sort(q.begin(), q.end());
int it = 0;
for (int i = 0; i < n; ++i) {
update(1, 0, n - 1, a[i].second);
while (it < m && q[it].first == i) {
int x = data[query(1, 0, n - 1, q[it].second)];
mp[q[it++]] = x;
}
}
for (int i = 0; i < m; ++i) cout << mp[q_data[i]] << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
long long n, k, a[200005];
map<long long, long long> mp;
int main() {
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (long long i = 1; i <= n; i++) a[i] = a[i] ^ a[i - 1];
for (long long i = 0; i <= n; i++) mp[a[i]]++;
long long ans = 0;
for (auto it : mp) {
if (!it.second) continue;
long long sum = it.second + mp[(1 << k) - 1 - it.first];
long long mid = sum / 2;
if (mp[(1 << k) - 1 - it.first] != 0)
ans +=
1LL * mid * (mid - 1) / 2 + 1LL * (sum - mid) * (sum - mid - 1) / 2;
else
ans += 1LL * mid * (mid - 1) + 1LL * (sum - mid) * (sum - mid - 1);
}
printf("%lld\n", 1LL * n * (n + 1) / 2 - ans / 2);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ld EPS = 1e-12, PI = acos(-1);
inline bool eq(ld a, ld b) { return fabs(a - b) < EPS; }
inline bool lt(ld a, ld b) { return a + EPS < b; }
inline bool le(ld a, ld b) { return a < b + EPS; }
inline int sign(ld x) { return eq(x, 0) ? 0 : (x < 0 ? -1 : 1); }
inline ld sq(ld x) { return x * x; }
struct point {
ld x, y;
point(ld x = 0, ld y = 0) : x(x), y(y) {}
point operator+(const point& p) const { return point(x + p.x, y + p.y); }
point operator-(const point& p) const { return point(x - p.x, y - p.y); }
point operator*(ld s) { return point(x * s, y * s); }
point operator/(ld s) { return point(x / s, y / s); }
point rot90() const { return point(-y, x); }
ld operator*(const point& p) const { return x * p.x + y * p.y; }
ld norm_sq() { return *this * *this; }
ld norm() { return sqrt(*this * *this); }
bool operator==(const point& p) const { return eq(x, p.x) && eq(y, p.y); }
bool operator<(const point& p) const {
return eq(y, p.y) ? x < p.x : y < p.y;
}
};
struct Circle {
point o;
ld r;
Circle(point o = point(), ld r = 0.) : o(o), r(r) {}
friend vector<point> operator&(const Circle& c1, const Circle& c2) {
ld dis = (c1.o - c2.o).norm();
if (lt(c1.r + c2.r, dis) || lt(dis, fabs(c1.r - c2.r)))
return vector<point>();
ld dt = (sq(c1.r) - sq(c2.r)) / dis;
ld d1 = (dis + dt) / 2;
point dir = (c2.o - c1.o) / dis;
point pcrs = c1.o + dir * d1;
dt = sqrtl(max(0.0L, sq(c1.r) - sq(d1)));
dir = dir.rot90();
return {pcrs + dir * dt, pcrs - dir * dt};
}
} c[5];
struct DSU {
int pa[5], sz[5];
void init(int n) {
for (int i = 1; i <= n; i++) {
pa[i] = i, sz[i] = 1;
}
}
int find(int n) { return pa[n] == n ? pa[n] : pa[n] = find(pa[n]); }
void merge(int a, int b) {
a = find(a), b = find(b);
if (a == b) return;
if (sz[a] > sz[b]) swap(a, b);
pa[a] = b, sz[b] += sz[a];
}
} dsu;
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c[i].o.x >> c[i].o.y >> c[i].r;
}
vector<point> all;
dsu.init(n);
int e = 0;
for (int i = 1; i <= n; i++) {
vector<point> pat;
for (int j = 1; j <= n; j++) {
if (i == j) continue;
vector<point> tmp = c[i] & c[j];
if (!tmp.empty()) dsu.merge(i, j);
for (int k = 0; k < (int)tmp.size(); k++) {
all.push_back(tmp[k]), pat.push_back(tmp[k]);
}
}
sort(pat.begin(), pat.end());
e += unique(pat.begin(), pat.end()) - pat.begin();
}
sort(all.begin(), all.end());
int v = unique(all.begin(), all.end()) - all.begin();
int c = 0;
for (int i = 1; i <= n; i++) {
c += dsu.find(i) == i;
}
cout << e - v + c + 1 << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TC = 1;
for (int i = 1; i <= TC; i++) {
solve();
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, pos, neg;
bool flag;
cin >> t;
while (t--) {
cin >> n;
vector<long long> a(n), b(n);
pos = n + 1;
neg = n + 1;
flag = true;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] == 1 && pos == n + 1) pos = i;
if (a[i] == -1 && neg == n + 1) neg = i;
}
for (int i = 0; i < n; ++i) cin >> b[i];
for (int i = 0; i < n; ++i) {
if (neg >= i && b[i] < a[i]) {
cout << "NO\n";
flag = false;
break;
}
if (pos >= i && b[i] > a[i]) {
cout << "NO\n";
flag = false;
break;
}
}
if (flag) cout << "YES\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 100010;
int a[MAXN + 1], Sum[MAXN + 1];
int main() {
int Cas = read();
while (Cas--) {
int N = read();
for (int i = 1; i <= N; i++) a[i] = read(), Sum[i] = Sum[i - 1] + a[i];
int L = 1, R = N, all = 0, Last = 0, ansa = 0, ansb = 0;
for (int step = 1;; ++step) {
if (Sum[R] - Sum[L - 1] <= Last) {
if (step & 1)
ansa += Sum[R] - Sum[L - 1];
else
ansb += Sum[R] - Sum[L - 1];
printf("%d %d %d\n", all + (L <= R), ansa, ansb);
break;
}
if (step & 1) {
for (int i = L; i <= R; i++)
if (Sum[i] - Sum[L - 1] > Last) {
Last = Sum[i] - Sum[L - 1], ansa += Last;
L = i + 1, ++all;
break;
}
} else {
for (int i = R; i >= L; i--)
if (Sum[R] - Sum[i - 1] > Last) {
Last = Sum[R] - Sum[i - 1], ansb += Last;
R = i - 1, ++all;
break;
}
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using PII = pair<int, int>;
const int mod = 998244353;
const int inf = 1 << 30;
const int maxn = 500000 + 5;
int n, m, q, a[maxn], qx[maxn];
int from[maxn], to[maxn];
bool op[maxn], del[maxn];
int pre[maxn], siz[maxn];
int find(int x) { return x == pre[x] ? x : pre[x] = find(pre[x]); }
vector<int> edge[maxn];
int tot, L[maxn], R[maxn], rdfn[maxn];
void dfs(int u) {
L[u] = ++tot;
rdfn[tot] = u;
for (int v : edge[u]) {
dfs(v);
}
R[u] = tot;
}
namespace SegT {
int pos[maxn << 2];
void pushup(int rt) {
int L = pos[rt << 1], R = pos[rt << 1 | 1];
pos[rt] = a[L] >= a[R] ? L : R;
}
void build(int l = 1, int r = n + n, int rt = 1) {
if (l == r) {
pos[rt] = rdfn[l];
return;
}
int m = (l + r) / 2;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
pushup(rt);
}
void update(int i, int l = 1, int r = n + n, int rt = 1) {
if (l == r) return;
int m = (l + r) / 2;
if (i <= m)
update(i, l, m, rt << 1);
else
update(i, m + 1, r, rt << 1 | 1);
pushup(rt);
}
int query(int L, int R, int l = 1, int r = n + n, int rt = 1) {
if (L <= l && r <= R) return pos[rt];
int m = (l + r) / 2;
if (R <= m) {
return query(L, R, l, m, rt << 1);
} else if (L > m) {
return query(L, R, m + 1, r, rt << 1 | 1);
} else {
int x = query(L, R, l, m, rt << 1);
int y = query(L, R, m + 1, r, rt << 1 | 1);
return a[x] >= a[y] ? x : y;
}
}
} // namespace SegT
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", from + i, to + i);
}
for (int i = 1; i <= q; i++) {
int op;
scanf("%d%d", &op, qx + i);
if (op == 2) {
::op[i] = true;
del[qx[i]] = true;
}
}
for (int i = 1; i <= n; i++) {
pre[i] = i;
siz[i] = 1;
}
int tot = n;
auto link = [&](int x, int y) {
x = find(x);
y = find(y);
if (x == y) return false;
tot++;
pre[tot] = tot;
siz[tot] = siz[x] + siz[y];
edge[tot].push_back(x);
edge[tot].push_back(y);
pre[x] = tot;
pre[y] = tot;
return true;
};
for (int i = 1; i <= m; i++) {
if (del[i]) continue;
link(from[i], to[i]);
}
for (int i = q; i >= 1; i--) {
if (op[i]) {
link(from[qx[i]], to[qx[i]]);
} else {
int y = find(qx[i]);
qx[i] = y;
}
}
for (int i = 1; i <= tot; i++) {
if (i == find(i)) {
dfs(i);
}
}
SegT::build();
for (int i = 1; i <= q; i++) {
if (op[i]) continue;
int pos = SegT::query(L[qx[i]], R[qx[i]]);
printf("%d\n", a[pos]);
a[pos] = 0;
SegT::update(L[pos]);
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout << "Red\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
scanf("%d %d %d", &n, &x, &y);
int roz = n * 3;
long long tab[roz + 1];
for (int i = 0; i < roz; i++) tab[i] = LLONG_MAX;
tab[1] = x;
for (int z = 0; z < 6; z++) {
for (int i = 1; i < roz; i++) {
tab[i + 1] = min(tab[i + 1], tab[i] + x);
if (i * 2 <= roz)
tab[i * 2] = min(tab[i * 2], tab[i] + y);
else
tab[roz] = min(tab[roz], tab[i] + y + (i * 2 - roz) * x);
}
for (int i = roz; i > 0; i--) tab[i - 1] = min(tab[i - 1], tab[i] + x);
}
printf("%lld\n", tab[n]);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
char a[256];
string s;
int main() {
a['0'] = '8';
a['1'] = '.';
a['2'] = '.';
a['3'] = '3';
a['4'] = '6';
a['5'] = '9';
a['6'] = '4';
a['7'] = '7';
a['8'] = '0';
a['9'] = '5';
cin >> s;
if (s.size() & 1 && a[s[s.size() / 2]] != s[s.size() / 2]) {
cout << "No\n";
return 0;
}
for (int i = 0; i < s.size() / 2; ++i) {
if (a[s[i]] != s[s.size() - 1 - i]) {
cout << "No\n";
return 0;
}
}
cout << "Yes\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int number1;
cin >> number1;
while (number1) {
long long sum;
cin >> sum;
long long a, b;
long long temp = sum / 3;
if (sum % 3 == 0) {
a = temp;
b = temp;
} else if (sum % 3 == 1) {
a = temp + 1;
b = temp;
} else {
b = temp + 1;
a = temp;
}
cout << a << " " << b << endl;
number1--;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int mod = 998244353;
int sum(int a, int b) {
int s = a + b;
if (s >= mod) s -= mod;
return s;
}
int mult(int a, int b) { return (1LL * a * b) % mod; }
int pw(int a, int b) {
if (b == 0) return 1;
if (b & 1) return mult(a, pw(a, b - 1));
int res = pw(a, b / 2);
return mult(res, res);
}
int sub(int a, int b) {
int s = a - b;
if (s < 0) s += mod;
return s;
}
const int maxN = 2005;
int dp[maxN][maxN];
string s;
int tp[maxN];
int dp0[maxN][maxN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> s;
dp[0][0] = 1;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '(')
tp[i + 1] = 1;
else if (s[i] == ')')
tp[i + 1] = 0;
else
tp[i + 1] = 2;
}
int n = s.size();
for (int i = 1; i <= n; i++) {
if (tp[i] == 1) {
for (int cnt = 1; cnt <= i; cnt++) {
dp[i][cnt] = dp[i - 1][cnt - 1];
}
} else if (tp[i] == 0) {
for (int cnt = 0; cnt <= i; cnt++) {
dp[i][cnt] = dp[i - 1][cnt];
}
} else {
for (int cnt = 0; cnt <= i; cnt++) {
dp[i][cnt] = dp[i - 1][cnt];
if (cnt) dp[i][cnt] = sum(dp[i][cnt], dp[i - 1][cnt - 1]);
}
}
}
dp0[n + 1][0] = 1;
for (int i = n; i >= 1; i--) {
if (tp[i] == 0 || tp[i] == 2) {
for (int cnt = 1; cnt <= n - i + 2; cnt++) {
dp0[i][cnt] = sum(dp0[i + 1][cnt - 1], dp0[i][cnt]);
}
}
if (tp[i] == 1 || tp[i] == 2) {
for (int cnt = 0; cnt <= n - i + 2; cnt++) {
dp0[i][cnt] = sum(dp0[i + 1][cnt], dp0[i][cnt]);
}
}
}
int val = 0;
for (int pref = 1; pref <= n; pref++) {
int pref_sum = 0;
for (int cnt = n; cnt >= 1; cnt--) {
pref_sum = sum(pref_sum, dp0[pref + 1][cnt]);
if (pref_sum == 0) continue;
if (tp[pref] == 0) continue;
val = sum(val, mult(pref_sum, dp[pref - 1][cnt - 1]));
}
}
cout << val << '\n';
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653;
int main() {
int n, R, r;
double a;
scanf("%d%d%d", &n, &R, &r);
if (r > R || 2 * r > R && n > 1)
puts("NO");
else {
if (n == 1)
puts(r <= R ? "YES" : "NO");
else {
a = asin((double)r / (R - r)) * n;
if (a < PI || fabs(a - PI) < 1e-8)
puts("YES");
else
puts("NO");
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, l, sum = 0;
cin >> n >> m;
long long int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 0; i <= n - 3; i++) {
l = lower_bound(arr, arr + n, arr[i] + m) - arr;
if (arr[l] > arr[i] + m) {
l--;
}
if (l - i >= 2) {
sum += ((l - i - 1) * (l - i)) / 2;
}
}
cout << sum;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long p[(1000000 + 1)], a[(1000000 + 1)], dp[(1000000 + 1)][2],
pr[(1000000 + 1)][2];
void solve() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> p[i];
for (long long sign = 0; sign < 2; sign++) {
dp[i][sign] = LONG_MAX;
}
}
dp[0][0] = LONG_MIN;
dp[0][1] = LONG_MIN;
for (long long i = 0; i < n - 1; i++) {
for (long long sign = 0; sign < 2; sign++) {
long long x = sign ? -p[i] : p[i];
long long y = dp[i][sign];
if (x < y) swap(x, y);
for (long long new_sign = 0; new_sign < 2; new_sign++) {
long long z = new_sign ? -p[i + 1] : p[i + 1];
if (z > x) {
if (dp[i + 1][new_sign] > y) {
dp[i + 1][new_sign] = y;
pr[i + 1][new_sign] = sign;
}
} else if (z > y) {
if (dp[i + 1][new_sign] > x) {
dp[i + 1][new_sign] = x;
pr[i + 1][new_sign] = sign;
}
}
}
}
}
long long sign = -1;
for (long long new_sign = 0; new_sign < 2; new_sign++) {
if (dp[n - 1][new_sign] != LONG_MAX) {
sign = new_sign;
}
}
if (sign == -1) {
cout << "NO" << endl;
return;
} else {
cout << "YES" << endl;
}
for (long long i = n - 1; i >= 0; i--) {
a[i] = sign ? -p[i] : p[i];
sign = pr[i][sign];
}
for (long long i = 0; i < n; i++) {
cout << a[i] << " ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
const long long int mod = 1e9 + 7;
const long long int maxn = 5 * 100001;
long long int power(long long int x, long long int n) {
long long int res = 1;
for (; n > 0; n >>= 1) {
if (n & 1) res = (res * x) % mod;
x = (x * x) % mod;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
pair<long long int, long long int> a[n];
map<long long int, long long int> m;
for (long long int i = 0; i < n; i++) {
cin >> a[i].first;
m[a[i].first];
}
for (long long int i = 0; i < n; i++) {
cin >> a[i].second;
}
long long int c = 0;
map<long long int, long long int> rm;
for (auto& x : m) {
x.second = c++;
rm[c - 1] = x.first;
}
rm[c] = 1e10;
rm[-1] = rm[0];
vector<long long int> g[m.size()];
for (long long int i = 0; i < n; i++) {
g[m[a[i].first]].push_back(a[i].second);
}
long long int ans = 0;
long long int val = 0;
multiset<long long int> curr;
for (long long int i = 0; i < m.size(); i++) {
ans += (rm[i] - rm[i - 1]) * val;
for (auto x : g[i]) {
val += x;
curr.insert(x);
}
val -= *curr.rbegin();
curr.erase(curr.find(*curr.rbegin()));
c = 0;
while (c < rm[i + 1] - rm[i] - 1 && curr.size() >= 1) {
val -= *curr.rbegin();
ans += (c + 1) * (*curr.rbegin());
curr.erase(curr.find(*curr.rbegin()));
c++;
}
if (i == m.size() - 1) assert(curr.size() == 0);
}
cout << ans << endl;
}
| 9 |
#include<bits/stdc++.h>
#define y1 dmytxdy
#define pb push_back
#define fi first
#define se second
#define mp make_pair
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef long double ld;
template <typename T> bool chkmin(T &x,T y){return x>y?x=y,1:0;}
template <typename T> bool chkmax(T &x,T y){return x<y?x=y,1:0;}
int readint(){
int x=0,f=1; char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
int n,q,top;
ll p[200005],a[200005],b[200005],s[200005],fa[200005],ch[200005][2],rev[200005],sum[200005],val[200005],stk[200005],ans[200005];
vector<pii> qry[200005];
bool nroot(int x){return ch[fa[x]][0]==x||ch[fa[x]][1]==x;}
bool son(int x){return ch[fa[x]][1]==x;}
void reverse(int x){rev[x]^=1,swap(ch[x][0],ch[x][1]);}
void pushdown(int x){if(rev[x]) reverse(ch[x][0]),reverse(ch[x][1]),rev[x]=0;}
void update(int x){sum[x]=val[x]+sum[ch[x][0]]+sum[ch[x][1]];}
void rotate(int x){
int y=fa[x],z=fa[y],k=son(x),w=ch[x][!k];
if(nroot(y)) ch[z][son(y)]=x;
ch[x][!k]=y,ch[y][k]=w;
if(w) fa[w]=y;
fa[y]=x,fa[x]=z;
update(y),update(x);
}
void pushall(int x){
if(nroot(x)) pushall(fa[x]);
pushdown(x);
}
void splay(int x){
pushall(x);
while(nroot(x)){
int y=fa[x];
if(nroot(y)) rotate(son(x)==son(y)?y:x);
rotate(x);
}
}
void access(int x){for(int y=0;x;x=fa[y=x]) splay(x),ch[x][1]=y,update(x);}
void makeroot(int x){access(x); splay(x); reverse(x);}
void cut(int x,int y){makeroot(x); access(y); splay(x); assert(ch[x][1]==y); ch[x][1]=0,fa[y]=0; update(x);}
int main(){
n=readint(); q=readint();
for(int i=1;i<=n;i++) p[i]=readint();
for(int i=1;i<=n;i++) a[i]=readint(),s[i]=s[i-1]+a[i];
for(int i=1;i<=n;i++) b[i]=readint();
set<int> st;
st.insert(1),st.insert(n+1);
qry[n+1].pb(mp(1,1));
int x;
for(int i=1;i<=q;i++){
x=readint();
if(x==1) continue;
if(st.find(x)!=st.end()){
st.erase(x);
auto it2=st.lower_bound(x),it1=it2; it1--;
qry[x].pb(mp(*it1,-i));
qry[*it2].pb(mp(x,-i));
qry[*it2].pb(mp(*it1,i));
}
else{
auto it2=st.lower_bound(x),it1=it2; it1--;
qry[x].pb(mp(*it1,i));
qry[*it2].pb(mp(x,i));
qry[*it2].pb(mp(*it1,-i));
st.insert(x);
}
}
top=0;
p[n+1]=n+1;
for(int i=1;i<=n+1;i++){
if(top&&p[i-1]>p[i]){
makeroot(i-1);
val[i-1]=a[i-1];
update(i-1);
fa[i-1]=i;
makeroot(i);
}
while(top&&p[stk[top]]<p[i]){
if(stk[top]==i-1){
makeroot(i-1);
val[i-1]=min(a[i-1],b[i-1]);
update(i-1);
fa[i-1]=i;
makeroot(i);
}
else{
access(stk[top]); splay(stk[top]);
if(sum[stk[top]]>b[stk[top]]){
cut(stk[top],stk[top]+1);
val[stk[top]]=b[stk[top]];
update(stk[top]);
fa[stk[top]]=i;
makeroot(i);
}
}
top--;
}
stk[++top]=i;
for(auto j:qry[i]){
access(j.fi); splay(j.fi);
if(j.se>0) ans[j.se]+=sum[j.fi];
else ans[-j.se]-=sum[j.fi];
}
}
for(int i=1;i<=q;i++) ans[i]+=ans[i-1];
for(int i=1;i<=q;i++) printf("%lld\n",ans[i]);
return 0;
} | 25 |
#include <bits/stdc++.h>
using namespace std;
int nextInt() {
int x;
scanf("%d", &x);
return x;
}
long long nextLong() {
long long x;
scanf("%I64d", &x);
return x;
}
double nextDouble() {
double x;
scanf("%lf", &x);
return x;
}
const int BUFSIZE = 1000000;
char buf[BUFSIZE + 1];
string nextString() {
scanf("%s", buf);
return buf;
}
string nextLine() {
gets(buf);
return buf;
}
int stringToInt(string s) {
stringstream in(s);
int x;
in >> x;
return x;
}
struct Point {
double x, y;
Point() : x(0), y(0) {}
Point(double x, double y) : x(x), y(y) {}
Point operator-(Point op) const { return Point(x - op.x, y - op.y); }
Point operator+(Point op) const { return Point(x + op.x, y + op.y); }
Point operator*(double op) const { return Point(x * op, y * op); }
double operator*(Point op) const { return x * op.x + y * op.y; }
double operator%(Point op) const { return x * op.y - y * op.x; }
double length2() { return x * x + y * y; }
double lengt() { return sqrt(length2()); }
};
Point nextPoint() {
double x = nextDouble();
double y = nextDouble();
return Point(x, y);
}
void update(int &x, int y) {
if (x > y) {
x = y;
}
}
int lowerIndex(vector<int> &a, int x) {
return lower_bound(a.begin(), a.end(), x) - a.begin();
}
int main() {
int n = nextInt();
vector<string> baseStrings(n);
for (int i = 0; i < baseStrings.size(); ++i) {
baseStrings[i] = nextString();
}
int m = nextInt();
vector<int> b(m);
for (int i = 0; i < b.size(); ++i) {
b[i] = nextInt() - 1;
}
string s = nextString();
const int INF = INT_MAX;
vector<vector<vector<int> > > aIndexes(baseStrings.size(),
vector<vector<int> >(26));
for (int i = 0; i < baseStrings.size(); ++i) {
for (int j = 0; j < baseStrings[i].size(); ++j) {
int alpha = baseStrings[i][j] - 'a';
aIndexes[i][alpha].push_back(j);
}
}
vector<int> tPrefLength(b.size());
for (int i = 1; i < tPrefLength.size(); ++i) {
tPrefLength[i] = tPrefLength[i - 1] + baseStrings[b[i - 1]].size();
}
vector<vector<int> > lastAIndex(26, vector<int>(b.size(), -1));
for (int alpha = 0; alpha < lastAIndex.size(); ++alpha) {
for (int i = 0; i < lastAIndex[alpha].size(); ++i) {
if (i > 0) {
lastAIndex[alpha][i] = lastAIndex[alpha][i - 1];
}
if (!aIndexes[b[i]][alpha].empty()) {
lastAIndex[alpha][i] = tPrefLength[i] + aIndexes[b[i]][alpha].back();
}
}
}
vector<vector<int> > dp(s.size() + 1, vector<int>(s.size() + 1, INF));
dp[0][0] = -1;
for (int i = 0; i + 1 < dp.size(); ++i) {
for (int j = 0; j <= i; ++j) {
if (dp[i][j] < INF) {
update(dp[i + 1][j], dp[i][j]);
int alpha = s[i] - 'a';
int pos = dp[i][j] + 1;
int idx = lowerIndex(lastAIndex[alpha], pos);
if (idx < b.size()) {
int wordId = b[idx];
int at = lowerIndex(aIndexes[wordId][alpha], pos - tPrefLength[idx]);
int npos = tPrefLength[idx] + aIndexes[wordId][alpha][at];
update(dp[i + 1][j + 1], npos);
}
}
}
}
int res = 0;
for (int len = 0; len <= s.size(); ++len) {
if (dp[s.size()][len] < INF) {
res = len;
}
}
cout << res << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long dp[210][210][6][3];
bool kq[210][210][6][3];
long long c[210][210];
int add(long long u, long long v) { return (u + v) % 1000000007; }
int mul(long long u, long long v) { return (u * v) % 1000000007; }
int h[5] = {8, 6, 4, 2, 4};
int p[5] = {4, 2, 1, 0, 0};
long long Cal(int n, int k, int cur, int type) {
if (k == 0) return 1;
if (cur == 5) return 0;
if (kq[n][k][cur][type]) return dp[n][k][cur][type];
long long ans = 0;
kq[n][k][cur][type] = true;
if (type == 0) {
if (n == 0) return 0;
int x;
if (cur == 4)
x = 2;
else
x = 4 - cur;
for (int i = 0; i <= min(x, k); i++)
ans = add(ans, mul(Cal(n - 1, k - i, cur, 2), c[x][i]));
} else if (type == 1) {
if (n == 0) return 0;
int u = h[cur], v = p[cur];
for (int i = 0; i <= u; i++)
for (int j = 0; j <= v; j++)
if (i + 2 * j <= u && i + j <= k)
ans = add(ans,
mul(Cal(n, k - i - j, cur, 0), c[v][j] * c[u - 2 * j][i]));
} else {
ans = add(ans, Cal(n, k, cur, 1));
if (cur == 1) {
if (k >= 1)
ans = add(ans, Cal(n, k - 1, 2, 1) * 2 + Cal(n, k - 1, 4, 1) +
Cal(n, k - 1, 3, 1) * 2);
if (k >= 2)
ans = add(ans, Cal(n, k - 2, 3, 1) * 3 + Cal(n, k - 2, 5, 1) * 2);
if (k >= 3) ans = add(ans, Cal(n, k - 3, 5, 1));
} else if (cur == 2) {
if (k >= 1) ans = add(ans, Cal(n, k - 1, 3, 1) * 2 + Cal(n, k - 1, 5, 1));
if (k >= 2) ans = add(ans, Cal(n, k - 2, 5, 1));
} else if (cur == 3)
ans = add(ans, Cal(n, k - 1, 5, 1));
else if (cur == 4) {
if (k >= 1) ans = add(ans, Cal(n, k - 1, 3, 1) * 2);
if (k >= 2) ans = add(ans, Cal(n, k - 2, 5, 1));
} else {
if (k >= 1)
ans = add(ans, Cal(n, k - 1, 1, 1) * 4 + Cal(n, k - 1, 2, 1) * 4);
if (k >= 2)
ans = add(ans, Cal(n, k - 2, 2, 1) * 4 + Cal(n, k - 2, 4, 1) * 2 +
Cal(n, k - 2, 3, 1) * 8 + Cal(n, k - 2, 5, 1) * 2);
if (k >= 3)
ans = add(ans, Cal(n, k - 3, 3, 1) * 4 + Cal(n, k - 3, 5, 1) * 4);
if (k >= 4) ans = add(ans, Cal(n, k - 4, 5, 1));
}
}
dp[n][k][cur][type] = ans;
return ans;
}
int main() {
scanf("%d%d", &n, &k);
c[0][0] = 1;
for (int i = 1; i <= 10; i++)
for (int j = 0; j <= i; j++)
if (j == 0 || j == i)
c[i][j] = 1;
else
c[i][j] = add(c[i - 1][j], c[i - 1][j - 1]);
long long res = Cal(n, k, 0, 2);
for (int i = 1; i <= k; i++) res = (res * i) % 1000000007;
printf("%d\n", res);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2500 + 7;
const int M = 20;
const int inf = (int)1e9 + 7;
const long long base = (long long)1e18;
const double pi = acos(-1);
const double ep = 1e-18;
int n, m, k;
string s[N];
int dp[N][N];
int l[7], r[7];
int get(int i, int j, int u, int v) {
return dp[u][v] - dp[u][j - 1] - dp[i - 1][v] + dp[i - 1][j - 1];
}
long long calc(int i, int j, int u, int v, int st) {
long long ans = 0;
if (st == 0) {
if (j == v) {
for (int p = i; p < u + 1; p++)
for (int q = p; q < u + 1; q++)
if (get(p, j, q, j) == k) ans++;
return ans;
}
int g = (j + v) / 2;
ans += calc(i, j, u, g, 1) + calc(i, g + 1, u, v, 1);
for (int p = i; p < u + 1; p++) {
for (int t = 0; t < k + 1; t++) {
l[t] = j;
r[t] = v;
}
for (int q = p; q < u + 1; q++) {
for (int t = 0; t < k + 1; t++) {
while (l[t] <= g && get(p, l[t], q, g) > t) l[t]++;
while (r[t] > g && get(p, g + 1, q, r[t]) > t) r[t]--;
}
for (int t = 0; t < k + 1; t++) {
if (l[t] <= g && r[k - t] > g) {
if (t > 0 && t < k)
ans += (l[t - 1] - l[t]) * (r[k - t] - r[k - t - 1]);
if (k > 0) {
if (t == 0) ans += (g - l[t] + 1) * (r[k - t] - r[k - t - 1]);
if (t == k) ans += (l[t - 1] - l[t]) * (r[k - t] - g);
} else {
ans += (g - l[t] + 1) * (r[t] - g);
}
}
}
}
}
} else {
if (u == i) {
for (int p = j; p < v + 1; p++)
for (int q = p; q < v + 1; q++) {
if (get(i, p, i, q) == k) ans++;
}
return ans;
}
int g = (u + i) / 2;
ans += calc(i, j, g, v, 0) + calc(g + 1, j, u, v, 0);
for (int p = j; p < v + 1; p++) {
for (int t = 0; t < k + 1; t++) {
l[t] = i;
r[t] = u;
}
for (int q = p; q < v + 1; q++) {
for (int t = 0; t < k + 1; t++) {
while (l[t] <= g && get(l[t], p, g, q) > t) l[t]++;
while (r[t] > g && get(g + 1, p, r[t], q) > t) r[t]--;
}
for (int t = 0; t < k + 1; t++) {
if (l[t] <= g && r[k - t] > g) {
if (t > 0 && t < k)
ans += (l[t - 1] - l[t]) * (r[k - t] - r[k - t - 1]);
if (k > 0) {
if (t == 0) ans += (g - l[t] + 1) * (r[k - t] - r[k - t - 1]);
if (t == k) ans += (l[t - 1] - l[t]) * (r[k - t] - g);
} else {
ans += (g - l[t] + 1) * (r[t] - g);
}
}
}
}
}
}
return ans;
}
void solve() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < m + 1; j++)
dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] +
s[i - 1][j - 1] - '0';
}
cout << calc(1, 1, n, m, 0);
}
int main() {
solve();
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
long long A[101000 << 2], n[101000 << 2], col[101000 << 2];
void pushup(int rt) {
A[rt] = A[rt << 1] + A[rt << 1 | 1];
if (n[rt << 1] == n[rt << 1 | 1])
n[rt] = n[rt << 1];
else
n[rt] = 0;
}
void pushdown(int rt, int m) {
if (col[rt]) {
col[rt << 1] += col[rt];
col[rt << 1 | 1] += col[rt];
n[rt << 1] = n[rt];
n[rt << 1 | 1] = n[rt];
A[rt << 1] += (m - (m >> 1)) * col[rt];
A[rt << 1 | 1] += (m >> 1) * col[rt];
col[rt] = 0;
}
}
void build(int l, int r, int rt) {
col[rt] = 0;
n[rt] = 0;
A[rt] = 0;
if (l == r) {
A[rt] = 0;
n[rt] = l;
return;
}
int m = (l + r) >> 1;
build(l, m, rt << 1);
build(m + 1, r, rt << 1 | 1);
pushup(rt);
}
void updata(int L, int R, long long c, int l, int r, int rt) {
if (L <= l && r <= R && n[rt]) {
col[rt] += abs(c - n[rt]);
A[rt] += (r - l + 1) * abs(c - n[rt]);
n[rt] = c;
return;
}
pushdown(rt, r - l + 1);
int m = (l + r) >> 1;
if (L <= m) updata(L, R, c, l, m, rt << 1);
if (R > m) updata(L, R, c, m + 1, r, rt << 1 | 1);
pushup(rt);
}
long long query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return A[rt];
pushdown(rt, r - l + 1);
int m = (l + r) >> 1;
long long ret = 0;
if (L <= m) ret = ret + query(L, R, l, m, rt << 1);
if (R > m) ret = ret + query(L, R, m + 1, r, rt << 1 | 1);
return ret;
}
int main() {
int N, m, mod, l, r;
long long x;
scanf("%d%d", &N, &m);
build(1, N, 1);
while (m--) {
scanf("%d", &mod);
if (mod == 1) {
scanf("%d%d%I64d", &l, &r, &x);
updata(l, r, x, 1, N, 1);
} else {
scanf("%d%d", &l, &r);
printf("%I64d\n", query(l, r, 1, N, 1));
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void rset();
void init_test();
void solve();
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed;
cout.precision(20);
init_test();
return 0;
}
template <typename T>
void chmin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
void chmax(T& a, T b) {
if (a < b) a = b;
}
template <typename T>
void MACRO_rdv2_Init(int n, T& t) {
t.resize(n);
}
template <typename First, typename... Rest>
void MACRO_rdv2_Init(int n, First& first, Rest&... rest) {
first.resize(n);
MACRO_rdv2_Init(n, rest...);
}
template <typename T>
void MACRO_rdv2_Scan(int p, T& t) {
std::cin >> t[p];
}
template <typename First, typename... Rest>
void MACRO_rdv2_Scan(int p, First& first, Rest&... rest) {
std::cin >> first[p];
MACRO_rdv2_Scan(p, rest...);
}
template <typename T>
void wrv(const vector<T>& v) {
for (int(__ii) = (0); (__ii) < (((int)v.size())); ++(__ii)) {
if (__ii) cout << ' ';
cout << v[__ii];
}
cout << '\n';
}
template <typename T>
void wrm(const vector<vector<T>>& v) {
for (int(__ii) = (0); (__ii) < (((int)v.size())); ++(__ii)) {
for (int(__jj) = (0); (__jj) < (v[__ii].size()); ++(__jj)) {
if (__jj) cout << ' ';
cout << v[__ii][__jj];
}
cout << '\n';
}
}
template <typename T>
void sc(T& x) {
cin >> x;
}
template <typename Head, typename... Tail>
void sc(Head& head, Tail&... tail) {
cin >> head;
sc(tail...);
}
template <typename T>
void wr(const T& x) {
cout << x << '\n';
}
template <typename Head, typename... Tail>
void wr(const Head& head, const Tail&... tail) {
cout << head << ' ';
wr(tail...);
}
template <typename T>
void wrf(const T& x) {
cout << x << endl;
}
template <typename Head, typename... Tail>
void wrf(const Head& head, const Tail&... tail) {
cout << head << ' ';
wrf(tail...);
}
template <typename T>
void debug_out(const T& x) {
cerr << x << '\n';
}
template <typename Head, typename... Tail>
void debug_out(const Head& head, const Tail&... tail) {
cerr << head << ' ';
debug_out(tail...);
}
template <typename... T>
void err(const T&... cod) {
wr(cod...);
exit(0);
}
void solve() {
int n, m;
sc(n, m);
chmin(m, 500 * 1000);
vector<int> a(n);
for (int(__ii) = (0); (__ii) < (n); ++(__ii)) cin >> a[__ii];
int o = 0, e = 0;
for (int(i) = (0); (i) < (n); ++(i)) {
o += a[i] % 2;
e += a[i] % 2 ^ 1;
}
int ans = 0;
set<int> seen, avail[2];
for (int(i) = (1); (i) < (m + 1); ++(i)) avail[i % 2].insert(i);
for (int(i) = (0); (i) < (n); ++(i)) avail[a[i] % 2].erase(a[i]);
for (int(i) = (0); (i) < (n); ++(i)) {
if (seen.count(a[i])) {
++ans;
o -= a[i] % 2;
e -= a[i] % 2 ^ 1;
if (o < e) {
if (avail[1].empty()) err(-1);
a[i] = *avail[1].begin();
avail[1].erase(avail[1].begin());
++o;
} else {
if (avail[0].empty()) err(-1);
a[i] = *avail[0].begin();
avail[0].erase(avail[0].begin());
++e;
}
}
seen.insert(a[i]);
}
for (int(i) = (0); (i) < (n); ++(i)) {
if (o < e && (a[i] % 2 ^ 1)) {
if (avail[1].empty()) err(-1);
++ans;
a[i] = *avail[1].begin();
avail[1].erase(avail[1].begin());
++o;
--e;
}
if (o > e && (a[i] % 2)) {
if (avail[0].empty()) err(-1);
++ans;
a[i] = *avail[0].begin();
avail[0].erase(avail[0].begin());
++e;
--o;
}
}
wr(ans);
wrv(a);
}
void init_test() {
int qq = 1;
while (qq--) solve();
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
long long ex(long long b, long long st) {
long long ans = 1;
long long now = b;
for (long long i = 0; i < 40; i++) {
long long ba = (1LL << i) & st;
if (ba == 0) {
now *= now;
now %= MOD;
continue;
}
ans *= now;
ans %= MOD;
now *= now;
now %= MOD;
}
return ans;
}
long long res(long long a, long long b) { return (ex(b, MOD - 2) * a) % MOD; }
signed main() {
ios_base::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
if (n + 1 <= k) {
cout << 0 << endl;
return 0;
}
long long L = 0;
vector<long long> fact;
fact.push_back(1);
for (long long i = 1; i < 2e6; i++) {
fact.push_back((fact[i - 1] * i) % MOD);
}
long long old = 0;
vector<long long> f(n + 1), s(n + 1);
for (long long i = 0; i <= k + 1; i++) {
f[i] = 0;
s[i] = 0;
}
for (long long i = k + 2; i <= n; i++) {
long long N = L * (i - 1);
N += L;
N += fact[i - 2] * (i - k - 1);
old *= (i - 2);
long long YY = (f[i - k - 2] + s[i - k - 2]);
YY *= fact[i - 2];
YY %= MOD;
YY = res(YY, fact[i - k - 2]);
old += YY;
old %= MOD;
s[i - 1] = ((fact[i - 2] * (i - k - 1) - old) % MOD + MOD) % MOD;
N -= (old);
L = (N % MOD + MOD) % MOD;
f[i] = L % MOD;
}
cout << L << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
bool __hack = std::ios::sync_with_stdio(false);
auto __hack1 = cin.tie(nullptr);
namespace template_util {
constexpr int bytecount(uint64_t x) { return x ? 1 + bytecount(x >> 8) : 0; }
template <int N>
struct bytetype {};
template <>
struct bytetype<4> {};
template <>
struct bytetype<3> {};
template <>
struct bytetype<2> {};
template <>
struct bytetype<1> {};
template <>
struct bytetype<0> {};
template <uint64_t N>
struct minimal_uint : bytetype<bytecount(N)> {};
} // namespace template_util
template <class T, class F, class... Args,
typename enable_if<is_integral<T>::value>::type* = nullptr>
inline T bs01(T l, T r, F pred, Args... args) {
assert(!pred(l, args...) && pred(r, args...));
while (l + 1 < r) {
T mid = (l + r) / 2;
if (pred(mid, args...)) {
r = mid;
} else {
l = mid;
}
}
return r;
}
template <class T>
T next(istream& in) {
T ret;
in >> ret;
return ret;
}
void solve(istream& in, ostream& out) {
int n = next<int>(in);
int64_t c0 = next<int64_t>(in);
int64_t c1 = next<int64_t>(in);
if (c0 > c1) {
swap(c0, c1);
}
if (c0 == 0) {
out << (n - 1) * c1;
return;
}
auto f = [&](int64_t k) {
int64_t cnt = 0, sumVals = 0;
for (int i = 0; c1 * i <= k && cnt < n; ++i) {
int64_t maxj = (k - c1 * i) / c0;
if (i == 0) {
cnt += maxj + 1;
sumVals += (maxj * c0) * (maxj + 1) / 2;
} else {
int64_t c = 1;
for (int j = 0; c1 * i + c0 * j <= k && cnt < n; ++j) {
cnt += c;
sumVals += c * (c1 * i + c0 * j);
c = c * (i + j + 1) / (j + 1);
}
}
}
return make_pair(cnt, sumVals);
};
int64_t lastVal = bs01(0LL, 1000000000000000000LL,
[&](int64_t k) { return f(k).first >= n; });
auto tmp = f(lastVal - 1);
out << tmp.second + lastVal * (n - 1 - tmp.first) + (n - 1) * (c0 + c1);
}
int main() {
solve(cin, cout);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int Inf = 1e9 + 1;
const int Mod = 1e9 + 7;
const double eps = 1e-15;
const int pw = 257;
int calc(int m) {
int res = m;
while (m) res += m % 10, m /= 10;
return res;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> v;
for (int i = n; i >= max(1, n - 81); --i) {
if (calc(i) == n) v.push_back(i);
}
cout << int(v.size()) << "\n";
reverse(v.begin(), v.end());
for (int i = 0; i < int(v.size()); ++i) cout << v[i] << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int sz = 0;
int pos[1111];
int p[1111];
int head[1111];
int len[1111];
int n, k;
bool tr;
int knum;
int can[2222];
int doit(int x) {
if (x == k) tr = 1;
if (p[x] == 0) return pos[x];
pos[p[x]] = pos[x] + 1;
return doit(p[x]);
}
int main() {
int i, j;
cin >> n >> k;
for (i = 1; i <= n; ++i) {
int x;
cin >> x;
if (x == 0) {
head[++sz] = i;
} else
p[x] = i;
}
for (i = 1; i <= sz; ++i) {
tr = 0;
pos[head[i]] = 1;
len[i] = doit(head[i]);
if (tr) knum = i;
}
can[0] = 1;
for (i = 1; i <= sz; ++i) {
if (i == knum) continue;
for (j = 1000; j >= 0; --j) {
if (can[j]) {
can[j + len[i]] = 1;
}
}
}
for (i = 0; i <= 1000; ++i) {
if (can[i]) {
cout << i + pos[k] << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
class sp {
public:
int q;
sp *w;
sp(int q1, sp *w1) {
q = q1;
w = w1;
}
};
sp *a1[26];
int f[26];
bool l(int q) {
if (f[q] > 0) return 1;
f[q] = 1;
for (sp *c = a1[q]; c; c = c->w)
if (l(c->q)) return 1;
f[q] = -2;
return 0;
}
int main() {
int q, w, e, r, d[26], h[26];
bool s[26][26];
char a[100][101];
for (w = 0; w < 26; w++) {
a1[w] = 0;
d[w] = 0;
f[w] = -1;
for (e = 0; e < 26; e++) s[w][e] = 1;
}
cin >> q;
for (w = 0; w < q; w++) {
cin >> a[w];
if (w) {
for (e = 0; (a[w][e] == a[w - 1][e]) && (a[w][e]); e++)
;
if (a[w - 1][e] == 0) continue;
if (a[w][e] == 0) {
cout << "Impossible";
return 0;
}
r = a[w][e] - 97;
e = a[w - 1][e] - 97;
if (s[e][r]) {
s[e][r] = 0;
d[r]++;
a1[e] = new sp(r, a1[e]);
}
}
}
r = 0;
for (w = 0; w < 26; w++) {
if ((f[w] == -1) && (l(w))) {
cout << "Impossible";
return 0;
}
if (d[w] == 0) {
h[r] = w;
r++;
}
}
sp *c;
for (e = 0; e < r; e++)
for (c = a1[h[e]]; c; c = c->w) {
d[c->q]--;
if (d[c->q] == 0) {
h[r] = c->q;
r++;
}
}
for (e = 0; e < r; e++) cout << (char)(h[e] + 97);
return 0;
}
| 8 |
#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 {i, j};
}
template <class c>
auto dud(c *x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug &operator<<(const c &) {
return *this;
}
};
const int N = 1007;
int px[N];
int py[N];
const int M = 2007;
vector<int> G[M];
int ax[M];
int bx[M];
int ay[M];
int by[M];
int skoj[M];
int odw[M];
int strona[M];
int cnt;
int n;
int rozm;
bool zawiera(int i, int x, int y) {
if (ax[i] == bx[i]) {
return min(ay[i], by[i]) < y && max(ay[i], by[i]) > y;
} else
return min(ax[i], bx[i]) < x && max(ax[i], bx[i]) > x;
}
bool dfs0(int v) {
odw[v] = 1;
for (int u : G[v]) {
if (!skoj[u] || (!odw[skoj[u]] && dfs0(skoj[u]))) {
skoj[v] = u;
skoj[u] = v;
return true;
}
}
return false;
}
void dfs1(int v) {
odw[v] = 1;
if (strona[v] == 0) {
for (int u : G[v]) {
if (!odw[u]) dfs1(u);
}
} else if (skoj[v] && !odw[skoj[v]]) {
dfs1(skoj[v]);
}
}
void turbomatching() {
rozm = 0;
int stop = 1;
while (stop) {
stop = 0;
for (int i = 1; i <= cnt; ++i) odw[i] = 0;
for (int i = 1; i <= cnt; ++i) {
if (!odw[i] && !skoj[i]) {
int ll = dfs0(i);
stop |= ll;
rozm += ll;
}
}
}
}
vector<int> znajdzZbior() {
for (int i = 1; i <= cnt; ++i) odw[i] = 0;
for (int i = 1; i <= cnt; ++i) {
if (!odw[i] && strona[i] == 0 && !skoj[i]) {
dfs1(i);
}
}
vector<int> res;
for (int i = 1; i <= cnt; ++i) {
if (strona[i] == 0) {
if (odw[i]) res.push_back(i);
} else {
if (!odw[i]) res.push_back(i);
}
}
assert((int)res.size() == cnt - rozm);
return res;
}
struct odcinek {
int xa, ya, xb, yb;
odcinek(int xa, int ya, int xb, int yb) : xa(xa), ya(ya), xb(xb), yb(yb) {}
};
int main() {
scanf("%d", &n);
vector<pair<int, int>> tab;
for (int i = 1; i <= n; ++i) {
scanf("%d", &px[i]);
scanf("%d", &py[i]);
tab.push_back({px[i], py[i]});
}
sort(tab.begin(), tab.end());
for (int i = 1; i < (int)tab.size(); ++i) {
if (tab[i].first == tab[i - 1].first) {
cnt++;
ax[cnt] = tab[i].first;
bx[cnt] = tab[i].first;
ay[cnt] = tab[i - 1].second;
by[cnt] = tab[i].second;
strona[cnt] = 0;
}
}
for (auto &u : tab) swap(u.first, u.second);
sort(tab.begin(), tab.end());
for (int i = 1; i < (int)tab.size(); ++i) {
if (tab[i].first == tab[i - 1].first) {
cnt++;
ay[cnt] = tab[i].first;
by[cnt] = tab[i].first;
ax[cnt] = tab[i - 1].second;
bx[cnt] = tab[i].second;
strona[cnt] = 1;
}
}
for (auto &u : tab) swap(u.first, u.second);
for (int i = 1; i <= cnt; ++i) {
for (int j = 1; j <= cnt; ++j) {
int px, py;
px = py = -1;
if (ax[i] == bx[i]) px = ax[i];
if (ax[j] == bx[j]) px = ax[j];
if (ay[i] == by[i]) py = ay[i];
if (ay[j] == by[j]) py = ay[j];
if (px == -1 || py == -1) continue;
if (zawiera(i, px, py) && zawiera(j, px, py)) {
G[i].push_back(j);
G[j].push_back(i);
}
}
}
turbomatching();
vector<int> zb = znajdzZbior();
vector<odcinek> pionowe, poziome;
for (int u : zb) {
if (strona[u] == 0)
pionowe.emplace_back(ax[u], min(ay[u], by[u]), ax[u], max(ay[u], by[u]));
}
for (int u : zb) {
if (strona[u] == 1)
poziome.emplace_back(min(ax[u], bx[u]), ay[u], max(ax[u], bx[u]), ay[u]);
}
for (int i = 1; i <= n; ++i) {
pionowe.emplace_back(px[i], py[i], px[i], py[i]);
poziome.emplace_back(px[i], py[i], px[i], py[i]);
}
sort(pionowe.begin(), pionowe.end(), [](odcinek A, odcinek B) -> bool {
if (A.xa == B.xa) return make_pair(A.ya, A.yb) < make_pair(B.ya, B.yb);
return A.xa < B.xa;
});
sort(poziome.begin(), poziome.end(), [](odcinek A, odcinek B) -> bool {
if (A.ya == B.ya) return make_pair(A.xa, A.xb) < make_pair(B.xa, B.xb);
return A.ya < B.ya;
});
vector<odcinek> wPionowe, wPoziome;
for (auto u : pionowe) {
int yy = u.ya;
while (!wPionowe.empty()) {
auto p = wPionowe.back();
if (p.xa == u.xa && p.yb == u.ya) {
yy = p.ya;
wPionowe.pop_back();
} else
break;
}
wPionowe.emplace_back(u.xa, yy, u.xb, u.yb);
}
for (auto u : poziome) {
int xx = u.xa;
while (!wPoziome.empty()) {
auto p = wPoziome.back();
if (p.ya == u.ya && p.xb == u.xa) {
xx = p.xa;
wPoziome.pop_back();
} else
break;
}
wPoziome.emplace_back(xx, u.ya, u.xb, u.yb);
}
cout << wPoziome.size() << endl;
for (auto u : wPoziome) {
cout << u.xa << ' ' << u.ya << ' ' << u.xb << ' ' << u.yb << '\n';
}
cout << wPionowe.size() << endl;
for (auto u : wPionowe) {
cout << u.xa << ' ' << u.ya << ' ' << u.xb << ' ' << u.yb << '\n';
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int N = 800005;
int head[N], nxt[N << 3], to[N << 3], from[N << 3], no = 0;
void link(int a, int b) {
nxt[no] = head[a];
from[no] = a;
to[no] = b;
head[a] = no++;
}
void addor(int a, int b) {
link(a ^ 1, b);
link(b ^ 1, a);
}
void addandor(int a, int b, int c, int d) {
addor(a, c);
addor(a, d);
addor(b, c);
addor(b, d);
}
void addxnor(int a, int b) {
link(a, b);
link(b, a);
link(a ^ 1, b ^ 1);
link(b ^ 1, a ^ 1);
}
void must0(int a) { link(a, a ^ 1); }
void must1(int a) { link(a ^ 1, a); }
int dfsnum[N], low[N], ccnum[N], cnum = 0, dfsn = 0, chead[N];
bool instack[N];
stack<int> scc;
void dfs(int idx) {
dfsnum[idx] = low[idx] = dfsn++;
scc.push(idx);
instack[idx] = 1;
for (int i = head[idx]; ~i; i = nxt[i]) {
int nx = to[i];
if (dfsnum[nx] == -1) dfs(nx);
if (instack[nx]) low[idx] = min(low[idx], low[nx]);
}
if (dfsnum[idx] == low[idx]) {
while (scc.top() != idx) {
int v = scc.top();
scc.pop();
ccnum[v] = cnum;
instack[v] = 0;
}
scc.pop();
chead[cnum] = idx;
ccnum[idx] = cnum;
chead[cnum] = idx;
instack[idx] = 0;
cnum++;
}
}
bool vis[N];
int cval[N];
bool src[N];
vector<vector<int>> adj;
void topo(int idx) {
if (vis[idx]) return;
vis[idx] = 1;
for (auto x : adj[idx]) {
topo(x);
}
if (cval[idx] == -1) {
cval[idx] = 1;
cval[ccnum[chead[idx] ^ 1]] = 0;
}
}
int main() {
memset(head, -1, sizeof head);
int n;
cin >> n;
vector<pair<string, string>> arr(n);
for (int i = 0; i < n; i++) {
string x, y, a = "", b = "";
cin >> x >> y;
b += x[0];
b += x[1];
b += y[0];
a += x[0];
a += x[1];
a += x[2];
arr[i].first = a;
arr[i].second = b;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
if (arr[i].first == arr[j].first) {
addxnor(i << 1, j << 1);
link((i << 1) ^ 1, (i << 1));
link((j << 1) ^ 1, (j << 1));
}
if (arr[i].first == arr[j].second) addxnor(i << 1, j << 1);
if (arr[i].second == arr[j].first) addxnor(i << 1, j << 1);
if (arr[i].second == arr[j].second) {
link((i << 1), (j << 1) ^ 1);
link((j << 1), (i << 1) ^ 1);
}
}
}
memset(dfsnum, -1, sizeof dfsnum);
n <<= 1;
for (int i = 0; i < n; i++) {
if (dfsnum[i] == -1) dfs(i);
}
for (int i = 0; i < n; i += 2) {
if (ccnum[i] == ccnum[i ^ 1]) {
cout << "NO";
return 0;
}
}
cout << "YES\n";
adj.resize(cnum);
memset(cval, -1, sizeof cval);
for (int i = 0; i < no; ++i) {
int a = from[i], b = to[i];
if (ccnum[a] != ccnum[b]) {
src[ccnum[b]] = 1;
adj[ccnum[a]].push_back(ccnum[b]);
}
}
for (int i = n - 1; i >= 0; i--) {
if (!src[ccnum[i]]) topo(ccnum[i]);
}
for (int i = 0; i < n; i += 2) {
int id = cval[ccnum[i]];
if (id)
cout << arr[i >> 1].second << "\n";
else
cout << arr[i >> 1].first << "\n";
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int ar[1000005], ans[1000006], xxx[1000007][10], tt[1000005];
long long cheak(long long x) {
long long i, ans = 1, a;
while (x) {
a = x % 10;
x /= 10;
if (a > 0) ans *= a;
}
return ans;
}
int main() {
long long int i, j, k, n, m = 0, x = 0, x2, a = 1, b, c, l = 0;
for (i = 1000000; i >= 1; i--) {
l = 0;
tt[l++] = i;
if (ar[i])
ans[i] = ar[i];
else {
a = i;
while (1) {
x = cheak(a);
a = x;
if (x <= 9) {
ans[i] = x;
for (j = 0; j < l; j++) ar[tt[j]] = x;
break;
}
tt[l++] = x;
}
}
}
for (i = 1; i <= 1000000; i++) {
x = ans[i];
for (j = 1; j <= 9; j++) {
if (x == j)
xxx[i][j] = xxx[i - 1][j] + 1;
else
xxx[i][j] = xxx[i - 1][j];
}
}
cin >> n;
while (n--) {
cin >> a >> b >> c;
cout << xxx[b][c] - xxx[a - 1][c] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
bool prime[1000000 + 1];
void seive() {
long long int N = 1e6 + 1;
memset(prime, true, sizeof(prime));
prime[0] = false;
prime[1] = false;
for (long long int i = 2; i * i <= N; i++) {
if (prime[i]) {
for (long long int j = i * i; j <= N; j += i) {
prime[j] = false;
}
}
}
}
bool isPowerOfTwo(int x) { return (x && !(x & (x - 1))); }
bool is_prime(int n) {
if (n == 1) return false;
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
long long int ans = 1;
int const G = 100005;
int vst[G];
vector<int> edge[G];
long long int ar[G];
long long int bfs(int sv) {
queue<int> pn;
pn.push(sv);
vst[sv] = 1;
long long int temp = ar[sv];
while (!pn.empty()) {
int x = pn.front();
vst[x] = 1;
pn.pop();
for (int i = 0; i < edge[x].size(); i++) {
if (!vst[edge[x][i]]) {
pn.push(edge[x][i]);
temp = ((temp > ar[edge[x][i]]) ? ar[edge[x][i]] : temp);
}
}
}
return temp;
}
void hemant() {
int n;
cin >> n;
vector<pair<int, int>> ar;
ar.push_back({0, 0});
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
ar.push_back({x, i});
}
sort(ar.begin(), ar.end());
int l = n + 1;
int r = 0;
for (int i = 1; i <= n; i++) {
l = ((l > ar[i].second) ? ar[i].second : l);
r = (r < ar[i].second ? ar[i].second : r);
long long int k = r - l + 1;
if (k == i)
cout << "1";
else
cout << "0";
}
cout << "\n";
}
int main() {
int t = 1;
cin >> t;
while (t--) {
hemant();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long SIZE = (long long)1e18;
int remains = 200000;
vector<set<pair<long long, long long>>> evals;
long long need;
vector<long long> resLeft;
vector<long long> resRight;
long long realEval(int fid, long long x) {
--remains;
assert(remains >= 0);
printf("? %d %lld\n", (fid + 1), x);
fflush(stdout);
long long realY;
scanf("%lld", &realY);
return realY;
}
bool compareAt(int fid, long long x, long long y) {
set<pair<long long, long long>>& known = evals[fid];
auto next = known.lower_bound(pair<long long, long long>(x + 1, -1));
auto prev = next;
--prev;
assert(prev->first >= 0);
assert(prev->first <= x);
assert(next->first > x);
assert(next->first <= SIZE + 1);
if (prev->second >= y) return true;
if (prev->second + x - prev->first < y) return false;
if (next->second < y) return false;
if (next->second + x - next->first >= y) return true;
long long realY = realEval(fid, x);
known.insert(pair<long long, long long>(x, realY));
return realY >= y;
}
void rec(vector<int>& ids, long long left, long long right, long long base) {
if (ids.size() == 1) {
resLeft[ids[0]] = left;
resRight[ids[0]] = right;
return;
}
int n = ids.size();
int n1 = n / 2;
long long interesting = base + n1 * need;
long long searchLeft = 0;
long long searchRight = SIZE;
while (searchRight - searchLeft > 1) {
long long searchMiddle = (searchLeft + searchRight) / 2;
int count = 0;
int togo = n;
for (int x : ids) {
if (compareAt(x, searchMiddle, interesting)) {
++count;
}
if (count >= n1) break;
--togo;
if (count + togo < n1) break;
}
if (count >= n1) {
searchRight = searchMiddle;
} else {
searchLeft = searchMiddle;
}
}
vector<int> ids1(n1);
vector<int> ids2(n - n1);
int p1 = 0;
int p2 = 0;
for (int x : ids) {
if (compareAt(x, searchLeft, interesting)) {
ids1[p1++] = x;
} else if (!compareAt(x, searchRight, interesting)) {
ids2[p2++] = x;
}
}
for (int x : ids) {
if (compareAt(x, searchLeft, interesting)) {
} else if (!compareAt(x, searchRight, interesting)) {
} else if (p1 == ids1.size()) {
ids2[p2++] = x;
} else {
ids1[p1++] = x;
}
}
rec(ids1, left, searchRight, base);
rec(ids2, searchRight, right, interesting);
}
int main() {
int n;
scanf("%d", &n);
scanf("%lld", &need);
need /= n;
for (int i = 0; i < n; ++i) {
set<pair<long long, long long>> pts;
pts.insert(pair<long long, long long>(0, 0));
pts.insert(pair<long long, long long>(SIZE, need * n));
pts.insert(pair<long long, long long>(SIZE + 1, need * n));
evals.push_back(pts);
}
vector<int> ids;
for (int i = 0; i < n; ++i) ids.push_back(i);
resLeft.resize(n);
resRight.resize(n);
rec(ids, 0, SIZE, 0);
for (int i = 0; i < n; ++i) {
assert(realEval(i, resRight[i]) - realEval(i, resLeft[i]) >= need);
}
printf("!\n");
for (int i = 0; i < n; ++i) {
printf("%lld %lld\n", resLeft[i], resRight[i]);
}
fflush(stdout);
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
char str[1000005];
int main() {
int i, j;
while (scanf("%s", &str) != EOF) {
int n = strlen(str);
int k = 0;
long long sum = 1;
for (i = 1; i < n; i++) {
if ((str[i] - '0') + (str[i - 1] - '0') == 9) {
k++;
} else {
if (k % 2 == 0) {
sum *= (k + 2) / 2;
}
k = 0;
}
if ((i + 1) == n) {
if (k % 2 == 0) {
sum *= (k + 2) / 2;
}
}
}
cout << sum << endl;
}
return 0;
}
| 7 |
#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 W, H, x1, y1, x2, y2, w, h, ans = INT_MAX, a = 0;
cin >> W >> H >> x1 >> y1 >> x2 >> y2 >> w >> h;
if (x2 - x1 + w <= W) {
ans = min(ans, max(a, w - x1));
ans = min(ans, max(a, x2 - (W - w)));
}
if (y2 - y1 + h <= H) {
ans = min(ans, max(a, h - y1));
ans = min(ans, max(a, y2 - (H - h)));
}
if (ans == INT_MAX)
cout << -1;
else
cout << fixed << setprecision(9) << (double)ans;
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a[3];
cin >> a[0] >> a[1] >> a[2];
sort(a, a + 3);
cout << ceil(((a[1] - a[0]) / 2) + ((a[2] - a[0]) / 2) + ((a[2] - a[1]) / 2))
<< endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
int a[201111], b[201111], n, i, l, r, sum, t;
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 1; i < n; i++) {
t = i - 1;
for (l = 1; l <= t; l = r + 1) {
r = t / (t / l);
if (a[i] < a[t / l]) b[l]++, b[r + 1]--;
}
if (a[i] < a[0]) b[i]++;
}
for (i = 1; i < n; i++) printf("%d ", sum += b[i]);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int coinUse[200100];
int coinCount[200100];
vector<int> coin;
int main() {
int c;
scanf("%d", &c);
for (int i = 0; i <= c; i++) coinCount[i] = 0;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
coinCount[x]++;
coin.push_back(x);
}
sort(coin.begin(), coin.end());
int nowCoin = -1;
for (int i = 0; i <= c; i++) {
nowCoin = coinCount[i] == 0 ? nowCoin : i;
coinUse[i] = nowCoin;
}
for (int newC = 1; newC < c; newC++) {
int moneyLeft = c;
int coinWillUse = max(newC, coinUse[c]);
coinCount[newC]++;
bool useNewCoin = false;
while (true) {
if (moneyLeft <= 0 || coinWillUse == -1) break;
moneyLeft -=
min(coinCount[coinWillUse], moneyLeft / coinWillUse) * coinWillUse;
if (coinWillUse == newC) useNewCoin = true;
coinWillUse = min(coinUse[moneyLeft], coinUse[coinWillUse - 1]);
if (!useNewCoin && moneyLeft >= newC && coinWillUse <= newC) {
coinWillUse = newC;
}
}
if (moneyLeft != 0) {
printf("%d", newC);
return 0;
}
coinCount[newC]--;
}
printf("Greed is good");
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string a, b, c;
cin >> a >> b >> c;
int flag = 1;
for (int i = 0; i < a.size(); i++) {
if (a[i] != c[i] && b[i] != c[i]) {
cout << "NO" << endl;
flag = 0;
break;
}
}
if (flag) {
cout << "YES" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long lastpos[1000000], rankpos[1000000], rankinv[1000000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t, n, i, j, c, k, m, x, y, f, ans;
cin >> n;
vector<long long> adj[n + 5];
vector<pair<long long, long long> > v(n + 1);
for (i = 1; i <= n; i++) {
lastpos[i] = 0;
rankpos[i] = 0;
}
for (i = 1; i <= n; i++) {
cin >> v[i].first >> v[i].second;
adj[v[i].first].push_back(i);
lastpos[v[i].first] = i;
}
c = 1;
for (i = n; i > 0; i--) {
if (rankpos[v[i].first] == 0) rankpos[v[i].first] = c++;
}
for (i = 1; i <= n; i++) {
rankinv[rankpos[i]] = i;
}
c--;
cin >> m;
while (m--) {
vector<pair<long long, long long> > temp;
cin >> k;
set<long long> s;
for (i = 0; i < k; i++) {
cin >> x;
if (rankpos[x] == 0) continue;
s.insert(x);
temp.push_back({rankpos[x], x});
}
sort((temp).begin(), (temp).end());
long long mex = 1;
for (i = 0; i < temp.size(); i++) {
if (rankpos[temp[i].second] == mex)
mex++;
else
break;
}
if (c == s.size()) {
cout << "0 0 \n";
continue;
}
x = rankinv[mex];
if (s.size() == c - 1) {
cout << v[adj[x][0]].first << " " << v[adj[x][0]].second << "\n";
continue;
}
mex++;
while (s.find(rankinv[mex]) != s.end()) {
mex++;
}
long long idx;
idx = *upper_bound((adj[x]).begin(), (adj[x]).end(), lastpos[rankinv[mex]]);
cout << x << " " << v[idx].second << "\n";
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100020;
int n, k;
unsigned long long tp[Maxn];
unsigned long long solve(int num, multiset<int>& S) {
int cnt = 1;
unsigned long long ret = 1ULL << 63;
for (multiset<int>::iterator it = S.begin(); it != S.end(); cnt++, it++) {
tp[cnt] = *it;
if (cnt >= num) ret = min(ret, tp[cnt] - tp[cnt - num + 1]);
}
if (ret & 1) ret++;
ret = max(ret, 2ULL);
return ret;
}
int main() {
scanf("%d%d", &n, &k);
vector<pair<int, int> > V;
for (int i = 1; i <= n; i++) {
int xx1, yy1, xx2, yy2;
scanf("%d%d%d%d", &xx1, &yy1, &xx2, &yy2);
xx1 <<= 1, yy1 <<= 1, xx2 <<= 1, yy2 <<= 1;
V.push_back(
pair<int, int>(xx1 + ((xx2 - xx1) >> 1), yy1 + ((yy2 - yy1) >> 1)));
}
if (k == n - 1) {
cout << 1 << endl;
return 0;
}
multiset<int> S;
unsigned long long ans = 1ULL << 63;
sort(V.begin(), V.end());
for (int i = 0; i < V.size(); i++) S.insert(V[i].second);
for (int i = 0; i <= k; i++)
for (int j = 0; j + i <= k; j++) {
if (n - j - 1 < i) continue;
int X = V[n - j - 1].first - V[i].first;
if (X & 1) X++;
X = max(X, 2);
for (int p = 0; p < i; p++) S.erase(S.lower_bound(V[p].second));
for (int p = n - j; p < V.size(); p++)
S.erase(S.lower_bound(V[p].second));
ans = min(ans, solve(n - k, S) * 1ULL * X);
for (int p = 0; p < i; p++) S.insert(V[p].second);
for (int p = n - j; p < V.size(); p++) S.insert(V[p].second);
}
cout << (ans >> 2) << endl;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
vector<int> b(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
int l = 0;
int r = n - 1;
int cnt = 0;
vector<int> test;
while (l < n && r >= 0) {
int num = a[l] + b[r];
if (num >= k) {
test.push_back(num);
l++;
r--;
} else {
l++;
}
}
cout << 1 << " " << test.size() << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec) os << v << ", ";
os << "]";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "deq[";
for (auto v : vec) os << v << ", ";
os << "]";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &vec) {
os << "{";
for (auto v : vec) os << v << ", ";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &vec) {
os << "{";
for (auto v : vec) os << v << ", ";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &vec) {
os << "{";
for (auto v : vec) os << v << ", ";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &vec) {
os << "{";
for (auto v : vec) os << v << ", ";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << "(" << pa.first << ", " << pa.second << ")";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
os << "{";
for (auto v : mp) os << v.first << ": " << v.second << ", ";
os << "}";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp) {
os << "{";
for (auto v : mp) os << v.first << ": " << v.second << ", ";
os << "}";
return os;
}
template <typename T>
void ndarray(vector<T> &vec, int len) {
vec.resize(len);
}
template <typename T, typename... Args>
void ndarray(vector<T> &vec, int len, Args... args) {
vec.resize(len);
for (auto &v : vec) ndarray(v, args...);
}
template <typename T>
bool chmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T>
bool chmin(T &m, const T q) {
if (q < m) {
m = q;
return true;
} else
return false;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first - r.first, l.second - r.second);
}
int mid(int dist1, int dist2) {
if (dist1 >= 0 && dist2 >= 0) {
return min(dist1, dist2);
} else if (dist1 < 0 && dist2 < 0) {
return max(dist1, dist2);
} else {
return 0;
}
}
void dig(int x1, int y1, int x2, int y2, set<pair<int, int>> &seen) {
for (int i = x1; i <= x2; i++) {
seen.insert({i, y1});
}
for (int i = x1; i >= x2; i--) {
seen.insert({i, y1});
}
for (int i = y1; i <= y2; i++) {
seen.insert({x2, i});
}
for (int i = y1; i >= y2; i--) {
seen.insert({x2, i});
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int x1, y1, x2, y2, x3, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
int xdist1 = x2 - x1, ydist1 = y2 - y1;
int xdist2 = x3 - x1, ydist2 = y3 - y1;
int midx = x1 + mid(xdist1, xdist2);
int midy = y1 + mid(ydist1, ydist2);
set<pair<int, int>> seen;
dig(x1, y1, midx, midy, seen);
dig(midx, midy, x2, y2, seen);
dig(midx, midy, x3, y3, seen);
cout << seen.size() << '\n';
for (auto i : seen) {
cout << i.first << ' ' << i.second << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[123456];
int sk1[123456];
int sk2[123456];
void print(int n) {
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < sk1[i]; ++j) cout << '(';
cout << a[i];
for (int j = 0; j < sk2[i]; ++j) cout << ')';
if (i != n) cout << "->";
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
if (a[n] == 1) {
cout << "NO";
return 0;
}
sk1[1]++;
sk2[n - 1]++;
if (n == 3) {
if (a[1] == 1 && a[2] == 0)
cout << "NO";
else
cout << "YES\n" << a[1] << "->" << a[2] << "->" << a[3];
return 0;
}
if (n == 2) {
if (a[1] == 1)
cout << "YES\n" << a[1] << "->" << a[2];
else
cout << "NO";
return 0;
}
if (n == 1) {
if (a[1])
cout << "NO";
else
cout << "YES\n" << a[1];
return 0;
}
bool ok = false;
for (int i = 1; i <= n - 2; ++i) {
if (a[i] == 0) {
sk1[i + 1]++;
sk2[n - 1]++;
sk1[i]++;
sk2[n - 1]++;
if (i != 1) {
sk1[1]++;
sk2[i - 1]++;
}
ok = true;
break;
}
}
if (ok) {
cout << "YES\n";
print(n);
return 0;
}
if (a[n - 1] == 0) {
cout << "NO";
return 0;
}
cout << "YES\n";
print(n);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1000000;
const int max_m = 1000000;
const int max_bit = 32;
int n, m, v, a[max_bit] = {0}, b[max_bit] = {0}, i, j, r = 0;
int main() {
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) {
scanf("%d", &v);
for (j = 0; j < max_bit; j++)
if ((1 << j) & v) a[j]++;
}
for (i = 0; i < m; i++) scanf("%d", &v), b[v]++;
while (true) {
i = 0;
while (i < max_bit && b[i] == 0) i++;
b[i]--;
while (i < max_bit && a[i] == 0) a[i]++, i++;
if (i == max_bit) break;
a[i]--;
r++;
}
printf("%d\n", r);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long int a[1010][1010];
long long int dp[1010][1010];
long long int v[1010][1010];
long long int n, m;
long long int f;
long long int dx[4] = {0, 1, 0, -1};
long long int dy[4] = {1, 0, -1, 0};
void dfs(long long int x, long long int y) {
if (dp[x][y] != -1) {
return;
}
v[x][y] = 1;
dp[x][y] = 1;
for (long long int i = 0; i < 4; i++) {
long long int xx = x + dx[i];
long long int yy = y + dy[i];
if (xx <= 0 || xx > n || yy <= 0 || yy > m ||
a[xx][yy] != (1 + a[x][y]) % 4) {
continue;
}
if (v[xx][yy]) {
f = 1;
return;
}
dfs(xx, yy);
if (f) {
return;
}
dp[x][y] = max(dp[x][y], 1 + dp[xx][yy]);
}
v[x][y] = 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
char c;
cin >> c;
if (c == 'D') a[i][j] = 0;
if (c == 'I') a[i][j] = 1;
if (c == 'M') a[i][j] = 2;
if (c == 'A') a[i][j] = 3;
}
}
memset(dp, -1, sizeof(dp));
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
if (dp[i][j] == -1) {
dfs(i, j);
}
if (f) {
cout << "Poor Inna!" << endl;
return 0;
}
}
}
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
if (!a[i][j]) {
ans = max(ans, dp[i][j] / 4);
}
}
}
if (!ans) {
cout << "Poor Dima!" << endl;
} else {
cout << ans << endl;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e18;
const long long mod = (long long)1e9 + 7;
const double pi = acos(-1.0);
const double eps = (double)1e-9;
const int dx[] = {0, 0, 1, 0, -1};
const int dy[] = {0, 1, 0, -1, 0};
const int L = 200500;
const int N = 1000000;
const int M = 1000500;
long long fact[L], rv[L];
int n, k, q, ans, cnt[M], g[M];
inline long long bp(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
inline long long C(int n, int k) {
if (n < k) return 0;
return fact[n] * rv[n - k] % mod * rv[k] % mod;
}
inline void ch(int i) {
ans -= C(cnt[i], k) * g[i] % mod;
if (ans < 0) ans += mod;
cnt[i]++;
ans += C(cnt[i], k) * g[i] % mod;
if (ans >= mod) ans -= mod;
}
inline void upd(int x) {
for (int i = 1; i * i <= x; i++) {
if (x % i == 0) {
ch(i);
if (i != x / i) ch(x / i);
}
}
}
int main() {
scanf("%d %d %d", &n, &k, &q);
fact[0] = rv[0] = 1;
for (int i = 1; i < L; i++) {
fact[i] = fact[i - 1] * i % mod;
rv[i] = bp(fact[i], mod - 2);
}
for (int i = 1; i <= N; i++) g[i] = i;
for (int i = 1; i <= N; i++)
for (int j = i + i; j <= N; j += i) g[j] -= g[i];
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
upd(x);
}
for (int i = 1; i <= q; i++) {
int x;
scanf("%d", &x);
upd(x);
printf("%d\n", ans);
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3e5 + 5;
int n, m, c[MAX];
vector<int> g[MAX];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
while (1) {
int ok = 0;
for (int u = 1; u <= n; u++) {
int e = 0;
for (int v : g[u])
if (c[u] == c[v]) e++;
if (e > 1) {
ok = 1;
c[u] = c[u] ^ 1;
}
}
if (!ok) break;
}
for (int i = 1; i <= n; i++) printf("%d", c[i]);
printf("\n");
return 0;
}
| 14 |
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d", &t);
char s[202];
scanf("%s", s);
int len = strlen(s);
int digit[10], want[10], ans[10];
for (int i = 0; i < 10; i++) {
digit[i] = 0;
want[i] = 0;
ans[i] = 0;
}
for (int i = 0; i < len; i++) {
if (s[i] == '0') digit[0]++;
if (s[i] == '1') digit[1]++;
if (s[i] == '2') digit[2]++;
if (s[i] == '3') digit[3]++;
if (s[i] == '4') digit[4]++;
if (s[i] == '5') digit[2]++;
if (s[i] == '6') digit[6]++;
if (s[i] == '7') digit[7]++;
if (s[i] == '8') digit[8]++;
if (s[i] == '9') digit[6]++;
}
int r;
while (t > 0) {
r = t % 10;
want[r]++;
t /= 10;
}
want[2] += want[5];
want[6] += want[9];
for (int i = 0; i < 10; i++) {
if (want[i] > 0 && i != 5 && i != 9) {
ans[i] = digit[i] / want[i];
}
}
int min = 10000;
for (int i = 0; i < 10; i++) {
if (want[i] > 0 && i != 5 && i != 9) {
if (ans[i] < min) min = ans[i];
}
}
printf("%d\n", min);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000007;
const int inf = 0x3f3f3f3f;
int f[N], pre[N], pos[N];
namespace Pam {
int n, s[N], last, tot, anc[N], fail[N], ch[N][27], len[N], diff[N];
void build() {
memset(f, 0x3f, sizeof(f));
memset(pre, 0, sizeof(pre));
memset(pos, 0, sizeof(pos));
memset(anc, 0, sizeof(anc));
memset(fail, 0, sizeof(fail));
memset(ch, 0, sizeof(ch));
memset(len, 0, sizeof(len));
fail[0] = fail[1] = tot = 1;
s[last = n = f[0] = 0] = len[1] = -1;
}
int get_fail(int p) {
while (s[n - len[p] - 1] != s[n]) p = fail[p];
return p;
}
void insert(int c) {
s[++n] = c;
int cur = get_fail(last);
if (!ch[cur][c]) {
int now = ++tot;
len[now] = len[cur] + 2;
fail[now] = ch[get_fail(fail[cur])][c];
diff[now] = len[now] - len[fail[now]];
anc[now] =
fail[now] > 1 && diff[now] == diff[fail[now]] ? anc[fail[now]] : now;
ch[cur][c] = now;
}
last = ch[cur][c];
}
void dp() {
for (int u = last; u > 1; u = fail[anc[u]]) {
pos[u] = n - len[anc[u]];
if (anc[u] != u && f[pos[fail[u]]] < f[pos[u]]) pos[u] = pos[fail[u]];
if (!(n & 1) && f[pos[u]] < f[n]) f[n] = f[pos[u]] + 1, pre[n] = pos[u];
}
if (!(n & 1) && s[n] == s[n - 1] && f[n - 2] < f[n])
f[n] = f[n - 2], pre[n] = n - 2;
}
} // namespace Pam
char s1[N], s2[N];
int n;
void work() {
int i;
scanf("%s%s", s1 + 1, s2 + 1);
n = strlen(s1 + 1);
Pam::build();
for (i = 1; i <= n; i++) {
Pam::insert(s1[i] - 'a');
Pam::dp();
Pam::insert(s2[i] - 'a');
Pam::dp();
}
if (f[n * 2] == inf) {
printf("%d\n", -1);
return;
}
printf("%d\n", f[n * 2]);
for (i = n * 2; i; i = pre[i])
if (i - pre[i] > 2) printf("%d %d\n", pre[i] / 2 + 1, i / 2);
}
int main() {
work();
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> c(n);
for (int i = 0; i < n; i++) {
cin >> c[i];
}
int st_diff = 0;
for (int i = 1; i < n; i++) {
if (c[i] != c[0]) {
st_diff = i;
break;
}
}
int res = 0;
for (int i = n - 1; i >= st_diff; i--) {
if (c[i] == c[0]) {
res = max(res, i - st_diff);
} else {
res = max(res, i);
}
}
cout << res << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long, long long);
long long mpower(long long, long long);
long long BIT[1000009];
long long query(long long);
void update(long long, long long);
long long n, m, t;
long long ans[1000009];
set<long long> s;
map<long long, long long> dis;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
queue<long long> q;
for (long long i = 1; i <= n; i++) {
cin >> t;
q.push(t);
s.insert(t);
}
long long cnt = 0, a = 0;
while (!q.empty() and cnt < m) {
long long u = q.front();
q.pop();
if (s.find(u + 1) == s.end()) {
ans[cnt++] = u + 1;
q.push(u + 1);
dis[u + 1] = dis[u] + 1;
if (cnt <= m) a += dis[u + 1];
s.insert(u + 1);
}
if (s.find(u - 1) == s.end()) {
ans[cnt++] = u - 1;
q.push(u - 1);
dis[u - 1] = dis[u] + 1;
if (cnt <= m) a += dis[u - 1];
s.insert(u - 1);
}
}
cout << a << endl;
for (long long i = 0; i < m; i++) cout << ans[i] << " ";
return 0;
}
void update(long long x, long long delta) {
for (; x < 1000009; x += x & -x) BIT[x] += delta;
}
long long query(long long x) {
long long sum = 0;
for (; x > 0; x -= x & -x) sum += BIT[x];
return sum;
}
long long power(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b % 2 == 1) res = res * a;
a = a * a;
b = b / 2;
}
return res;
}
long long mpower(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b % 2 == 1) {
res = (res * a) % 1000000007;
}
a = (a * a) % 1000000007;
b = b / 2;
}
return res;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long rev[(long long)2e5];
int main() {
char* s = (char*)malloc(sizeof(char) * ((long long)2e5 + 1));
cin >> s;
long long len = strlen(s);
long long d;
cin >> d;
for (long long i = 0; i < d; i++) {
long long j;
cin >> j;
rev[j - 1]++;
}
bool r = false;
for (long long i = 0; i <= len / 2 - 1; i++) {
r = (r + rev[i]) % 2;
if (r) {
char temp = s[i];
s[i] = s[len - i - 1];
s[len - i - 1] = temp;
}
}
cout << s;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e3 + 1;
char s[maxn];
int sum[maxn];
long long int t[maxn * 9];
int main() {
int n;
scanf("%d", &n);
scanf("%s", s);
int sizee = strlen(s);
for (int i = 1; i < sizee + 1; i++) sum[i] = sum[i - 1] + s[i - 1] - '0';
for (int i = 1; i < sizee + 1; i++)
for (int j = 0; j < i; j++) t[sum[i] - sum[j]]++;
long long int ans = 0;
if (n == 0) {
for (int i = 1; i < maxn * 9; i++) ans += t[i];
ans = ans * 2 * t[0] + t[0] * t[0];
} else
for (int i = 1; i < maxn * 9; i++)
if (n % i == 0 && n / i < maxn * 9) ans += t[i] * t[n / i];
printf("%I64d", ans);
}
| 8 |
#include <bits/stdc++.h>
const int md = 1e9 + 7;
const long long hs = 199;
const long double eps = 1e-9, pi = acos(-1);
using namespace std;
int n, d, lim = 80, ans[100002];
long long x;
vector<int> a, b, im, p;
void nextx() { x = (37 * x + 10007) % md; }
void init() {
a.resize(n), b.resize(n), p.resize(n + 1);
for (int i = 0; i < n; i++) a[i] = i + 1;
for (int i = 0; i < n; i++) nextx(), swap(a[i], a[x % (i + 1)]);
for (int i = 0; i < n; i++) b[i] = i < d;
for (int i = 0; i < n; i++) nextx(), swap(b[i], b[x % (i + 1)]);
for (int i = 0; i < n; i++) {
if (b[i]) im.push_back(i);
p[a[i]] = i;
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> d >> x;
init();
for (int i = 0; i < n; i++) {
bool found = false;
for (int j = n, l = max(1, n - lim); !found && j >= l; j--) {
if (i >= p[j] && b[i - p[j]]) {
ans[i] = j;
found = true;
}
}
if (!found) {
int mx = 0;
for (int j = 0; j < im.size() && i >= im[j]; j++)
if (a[i - im[j]] > mx) mx = a[i - im[j]];
ans[i] = mx;
}
}
for (int i = 0; i < n; i++) cout << ans[i] << '\n';
}
| 15 |
#include <bits/stdc++.h>
int main() {
int x;
scanf("%d", &x);
printf("%d %d", 10 * x, 9 * x);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
const int maxn = 2e5 + 5;
const long long mod = 1e9 + 7;
long long a[maxn], w[maxn];
long long lowbit(long long x) { return x & -x; }
void add(long long t[], long long x, long long d, int typ) {
for (; x < maxn; x += lowbit(x)) {
t[x] += d;
if (typ) t[x] = (t[x] + mod) % mod;
}
}
long long ask(long long t[], long long x, int typ) {
long long ret = 0;
for (; x; x -= lowbit(x)) {
ret += t[x];
if (typ) ret %= mod;
}
return ret;
}
long long sum[maxn];
long long t[maxn];
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
a[i] -= i;
}
for (int i = 1; i <= n; i++) {
scanf("%lld", w + i);
add(t, i, w[i], 0);
add(sum, i, w[i] * a[i], 1);
}
while (q--) {
long long l, r;
scanf("%lld%lld", &l, &r);
if (l < 0) {
add(t, -l, r - w[-l], 0);
add(sum, -l, a[-l] * (r - w[-l] + mod), 1);
w[-l] = r;
} else {
long long L = l, R = r;
long long all = ask(t, r, 0) - ask(t, l - 1, 0);
while (L < R) {
long long mid = (L + R) / 2;
if (ask(t, mid, 0) - ask(t, l - 1, 0) > all / 2)
R = mid;
else
L = mid + 1;
}
long long k = R;
long long ans = a[k] * (ask(t, k - 1, 1) - ask(t, l - 1, 1) + mod) % mod;
ans -= (ask(sum, k - 1, 1) - ask(sum, l - 1, 1) + mod) % mod;
ans = (ans + mod) % mod;
(ans += (ask(sum, r, 1) - ask(sum, k, 1) + mod)) %= mod;
ans -= a[k] * (ask(t, r, 1) - ask(t, k, 1) + mod) % mod;
ans = (ans + mod) % mod;
printf("%lld\n", ans);
}
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long a, b, c, d, e, f, i, j, k, l, m, n, o, x, y;
cin >> n >> l >> k;
string ss;
cin >> ss;
deque<char> dq;
for (char c : ss) dq.push_back(c);
sort(dq.begin(), dq.end());
string s[n + 5];
long long cnt = k;
for (j = 0; j < l; j++) {
long long cc = 0;
for (i = 0; i < cnt; i++) {
if (dq[cnt - 1] != dq[i]) cc++;
s[k - cnt + i].push_back(dq[i]);
}
for (i = 0; i < cnt; i++) dq.pop_front();
cnt -= cc;
}
for (i = 0; i < n; i++) {
if (s[i].size() < l) {
while (true) {
s[i].push_back(dq.front());
dq.pop_front();
if (s[i].size() == l) break;
}
}
}
for (i = 0; i < n; i++) {
for (char c : s[i]) cout << c;
cout << "\n";
}
}
| 10 |
#include <bits/stdc++.h>
int T;
long long m, d, w, t;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%lld%lld%lld", &m, &d, &w);
long long t = std::min(m, d);
long long g = gcd(d - 1, w);
w /= g;
long long s = t / w;
printf("%lld\n", s * t - w * s * (s + 1) / 2);
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
for (int i = 2; 1ll * i * i <= n; ++i) {
if (n % i != 0) continue;
while (n % i == 0) n /= i;
if (n == 1)
cout << i << endl;
else
cout << 1 << endl;
return;
}
cout << n << endl;
}
int main() {
ios_base::sync_with_stdio(false);
int test;
test = 1;
for (int tst = 1; tst <= test; ++tst) {
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N, i, j, L, R, A[100000], B[100000];
long long K, M, H;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> K >> M;
for (i = 0; i < N; i++) {
cin >> A[L];
if (L > 0 && A[L] == A[L - 1]) {
B[L] = B[L - 1] + 1;
if (B[L] == K) {
L -= K;
}
} else {
B[L] = 1;
}
L++;
}
N = L;
L = 0;
R = N - 1;
while (A[L] == A[R]) {
for (i = L; i < R && A[i] == A[L]; i++) {
}
for (j = R; j > L && A[j] == A[R]; j--) {
}
if (i == R) {
if ((M * (R - L + 1)) % K == 0) {
cout << 0 << '\n';
} else {
cout << (N - R + L - 1) + (M * (R - L + 1)) % K << '\n';
}
return 0;
}
if (R - j + i - L == K) {
R = j;
L = i;
} else {
if (R - j + i - L > K) {
R -= K;
}
break;
}
}
cout << N + (M - 1) * (R - L + 1) << '\n';
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int trie[300005][26];
int position[300005];
vector<int> adj[300005];
vector<pair<int, int> > upd[300005];
vector<int> qq[300005], tt[300005];
void add(char *s, int k, int id) {
static int pos = 1;
int node = 0;
for (int i = 0; i < k; ++i) {
int ind = s[i] - 'a';
if (!trie[node][ind]) {
trie[node][ind] = pos++;
}
node = trie[node][ind];
}
tt[node].push_back(id);
}
int q[300005], fail[300005];
void computeFail() {
int l = 1, r = 0;
for (int i = 0; i < 26; ++i) {
if (trie[0][i]) {
q[++r] = trie[0][i];
}
}
for (; l <= r; ++l) {
int node = q[l];
for (int i = 0; i < 26; ++i) {
if (trie[node][i]) {
int nnode = trie[node][i];
q[++r] = nnode;
fail[nnode] = trie[fail[node]][i];
} else {
trie[node][i] = trie[fail[node]][i];
}
}
adj[fail[node]].push_back(node);
}
}
void go(char *s, int len, int id) {
int cur = 0;
for (int i = 0; i < len; ++i) {
cur = trie[cur][s[i] - 'a'];
qq[cur].push_back(id);
}
}
char s[300005];
int ret[300005];
int type[300005], lt[300005];
int m;
stack<int *> pointer;
stack<int> value;
int seg[300005 * 4];
void init(int pos, int l, int r) {
seg[pos] = -1;
if (l == r) {
return;
}
int mid = (l + r) / 2;
init(pos * 2, l, mid);
init(pos * 2 + 1, mid + 1, r);
seg[pos] = seg[pos * 2] + seg[pos * 2 + 1];
}
int query(int pos, int l, int r, int ind) {
if (l == r) {
return seg[pos];
}
int ret = -1;
int mid = (l + r) / 2;
if (ind <= mid) {
ret = query(pos * 2, l, mid, ind);
} else {
ret = query(pos * 2 + 1, mid + 1, r, ind);
}
return max(seg[pos], ret);
}
void update(int pos, int l, int r, int ql, int qr, int x) {
if (r < ql || qr < l) {
return;
}
if (ql <= l && r <= qr) {
pointer.push(&seg[pos]);
value.push(seg[pos]);
seg[pos] = max(seg[pos], x);
return;
}
int mid = (l + r) / 2;
update(pos * 2, l, mid, ql, qr, x);
update(pos * 2 + 1, mid + 1, r, ql, qr, x);
}
void rollback() {
int *p = pointer.top();
*p = value.top();
pointer.pop();
value.pop();
}
void dfs(int node, int par) {
int sz = pointer.size();
for (int id : tt[node]) {
int rp = m;
for (pair<int, int> t : upd[id]) {
if (t.second <= rp) {
update(1, 0, m, t.second, rp, t.first);
rp = t.second - 1;
}
}
}
for (int x : qq[node]) {
ret[x] = max(ret[x], query(1, 0, m, x));
}
for (int ch : adj[node]) {
assert(ch != par);
dfs(ch, node);
}
while (sz < (int)pointer.size()) {
rollback();
}
}
void solve() {
int n;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf(" %s ", s);
add(s, strlen(s), i);
}
computeFail();
for (int i = 1; i <= n; ++i) {
upd[i].push_back({0, 0});
}
for (int i = 1; i <= m; ++i) {
ret[i] = -1;
scanf("%d ", &type[i]);
if (type[i] == 1) {
int id, x;
scanf("%d %d ", &id, &x);
upd[id].push_back({x, i});
} else {
scanf(" %s ", s);
go(s, strlen(s), i);
}
}
for (int i = 1; i <= n; ++i) {
reverse(upd[i].begin(), upd[i].end());
}
init(1, 0, m);
dfs(0, 0);
for (int i = 1; i <= m; ++i) {
if (type[i] == 2) {
printf("%d\n", ret[i]);
}
}
}
int main() {
solve();
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const int maxn = 1e6 + 5;
int n, m, k;
string s;
const int N = 10;
struct segtree {
vector<int> lazy, lastright, firstleft;
vector<vector<vector<int>>> t;
int n;
segtree() {}
void init(int n) {
this->n = n;
lazy.resize(4 * n, -1);
lastright.resize(4 * n);
firstleft.resize(4 * n);
t.resize(4 * n);
for (int i = 0; i < 4 * n; i++) {
t[i] = vector<vector<int>>(N, vector<int>(N, 0));
}
}
void combine(int v, int tl, int tr) {
assert(tl >= 1 && tr <= n);
lastright[v] = lastright[2 * v + 1];
firstleft[v] = firstleft[2 * v];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
t[v][i][j] = t[2 * v][i][j] + t[2 * v + 1][i][j];
}
}
t[v][lastright[2 * v]][firstleft[2 * v + 1]]++;
}
void build(int v, int tl, int tr) {
lazy[v] = -1;
if (tl == tr) {
lastright[v] = firstleft[v] = (s[tl] - 'a');
} else {
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
combine(v, tl, tr);
}
}
void push(int v, int tl, int tr) {
if (lazy[v] == -1) return;
int tm = (tl + tr) / 2;
lastright[2 * v] = firstleft[2 * v] = lazy[v];
lastright[2 * v + 1] = firstleft[2 * v + 1] = lazy[v];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
t[2 * v][i][j] = t[2 * v + 1][i][j] = 0;
}
}
t[2 * v][lazy[v]][lazy[v]] = tm - tl;
t[2 * v + 1][lazy[v]][lazy[v]] = tr - tm - 1;
lazy[2 * v] = lazy[v];
lazy[2 * v + 1] = lazy[v];
lazy[v] = -1;
}
void update(int v, int tl, int tr, int l, int r, int val) {
if (l > tr || r < tl) return;
if (l <= tl && tr <= r) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
t[v][i][j] = 0;
}
}
lastright[v] = firstleft[v] = val;
t[v][val][val] = tr - tl;
lazy[v] = val;
} else {
int tm = (tl + tr) / 2;
push(v, tl, tr);
update(2 * v, tl, tm, l, r, val);
update(2 * v + 1, tm + 1, tr, l, r, val);
combine(v, tl, tr);
}
}
void get(int v, int tl, int tr, int l, int r) {
if (l > tr || r < tl) return;
if (l <= tl && tr <= r) {
} else {
int tm = (tl + tr) / 2;
push(v, tl, tr);
get(2 * v, tl, tm, l, r);
get(2 * v + 1, tm + 1, tr, l, r);
combine(v, tl, tr);
}
}
void print() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
cout << t[1][i][j] << " ";
}
cout << endl;
}
cout << endl;
}
};
segtree t;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
cin >> s;
s = "*" + s;
t.init(n);
t.build(1, 1, n);
while (m--) {
int typ;
cin >> typ;
if (typ == 1) {
int l, r;
char c;
cin >> l >> r >> c;
t.update(1, 1, n, l, r, c - 'a');
t.get(1, 1, n, 1, n);
} else {
t.get(1, 1, n, 1, n);
string p;
cin >> p;
int len = p.size();
vector<int> mp(N, -1);
for (int i = 0; i < len; i++) {
mp[p[i] - 'a'] = i;
}
int ans = 1;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (mp[j] <= mp[i]) {
ans += t.t[1][i][j];
}
}
}
cout << ans << "\n";
}
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int flag = 1;
int mx = INT_MIN;
long long index = 0;
vector<int> vec(n);
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
vec[i] = temp;
if (temp > mx) {
mx = temp;
}
}
for (int i = 0; i < n - 1; i++) {
if (vec[i] < mx && vec[i + 1] == mx) {
index = i + 2;
break;
}
}
for (int i = 1; i < n; i++) {
if (vec[i] < mx && vec[i - 1] == mx) {
index = i;
break;
}
}
for (int i = 0; i < n - 1; i++) {
if (vec[i] != vec[i + 1]) {
flag = 0;
break;
}
}
if (flag) {
cout << -1 << endl;
continue;
}
cout << index << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100 * 1000 + 10, SQ = 444;
int n, m, a[MAX_N], l[MAX_N], r[MAX_N], id[MAX_N], cnt[MAX_N];
int ans[MAX_N], now_ans;
void read_input() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
scanf("%d%d", &l[i], &r[i]);
l[i]--;
}
}
bool cmp(int &i, int &j) {
pair<int, int> x(l[i] / SQ, l[i] / SQ & 1 ? -r[i] : r[i]);
pair<int, int> y(l[j] / SQ, l[j] / SQ & 1 ? -r[j] : r[j]);
return x < y;
}
void pre() {
iota(id, id + m, 0);
sort(id, id + m, cmp);
}
inline void add(int v, int x) {
if (v > n) return;
now_ans -= cnt[v] == v;
cnt[v] += x;
now_ans += cnt[v] == v;
}
void mo() {
int L = 0, R = 0;
for (int tmp = 0; tmp < m; tmp++) {
int i = id[tmp];
while (R < r[i]) add(a[R++], +1);
while (R > r[i]) add(a[--R], -1);
while (L < l[i]) add(a[L++], -1);
while (L > l[i]) add(a[--L], +1);
ans[i] = now_ans;
}
}
void solve() {
pre();
mo();
}
void print_output() {
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
}
int main() {
read_input();
solve();
print_output();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to, next, c, v;
} edges[10005];
int ans = 0;
int n, k, first[1005], te = 1;
int dis[1005], a[1005], c[1005], last[1005], now[1005];
int cur[1005], all = 0;
bool vis[1005], inq[1005];
queue<int> q;
void addE(int a, int b, int c, int d) {
edges[++te].to = b;
edges[te].next = first[a];
edges[te].v = d;
edges[te].c = c;
first[a] = te;
}
bool spfa() {
for (int i = 0; i <= all; ++i) dis[i] = 1e9;
dis[0] = 0;
q.push(0), inq[0] = 1;
while (!q.empty()) {
int x = q.front();
inq[x] = 0;
q.pop();
for (int e = first[x]; e; e = edges[e].next)
if (edges[e].c > 0) {
int to = edges[e].to;
if (dis[to] > dis[x] + edges[e].v) {
dis[to] = dis[x] + edges[e].v;
if (!inq[to]) inq[to] = 1, q.push(to);
}
}
}
return (dis[all] != 1e9);
}
int dfs(int x, int minf) {
if (!minf || x == all) return minf;
int f = 0;
vis[x] = 1;
for (int &e = cur[x]; e; e = edges[e].next) {
int to = edges[e].to;
if (!vis[to] && dis[to] == dis[x] + edges[e].v) {
int flow = dfs(to, min(minf, edges[e].c));
if (flow) {
edges[e].c -= flow;
edges[e ^ 1].c += flow;
ans += edges[e].v * flow;
f += flow;
minf -= flow;
if (!minf) {
vis[x] = 0;
return f;
}
}
}
}
vis[x] = 0;
return f;
}
void Dinic() {
while (spfa()) {
for (int i = 0; i <= all; ++i) cur[i] = first[i];
dfs(0, 1e9);
}
}
int main() {
memset(now, -1, sizeof(now));
ios::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) cin >> c[i];
for (int i = 1; i <= n; ++i) {
last[i] = now[a[i]];
now[a[i]] = i;
if (last[i] != i - 1) ans += c[a[i]];
}
for (int i = 1; i <= n; ++i) {
addE(i - 1, i, k - 1, 0);
addE(i, i - 1, 0, 0);
}
all = n;
for (int i = 1; i <= n; ++i)
if (last[i] != -1 && last[i] != i - 1) {
all++;
addE(0, last[i] + 1, 1, 0);
addE(last[i] + 1, 0, 0, 0);
addE(last[i] + 1, all, 1, 0);
addE(all, last[i] + 1, 0, 0);
addE(i, all, 1, -c[a[i]]);
addE(all, i, 0, c[a[i]]);
}
all++;
for (int i = n + 1; i < all; ++i) {
addE(i, all, 1, 0);
addE(all, i, 0, 0);
}
Dinic();
cout << ans << endl;
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n, m;
char a[N][N], b[N][N];
vector<pair<int, int> > v;
void dfs(int x, int y) {
if (a[x][y + 1] == 'L' && a[x + 1][y + 1] == 'U') {
dfs(x + 1, y + 1);
}
if (a[x][y + 1] == 'L' && a[x + 1][y + 1] == 'L') {
v.push_back(make_pair(x, y + 1));
a[x][y + 1] = 'U';
a[x + 1][y + 1] = 'D';
a[x][y + 2] = 'U';
a[x + 1][y + 2] = 'D';
}
if (a[x][y + 1] == 'U') {
v.push_back(make_pair(x, y));
a[x][y] = 'L';
a[x][y + 1] = 'R';
a[x + 1][y] = 'L';
a[x + 1][y + 1] = 'R';
}
}
vector<pair<int, int> > ans;
void solv() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == 'U') dfs(i, j);
}
}
ans = v;
v.clear();
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) a[i][j] = b[i][j];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == 'U') dfs(i, j);
}
}
reverse(v.begin(), v.end());
for (int i = 0; i < v.size(); ++i) ans.push_back(v[i]);
}
char aa[N][N], bb[N][N];
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
if (m % 2 == 0) {
solv();
} else {
for (int j = 0, ii = 0; j < m; ++j, ++ii) {
for (int i = n - 1, jj = 0; i >= 0; --i, ++jj) {
aa[ii][jj] = a[i][j];
}
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
if (aa[i][j] == 'L') a[i][j] = 'U';
if (aa[i][j] == 'R') a[i][j] = 'D';
if (aa[i][j] == 'U') a[i][j] = 'R';
if (aa[i][j] == 'D') a[i][j] = 'L';
}
a[i][n] = '\0';
}
for (int j = 0, ii = 0; j < m; ++j, ++ii) {
for (int i = n - 1, jj = 0; i >= 0; --i, ++jj) {
bb[ii][jj] = b[i][j];
}
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
if (bb[i][j] == 'L') b[i][j] = 'U';
if (bb[i][j] == 'R') b[i][j] = 'D';
if (bb[i][j] == 'U') b[i][j] = 'R';
if (bb[i][j] == 'D') b[i][j] = 'L';
}
b[i][n] = '\0';
}
swap(n, m);
solv();
swap(n, m);
for (int i = 0; i < ans.size(); ++i) {
swap(ans[i].first, ans[i].second);
ans[i].first = (n - ans[i].first - 1 - 1);
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); ++i)
cout << ans[i].first + 1 << ' ' << ans[i].second + 1 << endl;
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, k = 1, i_1, j_1;
;
cin >> n >> a >> b;
if (n > a * b) {
cout << "-1" << endl;
return 0;
}
int **ary = new int *[a];
for (int i = 0; i < a; i++) {
ary[i] = new int[b];
for (int j = 0; j < b; j++) {
ary[i][j] = 0;
}
}
for (int i = 0; i < a; i++) {
if (k <= n) {
if (i % 2 == 0 || i == 0) {
for (int j = 0; j < b; j++) {
if (k > n) {
i_1 = i;
j_1 = j;
break;
}
ary[i][j] = k;
k++;
}
} else {
for (int j = b - 1; j >= 0; j--) {
if (k > n) {
i_1 = i;
j_1 = j;
break;
}
ary[i][j] = k;
k++;
}
}
}
}
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
cout << ary[i][j] << ' ';
}
cout << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[100050], co[55];
int invco[256], q, l, r;
long long num[55], n, W = 1, p[100050], pinv[100050], dp[500050], ans[55][55];
const long long Mod = 1e9 + 7;
long long mypow(long long a, long long e) {
long long ans = 1, base = a;
while (e) {
if (e % 2) ans = ans * base % Mod;
base = base * base % Mod;
e /= 2;
}
return ans;
}
long long com(long long n, long long a) {
return (p[n] * pinv[a] % Mod) * pinv[n - a] % Mod;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
p[0] = pinv[0] = 1;
for (int i = 1; i <= 100000; i++) p[i] = p[i - 1] * i % Mod;
pinv[100000] = mypow(p[100000], Mod - 2);
for (int i = 100000 - 1; i; i--) pinv[i] = pinv[i + 1] * (i + 1) % Mod;
for (int i = 0; i < 26; i++) co[i] = i + 'a';
for (int i = 26; i < 52; i++) co[i] = i + 'A' - 26;
for (int i = 0; i < 52; i++) invco[co[i]] = i;
for (int i = 1; i <= strlen(s + 1); i++) num[invco[s[i]]]++;
W = p[n / 2] * p[n / 2] % Mod;
dp[0] = 1;
for (int i = 0; i < 52; i++) {
if (!num[i]) continue;
W = W * pinv[num[i]] % Mod;
for (int j = n / 2; j >= num[i]; j--)
dp[j] = (dp[j] + dp[j - num[i]]) % Mod;
}
for (int i = 0; i < 52; i++) {
if (!num[i]) continue;
for (int j = num[i]; j <= n / 2; j++)
dp[j] = (dp[j] - dp[j - num[i]] + Mod) % Mod;
for (int j = 0; j < 52; j++) {
if (!num[j]) continue;
if (i == j) {
ans[i][j] = 2 * W * dp[n / 2] % Mod;
continue;
}
for (int k = num[j]; k <= n / 2; k++)
dp[k] = (dp[k] - dp[k - num[j]] + Mod) % Mod;
ans[i][j] = 2 * W * dp[n / 2] % Mod;
for (int k = n / 2; k >= num[j]; k--)
dp[k] = (dp[k] + dp[k - num[j]]) % Mod;
}
for (int j = n / 2; j >= num[i]; j--)
dp[j] = (dp[j] + dp[j - num[i]]) % Mod;
}
scanf("%d", &q);
while (q--) {
scanf("%d%d", &l, &r);
printf("%lld\n", ans[invco[s[l]]][invco[s[r]]]);
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e7 + 5;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
int sieve[maxN];
int phi[maxN];
int numD[maxN];
int ps[maxN];
long long cnt[3];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
iota(phi, phi + maxN, -1);
iota(sieve, sieve + maxN, 0);
int n;
scanf("%d", &n);
phi[1] = 1;
sieve[1] = 0;
for (int i = 2; i <= n; i++) {
for (int j = 1; j * i <= n; j++) {
if (sieve[i] == i && sieve[j * i] == j * i) sieve[j * i] = i;
if (j != 1) phi[j * i] -= phi[i];
}
}
numD[1] = 0;
for (int i = 2; i <= n; i++) {
int p = i / sieve[i];
numD[i] = numD[p] + (sieve[p] != sieve[i]);
}
long long iso = 1;
for (int i = n / 2 + 1; i <= n; i++)
if (sieve[i] == i) iso++;
cnt[0] = 1ll * (n - iso) * (n - iso - 1) / 2;
for (int i = 2; i <= n; i++) {
if (sieve[i] == i && i * 2 > n) continue;
cnt[1] += i - 1 - phi[i];
}
int ncl = 1;
for (int i = 2; i <= n; i++) {
if (sieve[i] == i)
ncl++;
else
cnt[2] += phi[i] - ncl + numD[i];
}
for (int i = 2; i <= n; i++) {
if (sieve[i] == i && i * 2 > n) continue;
ps[sieve[i]]++;
}
for (int i = 1; i <= n; i++) ps[i] += ps[i - 1];
for (int i = 2; i <= n; i++) {
if (sieve[i] != i || i * 2 > n) continue;
cnt[2] += ps[n / i];
for (int j = 1; j * i <= n; j++)
if (sieve[j * i] <= n / i) cnt[2]--;
}
for (int i = 2; i <= n; i++) {
int p = i / sieve[i];
if (sieve[p] == p && p != sieve[i] && p != 1) cnt[2]--;
}
printf("%lld\n", 3 * cnt[0] - cnt[2] - 2 * cnt[1]);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
int n, k, m, a, g[N], v[N], last[N], st[N];
int main() {
scanf("%d%d%d%d", &n, &k, &m, &a);
for (int i = 0; i < a; ++i) {
scanf("%d", &g[i]);
v[g[i]]++;
last[g[i]] = i;
}
vector<pair<pair<int, int>, int> > all;
for (int i = 1; i <= n; ++i)
all.push_back(make_pair(make_pair(v[i], -last[i]), i));
sort(all.begin(), all.end());
int have = 0;
for (int i = all.size() - 1; i >= max(0, (int)all.size() - k); --i) {
have = all[i].first.first;
if (!have) continue;
int total = 0;
if (((int)all.size()) - k - 1 < 0) {
st[all[i].second] = 1;
continue;
}
for (int j = i - 1; j >= ((int)all.size()) - k - 1; --j) {
total += all[i].first.first - all[j].first.first + 1;
}
if (total > m - a) {
st[all[i].second] = 1;
}
}
for (int i = 0; i < all.size(); ++i) {
if (st[all[i].second]) continue;
if (all[i].first.first + m - a > have) {
st[all[i].second] = 2;
}
}
for (int i = 1; i <= n; ++i) {
if (i > 1) printf(" ");
if (st[i]) {
printf("%d", st[i]);
} else {
printf("3");
}
}
puts("");
return 0;
}
| 13 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
#pragma GOVNOCODE optimize("ROFL")
const int N = int(1e5) + 2;
const int INF = int(1e9) + 1;
const int MOD = 998244353;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
std::vector<std::vector<int>> a(n, std::vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
std::vector<std::vector<int>> ras(n, std::vector<int>(n, INF));
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = 0; k < m; k++) {
ras[i][j] = std::min(ras[i][j], std::abs(a[i][k] - a[j][k]));
}
ras[j][i] = ras[i][j];
}
}
std::vector<std::vector<int>> kek(n, std::vector<int>(n, INF));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k + 1 < m; k++) {
kek[i][j] = std::min(kek[i][j], std::abs(a[j][k] - a[i][k + 1]));
}
}
}
int l = 0, r = INF;
while (r - l > 1) {
int mid = (r + l) >> 1;
std::vector<std::vector<int>> dp(n, std::vector<int>((1 << n), 0));
for (int i = 0; i < n; i++) dp[i][(1 << i)] = (1 << i);
for (int code = 0; code < (1 << n); code++) {
for (int last = 0; last < n; last++) {
if ((code >> last & 1) == 0) continue;
if (code == (1 << last)) {
break;
}
for (int i = 0; i < n; i++) {
if (ras[i][last] >= mid && i != last && (code >> i & 1))
dp[last][code] |= dp[i][code - (1 << last)];
}
}
}
bool good = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (dp[j][(1 << n) - 1] >> i & 1)
if (kek[i][j] >= mid) good = true;
}
}
if (good)
l = mid;
else
r = mid;
}
cout << l;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, sum = 0, ans = 0;
cin >> n;
long long arr[n + 2];
for (long long i = 0; i < n; i++) cin >> arr[i], sum += arr[i];
sort(arr, arr + n);
if (sum % 2 == 0) return cout << sum, 0;
for (long long i = 0; i < n; i++) {
if ((sum - arr[i]) % 2 == 0) ans = max(ans, sum - arr[i]);
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
long long int mod = 1000000000 + 7;
long long int inf = (long long int)(5e18);
using namespace std;
mt19937 unlucko(chrono::steady_clock::now().time_since_epoch().count());
int main() {
iostream::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<string> a[26], b[26];
for (int i = 0; i < n; i++) {
string s;
cin >> s;
a[s[0] - 'A'].push_back(s);
}
for (int i = 0; i < n; i++) {
string s;
cin >> s;
b[s[0] - 'A'].push_back(s);
}
for (int i = 0; i < 26; i++) {
sort(a[i].rbegin(), a[i].rend());
sort(b[i].rbegin(), b[i].rend());
}
vector<pair<string, string> > ans;
for (int i = 0; i < 26; i++) {
while (!a[i].empty()) {
if (a[i].size() > b[i].size()) {
bool ok = false;
for (int j = 0; j < i; j++) {
if (!b[j].empty()) {
ans.push_back({a[i].back(), b[j].back()});
a[i].pop_back();
b[j].pop_back();
ok = true;
break;
}
}
if (ok) continue;
}
if (!b[i].empty()) {
ans.push_back({a[i].back(), b[i].back()});
a[i].pop_back();
b[i].pop_back();
} else {
for (int j = i + 1; j < 26; j++) {
if (b[j].size() > a[j].size()) {
ans.push_back({a[i].back(), b[j].back()});
a[i].pop_back();
b[j].pop_back();
break;
}
}
}
}
}
for (int i = 0; i < n; i++) {
cout << ans[i].first << " " << ans[i].second;
if (i != n - 1) cout << ", ";
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v1, v2;
set<int> s;
map<int, int> cnt;
int n, k, unlucky, dp[1023][2], fct[100001], inv[100001];
const int mod = 1000000007;
int cmb(int x, int y) {
if (x < y) return 0;
if (y < 0) return 0;
return 1LL * fct[x] * inv[x - y] % mod * inv[y] % mod;
}
int qpow(int b, int e) {
if (e == 0) return 1;
int tmp = qpow(b, e >> 1);
tmp = 1LL * tmp * tmp % mod;
return (e & 1) ? 1LL * tmp * b % mod : tmp;
}
int main() {
scanf("%d%d", &n, &k);
fct[0] = 1;
for (int i = 1; i <= n; i++) fct[i] = 1LL * fct[i - 1] * i % mod;
inv[n] = qpow(fct[n], mod - 2);
for (int i = n - 1; i >= 0; i--) inv[i] = 1LL * inv[i + 1] * (i + 1) % mod;
v1.push_back(4);
v1.push_back(7);
s.insert(4);
s.insert(7);
for (int i = 1; i < 9; i++) {
for (int l : v1)
v2.push_back(l * 10 + 4), v2.push_back(l * 10 + 7), s.insert(l * 10 + 4),
s.insert(l * 10 + 7);
v1 = v2;
}
for (int i = 0, a; i < n; i++) {
scanf("%d", &a);
if (s.count(a))
cnt[a]++;
else
unlucky++;
}
dp[0][0] = 1;
int i = 1;
for (pair<int, int> p : cnt) {
for (int j = 1; j <= i; j++)
dp[j][1] = (1LL * dp[j - 1][0] * p.second % mod + dp[j][1]) % mod;
for (int j = 1; j <= i; j++)
dp[j][0] = (0LL + dp[j][1] + dp[j][0]) % mod, dp[j][1] = 0;
i++;
}
int ans = 0;
for (i = 0; i <= min((int)cnt.size(), k); i++)
ans = (ans + 1LL * dp[i][0] * cmb(unlucky, k - i) % mod) % mod;
printf("%d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
string s;
int prep[510][510];
int dp[510][510];
int way[510][510];
int r(int p, int k) {
if (k < 0) return 1000000000;
if (p == s.size()) return 0;
if (dp[p][k] != -1) return dp[p][k];
int res = 2000000000;
for (int i = (p); i < (s.size()); ++i) {
int res1 = prep[p][i] + r(i + 1, k - 1);
if (res1 < res) {
res = res1;
way[p][k] = i;
}
}
return dp[p][k] = res;
}
int main() {
int k;
cin >> s >> k;
for (int i = (0); i < (s.size()); ++i)
for (int j = (i); j < (s.size()); ++j)
for (int k = (0); k < ((j - i + 1) / 2); ++k)
if (s[i + k] != s[j - k]) prep[i][j]++;
memset(dp, -1, sizeof(dp));
int res = r(0, k);
cout << res << endl;
int curp = 0, curk = k;
int cnt = 0;
while (curp < s.size()) {
int end = way[curp][curk];
if (cnt) printf("+");
for (int i = (curp); i < (end + 1); ++i)
if ((i - curp) * 2 < end - curp + 1)
printf("%c", s[end - i + curp]);
else
printf("%c", s[i]);
cnt++;
curp = end + 1;
curk--;
}
cout << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 10e-11;
const double PI = acos(-1);
class VagueDouble {
public:
double vd;
VagueDouble() { vd = nan(""); }
VagueDouble(const double d) { vd = d; }
inline VagueDouble operator-() const { return VagueDouble(-vd); }
inline VagueDouble operator+(const VagueDouble VD) const {
return VagueDouble(vd + VD.vd);
}
inline VagueDouble operator-(const VagueDouble VD) const {
return VagueDouble(vd - VD.vd);
}
inline VagueDouble operator*(const VagueDouble VD) const {
return VagueDouble(vd * VD.vd);
}
inline VagueDouble operator/(const VagueDouble VD) const {
return VagueDouble(vd / VD.vd);
}
inline VagueDouble operator+(const double d) const {
return VagueDouble(vd + d);
}
inline VagueDouble operator-(const double d) const {
return VagueDouble(vd - d);
}
inline VagueDouble operator*(const double d) const {
return VagueDouble(vd * d);
}
inline VagueDouble operator/(const double d) const {
return VagueDouble(vd / d);
}
inline bool operator<(const VagueDouble VD) const {
return vd + EPS < VD.vd || vd + EPS * abs(vd) < VD.vd;
}
inline bool operator>(const VagueDouble VD) const {
return vd - EPS > VD.vd || vd - EPS * abs(vd) > VD.vd;
}
inline bool operator==(const VagueDouble VD) const {
return !(*this < VD.vd) && !(*this > VD.vd);
}
inline bool operator!=(const VagueDouble VD) const {
return (*this < VD.vd) || (*this > VD.vd);
}
inline bool operator<=(const VagueDouble VD) const {
return !(*this > VD.vd);
}
inline bool operator>=(const VagueDouble VD) const {
return !(*this < VD.vd);
}
inline bool operator<(const double d) const { return *this < VagueDouble(d); }
inline bool operator>(const double d) const { return *this > VagueDouble(d); }
inline bool operator==(const double d) const {
return *this == VagueDouble(d);
}
inline bool operator!=(const double d) const {
return *this != VagueDouble(d);
}
inline bool operator<=(const double d) const {
return *this <= VagueDouble(d);
}
inline bool operator>=(const double d) const {
return *this >= VagueDouble(d);
}
inline void operator+=(const VagueDouble VD) { *this = *this + VD; }
inline void operator-=(const VagueDouble VD) { *this = *this - VD; }
inline void operator*=(const VagueDouble VD) { *this = *this * VD; }
inline void operator/=(const VagueDouble VD) { *this = *this / VD; }
inline friend VagueDouble operator+(const double d, const VagueDouble &VD) {
return VagueDouble(d + VD.vd);
}
inline friend VagueDouble operator-(const double d, const VagueDouble &VD) {
return VagueDouble(d - VD.vd);
}
inline friend VagueDouble operator*(const double d, const VagueDouble &VD) {
return VagueDouble(d * VD.vd);
}
inline friend VagueDouble operator/(const double d, const VagueDouble &VD) {
return VagueDouble(d / VD.vd);
}
inline friend bool operator<(const double d, const VagueDouble &VD) {
return VagueDouble(d) < VD;
}
inline friend bool operator>(const double d, const VagueDouble &VD) {
return VagueDouble(d) > VD;
}
inline friend bool operator==(const double d, const VagueDouble &VD) {
return VagueDouble(d) == VD;
}
inline friend bool operator<=(const double d, const VagueDouble &VD) {
return VagueDouble(d) <= VD;
}
inline friend bool operator>=(const double d, const VagueDouble &VD) {
return VagueDouble(d) >= VD;
}
inline friend std::ostream &operator<<(std::ostream &os,
const VagueDouble VD) {
os << VD.vd;
return os;
}
inline friend std::istream &operator>>(std::istream &is, VagueDouble &VD) {
double d;
is >> d;
VD = VagueDouble(d);
return is;
}
inline friend VagueDouble abs(VagueDouble VD) {
return (VD.vd < 0) ? (-VD.vd) : VD.vd;
}
inline friend VagueDouble sqr(VagueDouble VD) { return VD.vd * VD.vd; }
inline friend VagueDouble sqr(double d) { return d * d; }
inline friend VagueDouble sqrt(VagueDouble VD) {
return VagueDouble(sqrt(VD.vd));
}
inline friend bool isnan(VagueDouble VD) { return isnan(VD.vd); }
inline double to_double() { return vd; }
};
class P {
public:
VagueDouble x, y;
P() {
x = nan("");
y = nan("");
}
P(double _x, double _y) {
x = _x;
y = _y;
}
P(VagueDouble _x, VagueDouble _y) {
x = _x;
y = _y;
}
inline P operator-() const { return P(-x, -y); }
inline P operator+(const P p) const { return P(x + p.x, y + p.y); }
inline P operator-(const P p) const { return P(x - p.x, y - p.y); }
inline P operator*(const double d) const { return P(x * d, y * d); }
inline P operator/(const double d) const { return P(x / d, y / d); }
inline bool operator<(const P &p) const {
return (x == p.x) ? (y < p.y) : (x < p.x);
}
inline bool operator>(const P &p) const {
return (x == p.x) ? (y > p.y) : (x > p.x);
}
inline bool operator==(const P &p) const { return (x == p.x) && (y == p.y); }
inline bool operator!=(const P &p) const { return (x != p.x) || (y != p.y); }
inline void operator+=(const P &p) { *this = *this + p; }
inline void operator-=(const P &p) { *this = *this - p; }
inline void operator*=(const double &p) { *this = *this * p; }
inline void operator/=(const double &p) { *this = *this / p; }
inline VagueDouble operator*(const P p) const { return x * p.x + y * p.y; }
inline VagueDouble operator^(const P p) const { return x * p.y - y * p.x; }
friend std::ostream &operator<<(std::ostream &os, const P &p) {
os << p.x.vd << "," << p.y.vd;
return os;
}
friend std::istream &operator>>(std::istream &is, P &p) {
double _x, _y;
is >> _x >> _y;
p = P(_x, _y);
return is;
}
inline VagueDouble length() { return sqrt(x * x + y * y); }
inline friend VagueDouble area(P p0, P p1, P p2) {
return abs((p1 - p0) ^ (p2 - p0)) * 0.5;
}
inline friend bool isnan(P p) { return isnan(p.x); }
};
VagueDouble dist(P p0, P p1) {
VagueDouble dx = abs(p0.x - p1.x);
VagueDouble dy = abs(p0.y - p1.y);
if (dx == 0.0) return dy;
return dx * sqrt(1.0 + sqr(dy / dx));
}
VagueDouble distPL(P l0, P l1, P p) {
if (l0 == -l1) return dist(l0, p);
return abs((p - l0) ^ (l1 - l0)) / (l1 - l0).length();
}
VagueDouble angle(P from0, P to0, P from1, P to1) {
P v0 = to0 - from0, v1 = to1 - from1;
VagueDouble res = atan2(v1.y.vd, v1.x.vd) - atan2(v0.y.vd, v0.x.vd);
for (; true; res += PI * 2.0)
if (0 <= res) return res;
}
bool onLine(P l0, P l1, P p) {
if (p.x < min(l0.x, l1.x) || max(l0.x, l1.x) < p.x) return false;
if (p.y < min(l0.y, l1.y) || max(l0.y, l1.y) < p.y) return false;
return distPL(l0, l1, p) == 0;
}
P LinePosAtX(P l0, P l1, VagueDouble x) {
VagueDouble dx = l0.x - l1.x;
VagueDouble dy = l0.y - l1.y;
if (dx == 0) return P();
return P(x, x * dy / dx + (l0.y - l0.x * dy / dx));
}
P LinePosAtY(P l0, P l1, VagueDouble y) {
VagueDouble dx = l0.x - l1.x;
VagueDouble dy = l0.y - l1.y;
if (dy == 0) return P();
return P(y * dx / dy + (l0.x - l0.y * dx / dy), y);
}
P findLineCross(P a0, P a1, P b0, P b1) {
VagueDouble dx0 = a1.x - a0.x;
VagueDouble dy0 = a1.y - a0.y;
VagueDouble dx1 = b1.x - b0.x;
VagueDouble dy1 = b1.y - b0.y;
VagueDouble den = dx1 * dy0 - dy1 * dx0;
if (den == 0) return P();
VagueDouble da = ((a0.x - b0.x) * dy0 - (a0.y - b0.y) * dx0) / den;
return P(b0.x + dx1 * da, b0.y + dy1 * da);
}
P findSegCross(P a0, P a1, P b0, P b1) {
P res = findLineCross(a0, a1, b0, b1);
if (isnan(res)) return P();
if (res.x < min(a0.x, a1.x) || max(a0.x, a1.x) < res.x) return P();
if (res.x < min(b0.x, b1.x) || max(b0.x, b1.x) < res.x) return P();
if (res.y < min(a0.y, a1.y) || max(a0.y, a1.y) < res.y) return P();
if (res.y < min(b0.y, b1.y) || max(b0.y, b1.y) < res.y) return P();
return res;
}
class Polygon {
public:
vector<P> points;
Polygon() {}
Polygon(vector<P> vec) { points = vec; }
Polygon(long long int num) { points.resize(num); }
friend std::ostream &operator<<(std::ostream &os, Polygon &poly) {
for (long long int i = 0;
i < ((long long int)(((long long int)(poly).size()))); ++i)
os << poly[i] << " ";
return os;
}
friend std::istream &operator>>(std::istream &is, Polygon &poly) {
for (long long int i = 0;
i < ((long long int)(((long long int)(poly).size()))); ++i)
is >> poly[i];
return is;
}
long long int size() { return ((long long int)(points).size()); }
P &operator[](long long int pos) { return points[pos]; }
bool onPoly(P p) {
long long int n = ((long long int)(points).size());
if (onLine(points[n - 1], points[0], p)) return true;
for (long long int i = 0; i < ((long long int)(n - 1)); ++i)
if (onLine(points[i], points[i + 1], p)) return true;
return false;
}
bool inPoly(P p) {
long long int n = ((long long int)(points).size());
if (n == 0) return false;
if (onPoly(p)) return true;
P right_point = p;
for (long long int i = 0; i < ((long long int)(n)); ++i)
right_point.x = max(right_point.x, points[i].x);
if (right_point == p) return false;
long long int cnt = 0;
for (long long int i = 0, next = 1; i < n; i++, next++) {
if (next == n) next = 0;
if (0 < (points[i].y - p.y) * (points[next].y - p.y)) continue;
P cross = findSegCross(points[i], points[next], p, right_point);
if (!isnan(cross)) cnt++;
}
for (long long int i = 0;
i < ((long long int)(((long long int)(points).size()))); ++i)
if (onLine(p, right_point, points[i])) {
VagueDouble dy0 = points[(i - 1 + n) % n].y - p.y;
VagueDouble dy1 = points[(i + 1 + n) % n].y - p.y;
if (dy0 * dy1 < 0) cnt++;
}
return (cnt & 1);
}
bool outPoly(P p) { return !inPoly(p); }
void convexReform() {
long long int k = 0;
if (((long long int)(points).size()) <= 1) return;
sort(points.begin(), points.end());
vector<P> ans(2 * ((long long int)(points).size()));
for (long long int i = 0; i < ((long long int)(points).size());
ans[k++] = points[i++]) {
while (2 <= k &&
0 <= ((ans[k - 1] - ans[k - 2]) ^ (points[i] - ans[k - 2])))
k--;
}
for (long long int i = ((long long int)(points).size()) - 2, t = k + 1;
0 <= i; ans[k++] = points[i--]) {
while (t <= k &&
0 <= ((ans[k - 1] - ans[k - 2]) ^ (points[i] - ans[k - 2])))
k--;
}
ans.resize(k - 1);
points = ans;
}
VagueDouble convexArea() {
VagueDouble res = 0;
for (long long int i = 0;
i < ((long long int)(((long long int)(points).size()) - 1)); ++i)
res += area(points[0], points[i], points[i + 1]);
return res;
}
};
class Circle {
public:
P center;
VagueDouble radius;
Circle(P _center, VagueDouble _r) {
center = _center;
radius = _r;
};
Circle(P p0, P p1, P p2) {
if (p0 == p1) {
center = (p0 + p2) * 0.5;
radius = dist(p0, p2) * 0.5;
return;
}
if (p0 == p2) {
center = (p0 + p1) * 0.5;
radius = dist(p0, p2) * 0.5;
return;
}
if (p1 == p2) {
center = (p0 + p2) * 0.5;
radius = dist(p0, p2) * 0.5;
return;
}
P mid0 = (p0 + p1) * 0.5;
P mid1 = (p0 + p2) * 0.5;
P _mid0 = mid0 + P((p1 - p0).y, (p0 - p1).x);
P _mid1 = mid1 + P((p2 - p0).y, (p0 - p2).x);
center = findLineCross(mid0, _mid0, mid1, _mid1);
radius = dist(center, p0);
}
};
int main() {
long long int n;
cin >> n;
vector<Polygon> base(n, Polygon(3));
for (long long int i = 0; i < ((long long int)(n)); ++i) cin >> base[i];
set<P> seg[10005];
for (long long int i = 0;
i < ((long long int)(((long long int)(base).size()))); ++i)
for (long long int j = 0;
j < ((long long int)(((long long int)(base[i]).size()))); ++j)
seg[i * 3 + j].insert(base[i][(j + 0) % 3]);
for (long long int i = 0;
i < ((long long int)(((long long int)(base).size()))); ++i)
for (long long int j = 0;
j < ((long long int)(((long long int)(base[i]).size()))); ++j)
seg[i * 3 + j].insert(base[i][(j + 1) % 3]);
for (long long int i = 0;
i < ((long long int)(((long long int)(base).size()))); ++i)
for (long long int j = 0;
j < ((long long int)(((long long int)(base[i]).size()))); ++j)
for (long long int k = 0; k < ((long long int)(i)); ++k)
for (long long int l = 0;
l < ((long long int)(((long long int)(base[k]).size()))); ++l) {
if (i == k) continue;
P cross = findSegCross(base[i][j], base[i][(j + 1) % 3], base[k][l],
base[k][(l + 1) % 3]);
if (isnan(cross)) continue;
seg[i * 3 + j].insert(cross);
seg[k * 3 + l].insert(cross);
}
VagueDouble res = 0.0;
vector<P> vec[10005];
for (long long int i = 0;
i < ((long long int)(((long long int)(base).size()))); ++i)
for (long long int j = 0;
j < ((long long int)(((long long int)(base[i]).size()))); ++j)
for (__typeof((seg[i * 3 + j]).begin()) it = (seg[i * 3 + j]).begin();
it != (seg[i * 3 + j]).end(); it++)
vec[i * 3 + j].push_back(*it);
for (long long int i = 0;
i < ((long long int)(((long long int)(base).size()))); ++i)
for (long long int j = 0;
j < ((long long int)(((long long int)(base[i]).size()))); ++j)
for (long long int k = 0;
k < ((long long int)(((long long int)(vec[i * 3 + j]).size()) - 1));
++k) {
P mid = (vec[i * 3 + j][k] + vec[i * 3 + j][k + 1]) / 2.0;
bool ok = true;
for (long long int l = 0;
l < ((long long int)(((long long int)(base).size()))); ++l)
if (i != l && base[l].inPoly(mid)) {
ok = false;
break;
}
if (ok) res += dist(vec[i * 3 + j][k], vec[i * 3 + j][k + 1]);
}
printf("%0.20lf\n", res.to_double());
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
bool arr[407][407];
int main() {
cin.sync_with_stdio(0);
int n, m;
cin >> n >> m;
bool win = false;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
if ((x == 0 && y == n - 1) || (x == n - 1 && y == 0)) win = true;
arr[x][y] = arr[y][x] = true;
}
vector<bool> vis(n, false);
vis[0] = true;
queue<pair<int, int> > Q;
Q.push({0, 0});
while (!Q.empty()) {
pair<int, int> x = Q.front();
Q.pop();
if (x.first == n - 1) {
cout << x.second << endl;
return 0;
}
for (int i = 0; i < n; i++) {
if (arr[x.first][i] == !win && vis[i] == false) {
vis[i] = true;
Q.push({i, x.second + 1});
}
}
}
cout << -1 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp;
long long pow(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) ans = ans * a % 1000000007;
b >>= 1;
a = a * a % 1000000007;
}
return ans;
}
long long dfs(long long n) {
if (mp[n] != 0) return mp[n];
long long ans = pow(2, n - 1);
if (n > 1) ans--;
for (long long i = 2;; i++) {
if (i * i > n) break;
if (n % i == 0) {
ans = (ans - dfs(n / i) + 1000000007) % 1000000007;
if (n / i != i) ans = (ans - dfs(i) + 1000000007) % 1000000007;
}
}
return mp[n] = ans;
}
int main() {
long long x, y, i, j, k, l;
scanf("%I64d%I64d", &x, &y);
if (y % x != 0) {
printf("0\n");
return 0;
}
y /= x;
printf("%I64d", dfs(y));
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
int n, a[100000];
int main() {
vector<int> v;
cin >> n;
for (int i = 0; i < (int)n; i++) cin >> a[i], v.push_back(a[i]);
sort((v).begin(), (v).end());
for (int i = 0; i < (int)n; i++)
a[i] = lower_bound((v).begin(), (v).end(), a[i]) - v.begin() + 1;
int l = 0, r = n - 1;
while (l < r && a[l] == l + 1) l++;
while (l < r && a[r] == r + 1) r--;
reverse(a + l, a + r + 1);
bool ok = 1;
for (int i = l; i <= r; i++)
if (a[i] != i + 1) ok = 0;
if (!ok)
cout << "no" << endl;
else {
cout << "yes" << endl;
cout << l + 1 << " " << r + 1 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class qv {
public:
int v, n;
};
int mf(qv a, qv b) { return a.n < b.n; }
int n, m;
vector<vector<int>> mas;
vector<vector<long long>> imas;
vector<int> proc;
long long MAX = 1000000007;
long long msum(long long a, long long b) { return ((a + b) % MAX); }
long long mmul(long long a, long long b) { return ((a * b) % MAX); }
void count(int v) {
vector<long long> timas;
for (int i = 0; i < 4 * m; i++) timas.push_back(0);
bool flag = false;
for (int i = 0; i < 4 * m; i++) imas[v].push_back(0);
imas[v][m - 1] = 1;
proc[v] = 1;
for (vector<int>::const_iterator it = mas[v].begin(); it != mas[v].end();
++it) {
if (!proc[*it]) {
if (!flag) {
count(*it);
flag = true;
for (int i = 0; i < 2 * m; i++) imas[v][i] = imas[*it][i];
} else {
for (int i = 0; i < 4 * m; i++) timas[i] = 0;
;
count(*it);
for (int i = 0; i < 2 * m; i++) {
for (int j = 0; j < 2 * m; j++) {
if (i + j <= (2 * m - 3))
timas[min(i, j)] =
msum(timas[min(i, j)], mmul(imas[v][i], imas[*it][j]));
else
timas[max(i, j)] =
msum(timas[max(i, j)], mmul(imas[v][i], imas[*it][j]));
}
}
for (int i = 0; i < 4 * m; i++) imas[v][i] = timas[i];
}
}
}
long long sum = imas[v][0];
for (int i = 2 * m - 2; i > 0; i--) {
sum = msum(sum, imas[v][i]);
imas[v][i] = imas[v][i - 1];
}
imas[v][0] = sum;
}
int main() {
scanf("%d %d", &n, &m);
mas.resize(n + 1);
imas.resize(n + 1);
int cur;
proc.push_back(0);
for (int i = 0; i < n + 1; i++) mas[i].resize(0);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
mas[a].push_back(b);
mas[b].push_back(a);
proc.push_back(0);
}
proc.push_back(0);
m += 1;
count(1);
long long sum = 0;
for (int i = 0; i < m; i++) sum = msum(sum, imas[1][i]);
printf("%d", sum);
scanf("%d", &m);
return 0;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 2e5 + 5;
int arr[MN], n, k, i, j, nxt[MN];
long long prod, sum, ans;
int main() {
for (scanf("%d%d", &n, &k), i = 1; i <= n; i++) scanf("%d", &arr[i]);
for (i = n; i >= 1; i--) {
if (arr[i] == 1) nxt[i] = nxt[i + 1] + 1;
}
for (i = 1; i <= n; i++) {
sum = 0;
prod = 1;
for (j = i; j <= n; j++) {
if (arr[j] != 1)
prod *= arr[j], sum += arr[j];
else {
if (prod % k == 0 && sum < prod / k && sum >= prod / k - nxt[j]) ans++;
sum += nxt[j];
j += nxt[j] - 1;
continue;
}
if (sum * k == prod) ans++;
if (prod / (sum + n) > k) break;
}
}
printf("%lld\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
unsigned long long int p[1000000], arr[1000000];
int len, s[1000000];
char str[500000];
void pre() {
p[0] = 1;
for (int i = 1; i <= 2 * len; i++) p[i] = p[i - 1] * 31;
}
inline int lowbit(int x) { return x & (-x); }
void insert(int pos, unsigned long long int add) {
for (int i = pos; i <= 2 * len; i += lowbit(i)) arr[i] += add;
}
unsigned long long int query(int pos) {
unsigned long long int re = 0;
for (int i = pos; i > 0; i -= lowbit(i)) re += arr[i];
return re;
}
bool palind(int l, int r) {
if (l <= 0 || r > len) return false;
unsigned long long int a = (query(r) - query(l - 1));
unsigned long long int b = (query(2 * len - l + 1) - query(2 * len - r));
a *= p[2 * len - r + 1 - l];
return (a == b) ? true : false;
}
int main() {
int d, i, pos;
scanf("%d", &d);
d--;
scanf("%s", str);
for (i = 0; str[i] != '\0'; i++) s[i + 1] = str[i] - 'a';
len = i;
pre();
for (i = 1; i <= len; i++) s[2 * len - i + 1] = s[i];
for (i = 1; i <= len * 2; i++) insert(i, s[i] * p[i]);
for (i = 1; i <= len; i++) {
if (palind(i, i + d)) {
pos = i + d;
break;
}
if (i + d + 1 <= len && palind(i, i + d + 1)) {
pos = i + d + 1;
break;
}
}
if (i == len + 1) pos = len;
do {
while (s[pos] == 25 && pos != 1) pos--;
if (s[pos] == 25 && pos == 1) {
printf("Impossible\n");
return 0;
}
s[pos]++;
insert(pos, p[pos]);
insert(2 * len - pos + 1, p[2 * len - pos + 1]);
} while (palind(pos - d, pos) || palind(pos - d - 1, pos));
for (pos++; pos <= len; pos++) {
insert(pos, -p[pos] * s[pos]);
insert(2 * len - pos + 1, -p[2 * len - pos + 1] * s[pos]);
for (s[pos] = 0; palind(pos - d, pos) || palind(pos - d - 1, pos);
s[pos]++) {
insert(pos, p[pos]);
insert(2 * len - pos + 1, p[2 * len - pos + 1]);
}
}
for (i = 1; i <= len; i++) str[i - 1] = s[i] + 'a';
printf("%s\n", str);
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
void Weapons19() {
string s, t;
cin >> s >> t;
vector<vector<long long int>> dp(t.size() + 1,
vector<long long int>(s.size() + 1));
for (long long int i = 1; i <= t.size(); i++) {
for (long long int j = 1; j <= s.size(); j++) {
dp[i][j] = dp[i - 1][j];
if (s[j - 1] == t[i - 1]) dp[i][j] += 1 + dp[i - 1][j - 1];
dp[i][j] %= 1000000007;
}
}
long long int ans = 0;
for (long long int i = 1; i <= s.size(); i++) ans += dp[t.size()][i];
cout << ans % 1000000007;
}
int32_t main() {
cout << fixed << setprecision(16);
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
Weapons19();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, p;
cin >> n >> p;
long long int sum[n];
long long int cur = 0;
long long int inp;
for (int i = 0; i < n; i++) {
cin >> inp;
cur += inp;
sum[i] = cur;
}
long long int mx = 0;
for (int i = 0; i < n - 1; i++) {
long long int temp = sum[i] % p + (sum[n - 1] - sum[i]) % p;
if (temp > mx) mx = temp;
}
cout << mx << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int cost[n];
long long int sum = 0;
for (int i = 0; i < n; i++) {
cin >> cost[i];
sum += cost[i];
}
sort(cost, cost + n);
long long int m;
cin >> m;
long long int noOfCoupons[n];
for (int i = 0; i < m; i++) {
cin >> noOfCoupons[i];
cout << sum - cost[n - noOfCoupons[i]] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline string Next() {
string S;
cin >> S;
return S;
}
inline string NextLine() {
string S;
getline(cin, S);
return S;
}
inline int NextInt() {
int n;
scanf("%d", &n);
return n;
}
inline long long NextLong() {
long long n;
scanf("%lld", &n);
return n;
}
inline double NextDouble() {
double n;
scanf("%lf", &n);
return n;
}
const int N = (int)1e6 + 7;
const int P = (int)1e9 + 7;
int n, m, f[N];
int main() {
n = NextInt();
m = NextInt();
long long t = 1;
for (int i = 1; i <= n; ++i) {
t = t * m % P;
f[i] = (f[i - 1] * (2 * m - 1ll) + t) % P;
}
cout << (f[n] + t) % P;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
long long n, m, k;
cin >> n >> m >> k;
if (k > n + m - 2)
cout << -1;
else {
long long ans = 0;
if (n - 1 >= k) {
ans = max(ans, min(n / (k + 1), n - n / (k + 1) * k) * m);
} else {
long long res = k - n + 2;
ans = max(ans, min(m / res, m - m / res * (res - 1)));
}
swap(n, m);
if (n - 1 >= k) {
ans = max(ans, min(n / (k + 1), n - n / (k + 1) * k) * m);
} else {
long long res = k - n + 2;
ans = max(ans, min(m / res, m - m / res * (res - 1)));
}
cout << ans;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int tn, p[100500 >> 2], mu[100500];
bool e[100500];
void sieve(int n) {
mu[1] = e[1] = 1;
for (int i = 1; i <= n; i++) {
if (!e[i]) mu[p[++tn] = i] = -1;
for (int j = 1; j <= tn && i * p[j] <= n; j++) {
e[i * p[j]] = 1;
if (i % p[j] == 0) break;
mu[i * p[j]] = -mu[i];
}
}
}
int gcd(int a, int b) { return !b ? a : gcd(b, a % b); }
int n, m, o[100500], stk[100500], top, s[100500];
vector<int> d[100500];
long long ans;
void add(int x) {
int fl = 0;
for (int i = 0; i < d[x].size(); i++) fl += s[d[x][i]];
while (fl) {
if (gcd(x, stk[top]) == 1) {
ans = max(ans, 1ll * stk[top] * x);
fl--;
}
for (int i = 0; i < d[stk[top]].size(); i++)
s[d[stk[top]][i]] -= mu[d[stk[top]][i]];
top--;
}
for (int i = 0; i < d[x].size(); i++) s[d[x][i]] += mu[d[x][i]];
stk[++top] = x;
}
int main() {
scanf("%d", &n);
for (int i = 1, x; i <= n; i++) {
scanf("%d", &x);
o[x]++;
m = max(x, m);
}
sieve(m);
for (int i = 1; i <= m; i++)
for (int j = i; j <= m; j += i) {
o[i] |= o[j];
d[j].push_back(i);
}
for (int i = m; i; i--) {
if (o[i]) add(i);
if (o[i] > 1) ans = max(ans, (long long)i);
}
printf("%lld", ans);
return 0;
}
| 21 |
#include <bits/stdc++.h>
long long powermod(long long _a, long long _b, long long _m) {
long long _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a) % _m;
_b /= 2;
_a = (_a * _a) % _m;
}
return _r;
}
using namespace std;
template <typename T>
void pr(const T& t) {
cout << t << "\n";
}
template <typename T, typename U, typename... ARGS>
void pr(const T& t, const U& u, const ARGS&... args) {
cout << t << " ";
pr(u, args...);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long tt;
cin >> tt;
while (tt--) {
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 ans = 0, minn = 1e18;
for (long long i = 0; i < n; ++i) {
minn = 1e18;
for (long long j = i; j < n; ++j) {
minn = min(minn, arr[j]);
ans = max(ans, min(minn, (j - i + 1)));
}
}
pr(ans);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double tick() {
static clock_t oldt, newt = clock();
double diff = 1.0 * (newt - oldt) / CLOCKS_PER_SEC;
oldt = newt;
return diff;
}
inline long long int read() {
long long int f = 1, x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long int fastExpo(long long int a, long long int n) {
long long int res = 1;
while (n) {
if (n % 2) res = res * a;
n /= 2;
a = a * a;
}
return res;
}
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int main() {
long long int n = read();
long long int k =
(n + 4) / 1 * (n + 3) / 2 * (n + 2) / 3 * (n + 1) / 4 * n / 5;
long long int k2 = (n + 2) / 1 * (n + 1) / 2 * n / 3;
cout << k * k2 << endl;
cerr << "execution time is: " << tick() << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k, lim, m, fa[110000];
bool check(int n) {
n++;
return n == (n & -n);
}
int main() {
scanf("%d%d", &n, &k);
lim = max((n - 3) / 2, 0);
if (!(n & 1) || (k > lim) || (k == check(n)) || (n == 9 && k == 2)) {
puts("NO");
return 0;
}
puts("YES");
m = max(2 * (k - 1), 0);
for (int i = 1; i <= m; i++)
if (i & 1)
fa[i] = max(i - 2, 0);
else
fa[i] = max(i - 1, 0);
for (int i = 1; i <= n - m; i++) {
if (i == 1)
fa[i + m] = max(m - 1, 0);
else
fa[i + m] = (i >> 1) + m;
}
if (check(n - m) && k) fa[n - 1] = 2, fa[n] = 2;
for (int i = 1; i <= n; i++) printf("%d ", fa[i]);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
const long long INF = INT_MAX;
const long long INF_LL = LLONG_MAX;
const long double EPS = 1e-9;
const long long MOD = 1e9 + 7;
long long n;
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
long long t;
cin >> t;
while (t--) {
long long q;
cin >> n >> q;
vector<long long> Num(n), Dp_decr(n, -INF), Dp_incr(n, -INF);
for (long long i = 0; i < n; ++i) {
cin >> Num[i];
}
Dp_decr[0] = Num[0];
long long incr_max = 0;
long long decr_max = Num[0];
for (long long i = 1; i < n; ++i) {
Dp_decr[i] = incr_max + Num[i];
Dp_incr[i] = decr_max - Num[i];
decr_max = max(decr_max, Dp_decr[i]);
incr_max = max(incr_max, Dp_incr[i]);
}
cout << max(decr_max, incr_max) << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
if (n % 2 == 0) {
cout << "white\n"
<< "1 2" << endl;
} else {
cout << "black\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<int, int> > v;
for (int i = 3; i <= 360; i++) {
for (int j = 1; j <= i - 2; j++) {
if (j * 180 % i) continue;
v.push_back({i, j * 180 / i});
}
}
sort(v.begin(), v.end());
int t;
cin >> t;
while (t--) {
int ang;
cin >> ang;
long long ans = -1;
for (int i = 0; i < v.size(); i++) {
if (v[i].second == ang) {
ans = v[i].first;
break;
}
}
cout << ans << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a, n, i, k, b, k1, k2, w, c;
long double s;
int main() {
cin >> a >> b;
n = a + ((a - 1) / (b - 1));
cout << n << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 17;
int n, m, a[MAXN], L[MAXN], R[MAXN], parL[MAXN], parR[MAXN];
long long ans;
void set_rootR(int v, int x) {
if (parR[v] == v) {
parR[v] = x;
return;
}
set_rootR(parR[v], x);
parR[v] = x;
}
void set_rootL(int v, int x) {
if (parL[v] == v) {
parL[v] = x;
return;
}
set_rootL(parL[v], x);
parL[v] = x;
}
int find_rootR(int v) {
if (parR[v] == v) return v;
parR[v] = find_rootR(parR[v]);
return parR[v];
}
int find_rootL(int v) {
if (parL[v] == v) return v;
parL[v] = find_rootL(parL[v]);
return parL[v];
}
void addEdgeR(int v, int u) {
int root = find_rootR(u);
set_rootR(v, root);
}
void addEdgeL(int v, int u) {
int root = find_rootL(u);
set_rootL(v, root);
}
int indL(int v, int i) {
int pL = find_rootL(v);
return max(pL - (L[pL] + i), 1);
}
int indR(int v, int i) {
int pR = find_rootR(v);
return min(pR + (R[pR] + i), n);
}
int bsL(int v, int x) {
int l = v, r = n + 1;
while (l + 1 < r) {
int mid = (l + r) / 2;
int ind = indL(mid, x);
if (ind <= v)
l = mid;
else
r = mid;
}
if (indL(l, x) == v)
return l;
else
return -1;
}
int bsR(int v, int x) {
int l = 1, r = v + 1;
while (l + 1 < r) {
int mid = (l + r) / 2;
int ind = indR(mid, x);
if (ind > v)
r = mid;
else
l = mid;
}
if (indR(l, x) == v)
return l;
else
return -1;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) cin >> a[i];
if (n == 1) {
cout << 0 << endl;
return 0;
}
for (int i = 1; i <= n + 2; i++) parL[i] = parR[i] = i;
for (int i = 1; i <= m; i++) {
int tL1, tL2, tR1, tR2;
tL1 = bsL(a[i] + 1, i - 1);
tL2 = bsL(a[i] + 2, i - 1);
tR1 = bsR(a[i] - 1, i - 1);
tR2 = bsR(a[i] - 2, i - 1);
if (a[i] > 2 && tR1 != -1 && tR2 != -1) addEdgeR(tR2, tR1);
if (a[i] < n - 1 && tL1 != -1 && tL2 != -1) addEdgeL(tL2, tL1);
if (a[i] > 1 && tR1 != -1) {
int t = find_rootR(tR1);
R[t]--;
}
if (a[i] < n && tL1 != -1) {
int t = find_rootL(tL1);
L[t]--;
}
}
for (int i = 1; i <= n; i++) {
int l = indL(i, m + 1), r = indR(i, m + 1);
ans += r - l + 1;
}
cout << ans << endl;
return 0;
}
| 17 |
Subsets and Splits