solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <class D>
void read(D& res) {
res = 0;
register D g = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') g = -1;
ch = getchar();
}
while (isdigit(ch)) {
res = (res << 3) + (res << 1) + (ch ^ 48);
ch = getchar();
}
res *= g;
}
const int INF = 1e9 + 7;
vector<int> t[101000];
struct E {
int to, nt, w, v;
} e[202000];
int n, m, rot, L, R, M, sn, head[101000], tot, X, Y, W;
int siz[101000], vis[101000], dep[101000], mx[101000], val[101000], a[101000],
pa[101000], b[101000], pb[101000], q[101000], hed, tal, N, maxi, root;
int A, B;
vector<int> son;
void add(int x, int y, int w) {
e[++tot].to = y;
e[tot].nt = head[x];
head[x] = tot;
e[tot].w = w;
}
void findroot(int x, int fa) {
siz[x] = 1;
mx[x] = 0;
for (int k = head[x]; k != -1; k = e[k].nt) {
if (e[k].to == fa || vis[e[k].to]) continue;
findroot(e[k].to, x);
siz[x] += siz[e[k].to];
mx[x] = max(mx[x], siz[e[k].to]);
}
mx[x] = max(mx[x], N - siz[x]);
if (mx[x] < maxi) maxi = mx[x], root = x;
}
void D_1(int x, int fa) {
siz[x] = 1;
for (int k = head[x]; k != -1; k = e[k].nt) {
if (e[k].to == fa || vis[e[k].to]) continue;
D_1(e[k].to, x);
siz[x] += siz[e[k].to];
}
}
void divided(int x, int fa) {
if (fa) t[fa].emplace_back(x);
vis[x] = 1;
D_1(x, 0);
for (int k = head[x]; k != -1; k = e[k].nt) {
if (e[k].to == fa || vis[e[k].to]) continue;
N = siz[e[k].to];
maxi = INF;
findroot(e[k].to, x);
divided(root, x);
}
}
void D_2(int x, int fa, int depth) {
dep[x] = depth;
mx[x] = depth;
for (int k = head[x]; k != -1; k = e[k].nt) {
if (e[k].to == fa || vis[e[k].to]) continue;
val[e[k].to] = val[x] + e[k].v;
D_2(e[k].to, x, depth + 1);
mx[x] = max(mx[x], mx[e[k].to]);
}
}
inline bool bbb(int x, int y) { return mx[x] < mx[y]; }
void D_3(int x, int fa) {
if (val[x] > b[dep[x]]) b[dep[x]] = val[x], pb[dep[x]] = x;
for (int k = head[x]; k != -1; k = e[k].nt) {
if (e[k].to == fa || vis[e[k].to]) continue;
D_3(e[k].to, x);
}
}
void conquer(int x) {
if (sn) return;
son.clear();
val[x] = 0;
D_2(x, 0, 0);
for (int k = head[x]; k != -1; k = e[k].nt) {
if (vis[e[k].to]) continue;
son.emplace_back(e[k].to);
}
sort(son.begin(), son.end(), bbb);
for (int i = 0; i <= mx[x]; i++) a[i] = b[i] = -INF, pa[i] = pb[i] = 0;
maxi = 0;
a[0] = 0;
pa[0] = x;
for (auto d : son) {
for (int i = 1; i <= mx[d]; i++) b[i] = -INF, pb[i] = 0;
D_3(d, x);
hed = 1;
tal = 0;
for (int i = min(R - 1, maxi); i >= L - 1; i--) {
if (a[i] == -INF) continue;
while (hed <= tal && a[q[tal]] <= a[i]) tal--;
q[++tal] = i;
}
for (int i = 1; i <= mx[d]; i++) {
while (hed <= tal && q[hed] + i > R) {
hed++;
}
if (L - i <= maxi && L >= i && a[L - i] > -INF) {
while (hed <= tal && a[q[tal]] <= a[L - i]) {
tal--;
}
q[++tal] = L - i;
}
if (hed <= tal && b[i] + a[q[hed]] >= 0) {
sn = 1, A = pa[q[hed]], B = pb[i];
}
}
for (int i = 1; i <= mx[d]; i++) {
if (a[i] < b[i]) a[i] = b[i], pa[i] = pb[i];
}
maxi = mx[d];
}
vis[x] = 1;
for (auto d : t[x]) conquer(d);
}
int ck(int lim) {
for (int i = 1; i <= n; i++)
for (int k = head[i]; k != -1; k = e[k].nt) {
if (e[k].w < lim)
e[k].v = -1;
else
e[k].v = 1;
}
for (int i = 1; i <= n; i++) vis[i] = 0;
sn = 0;
conquer(rot);
return sn;
}
void dichotomize(int l, int r) {
if (l == r) {
return ck(l), void();
}
int mid = (l + r + 1) >> 1;
if (ck(mid))
dichotomize(mid, r);
else
dichotomize(l, mid - 1);
}
int main() {
read(n);
read(L);
read(R);
memset(head, -1, sizeof(head));
tot = -1;
for (int i = 1; i <= n - 1; i++) {
read(X);
read(Y);
read(W);
add(X, Y, W);
add(Y, X, W);
M = max(M, W);
}
N = n;
maxi = INF;
findroot(1, 0);
rot = root;
divided(root, 0);
dichotomize(0, M);
printf("%d %d", A, B);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
bool dfs(int u, vector<vector<int> >& adj, vector<int>& vis) {
vis[u] = -1;
for (auto e : adj[u]) {
if (vis[e] < 0)
return false;
else if (!vis[e] && !dfs(e, adj, vis))
return false;
}
vis[u] = 1;
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, qntdA = 0;
cin >> n >> m;
string ans = "";
vector<int> vis1(n + 1, false), vis2(n + 1, false);
vector<vector<int> > adj1(n + 1), adj2(n + 1);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj1[u].push_back(v);
adj2[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!vis1[i] && !vis2[i]) {
qntdA++;
ans += 'A';
} else
ans += 'E';
if (!dfs(i, adj1, vis1) || !dfs(i, adj2, vis2)) {
cout << "-1\n";
return 0;
}
}
cout << qntdA << '\n' << ans << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int arry[200005];
int temp[200005];
int main() {
int n, k;
while (~scanf("%d %d", &n, &k)) {
for (int i = 0; i <= n; i++) {
scanf("%d", &arry[i]);
temp[i] = arry[i];
}
arry[n + 1] = 0;
temp[n + 1] = 0;
for (int i = 1; i <= n + 1; i++) {
arry[i] += arry[i - 1] / 2;
arry[i - 1] = arry[i - 1] % 2;
}
int flag = n + 1;
for (int i = 0; i <= n; i++) {
if (arry[i] != 0) {
flag = i;
break;
}
}
long long sum = arry[n + 1];
int ans = 0;
for (int i = n; i >= 0; i--) {
sum = arry[i] + sum * 2;
if (abs(sum) > 2 * k) {
break;
}
if (i == n && temp[i] == sum) continue;
if (i <= flag && abs(sum - temp[i]) <= k) ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
long long P[(100009)] = {1}, p[(100009)] = {1}, x;
void pw(void) {
for (int k(1); k < (100009); k++)
P[k] = (P[k - 1] * (257)) % (2147483647),
p[k] = (p[k - 1] * (263)) % (1000000009);
}
void rh(char *s, int L, int N, pair<long long, long long> *T) {
if (!x++) pw();
long long H = 0, h = 0;
for (int i(0); i < L; i++)
H = (H * (257) + s[i]) % (2147483647),
h = (h * (263) + s[i]) % (1000000009);
*T = {H, h};
for (int k(L); k < N; k++)
H = (H * (257) + s[k]) % (2147483647),
H = (H - (P[L] * s[k - L]) % (2147483647) + (2147483647)) % (2147483647),
h = (h * (263) + s[k]) % (1000000009),
h = (h - (p[L] * s[k - L]) % (1000000009) + (1000000009)) % (1000000009),
T[k - L + 1] = {H, h};
}
char s[(4000000)], r[(100009)];
pair<long long, long long> Z[(4000000)];
map<pair<long long, long long>, int> T;
set<int> S;
int N, L, l;
bool ok(int I) {
int J = I, H = L / l;
S.clear();
for (int i(0); i < H; i++)
if (!T.count(Z[J]) || S.count(T[Z[J]]))
return 0;
else
S.insert(T[Z[J]]), J += l;
puts("YES"), J = I;
for (int i(0); i < H; i++)
printf("%d%c", T[Z[J]] + 1, i + 1 == H ? 10 : 32), J += l;
return 1;
}
int main(void) {
scanf("%d%d%s%d", &L, &l, s, &N), L *= l;
if (L % l) return puts("NO"), 0;
for (int i(0); i < N; i++) scanf("%s", r), rh(r, l, l, Z), T[*Z] = i;
for (int i(0); i < L; i++) s[L + i] = s[i];
rh(s, l, 2 * L, Z);
for (int i(0); i < l; i++)
if (ok(i)) return 0;
puts("NO");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, l, r, c, pl, pr, cl, cr;
cin >> a >> b >> l >> r;
c = a + b;
cl = --l / c;
cr = --r / c;
pl = l % c;
pr = r % c;
if (cl == cr) {
if (pl < a && pr < a) {
cout << pr - pl + 1 << endl;
} else if (pl < a && pr >= a) {
cout << a - pl << endl;
} else {
cout << 1 << endl;
}
} else if (a <= b) {
if (cl < cr - 1) {
cout << a + 1 << endl;
} else {
if (pr >= a) {
cout << a + 1 << endl;
} else {
if (pl >= a) {
cout << pr + 1 + 1 << endl;
} else {
int left = a - pl;
int right = pr + 1;
if (left + right > a) {
cout << a + (right == a) << endl;
} else {
cout << left + right + (right == a) << endl;
}
}
}
}
} else {
int d = a - b;
if (cl == cr - 1) {
if (pr >= a && pl >= a) {
cout << a + 1 << endl;
} else if (pr < a && pl >= a) {
cout << pr + 1 + 1 << endl;
} else if (pr >= a && pl < a) {
cout << min((a + a - pl), a + a - b) << endl;
} else if (pr < a && pl < a) {
if (pl > b) {
cout << pr + 1 + a - pl << endl;
} else {
cout << pr + 1 + a - b << endl;
}
}
} else if (cl == cr - 2) {
cout << a + max(1, d + min(0, pr - a + 1 + max(0, a - pl)));
} else {
cout << a + d;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec) is >> x;
return is;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
int n, h;
cin >> n >> h;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int ans = 0;
vector<int> b;
for (int i = 0; i < n; i++) {
b.push_back(a[i]);
sort((b).rbegin(), (b).rend());
int j = 0;
int _h = h;
while (j < b.size()) {
if (j < b.size() - 1) {
_h -= max(b[j], b[j + 1]);
j += 2;
} else {
_h -= b[j];
j++;
}
}
if (_h < 0)
break;
else {
ans++;
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0, count = 0;
for (int i = 1; i < n; i++) {
if (a[i] != a[i - 1])
count++;
else {
ans = max(ans, count);
count = 0;
}
}
cout << max(ans + 1, count + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[112345];
map<int, int> s[20];
long long gao(int c, int i) { return c * (long long)(c + 1) / 2 * (1L << i); }
int get(int x, int i) { return x & (1 << i); }
void out(map<int, int> &s) {
cout << "map:" << endl;
for (map<int, int>::iterator it = s.begin(); it != s.end(); it++)
cout << it->first << ' ' << it->second << endl;
cout << endl;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < (int)n; i++) scanf("%d", a + i);
long long sum = 0;
for (int j = 0; j < (int)20; j++) {
a[n] = 0;
int c = 0, p = -1;
for (int i = 0; i <= n; i++) {
if (a[i] & (1 << j)) {
if (!c++) p = i;
} else {
if (c) {
s[j][p] = c;
sum += gao(c, j);
}
c = 0;
}
}
}
while (m--) {
int p, v;
scanf("%d%d", &p, &v);
p--;
for (int i = 0; i < (int)20; i++) {
map<int, int> &ss = s[i];
if (ss.size()) {
}
if (get(v, i) != get(a[p], i)) {
if (get(v, i)) {
if (p + 1 < n && get(a[p + 1], i)) {
int t;
sum += gao(t = ss[p] = ss[p + 1] + 1, i);
sum -= gao(t - 1, i);
ss.erase(p + 1);
} else {
ss[p] = 1;
sum += gao(1, i);
}
if (p - 1 >= 0 && get(a[p - 1], i)) {
int t, t0;
map<int, int>::iterator it;
it = ss.lower_bound(p);
it--;
int x = it->first, y = it->second;
sum += gao(ss[x] = y + ss[p], i);
sum -= gao(ss[p], i);
sum -= gao(y, i);
ss.erase(p);
}
} else {
map<int, int>::iterator it;
it = ss.upper_bound(p);
it--;
int x = it->first, y = it->second;
assert(x <= p && x + y > p);
sum -= gao(y, i);
ss.erase(x);
if (x < p) {
ss[x] = p - x;
sum += gao(p - x, i);
}
if (x + y - 1 > p) {
ss[p + 1] = x + y - 1 - p;
sum += gao(x + y - 1 - p, i);
}
}
}
}
a[p] = v;
cout << sum << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
vector<string> s(9);
for (int i = 0; i < 9; i++) cin >> s[i];
s[0][1] = s[0][0];
s[1][4] = s[1][3];
s[2][7] = s[2][6];
s[3][2] = s[3][1];
s[4][5] = s[4][4];
s[5][8] = s[5][7];
s[6][0] = s[6][2];
s[7][3] = s[7][5];
s[8][6] = s[8][8];
for (int i = 0; i < 9; i++) cout << s[i] << endl;
}
return (0);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
if (n == 1 && t == 10)
cout << -1;
else {
switch (t) {
case 2:
for (int i = 0; i < n; i++) cout << 2;
break;
case 3:
for (int i = 0; i < n; i++) cout << 3;
break;
case 4:
for (int i = 0; i < n; i++) cout << 4;
break;
case 5:
for (int i = 0; i < n; i++) cout << 5;
break;
case 6:
for (int i = 0; i < n; i++) cout << 6;
break;
case 7:
for (int i = 0; i < n; i++) cout << 7;
break;
case 8:
for (int i = 0; i < n; i++) cout << 8;
break;
case 9:
for (int i = 0; i < n; i++) cout << 9;
break;
case 10:
for (int i = 0; i < n - 1; i++) cout << 1;
cout << 0;
break;
};
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, i, x, sum = 0;
vector<long long> p;
vector<pair<long long, long long>> v;
cin >> n;
for (i = 0; i < n; ++i) {
cin >> x;
v.push_back({x, i});
sum += x;
}
sort(v.begin(), v.end());
sum -= v[n - 1].first;
for (i = 0; i < n - 1; ++i) {
if (sum - v[i].first == v[n - 1].first) p.push_back(v[i].second);
}
sum -= v[n - 2].first;
if (sum == v[n - 2].first) p.push_back(v[n - 1].second);
cout << p.size() << "\n";
for (auto x : p) cout << x + 1 << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0;
char c = getchar();
bool ok = 0;
while (c < 48 || c > 57) ok |= (c == '-'), c = getchar();
while (c > 47 && c < 58) x *= 10, x += c - 48, c = getchar();
if (ok) x = -x;
return x;
}
void print(long long x) { printf("%I64d\n", x); }
const int MAX_N = 702;
bool G[MAX_N][MAX_N];
long long D[MAX_N];
long long C[MAX_N][MAX_N], ans, n, m;
int main() {
n = read(), m = read();
while (m--) {
int x = read() - 1, y = read() - 1;
G[x][y] = G[y][x] = 1;
}
for (int u = 0; u < n; u++) {
long long cnt = 0;
for (int v = 0; v < n; v++) {
if (G[v][u]) cnt++;
}
D[u] = cnt;
}
for (int u = 0; u < n; u++) {
for (int v = u + 1; v < n; v++) {
for (int x = 0; x < n; x++) {
if (G[u][x] && G[v][x]) C[u][v]++, C[v][u]++;
}
}
}
long long cost = 0;
for (int u = 0; u < n; u++) {
for (int v = 1 + u; v < n; v++) {
for (int x = 0; x < n; x++) {
if (v == x || x == u || !G[u][v]) continue;
ans += (C[u][x] - (G[v][x] ? 1LL : 0LL)) *
(C[v][x] - (G[u][x] ? 1LL : 0LL));
if (G[u][x] && G[v][x]) cost += D[x] - 2;
}
}
}
ans -= cost;
ans /= 5LL;
print(ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string j;
cin >> j;
if (j == "0") {
cout << 4 << endl;
return 0;
}
string s = "";
if (j.length() > 1) s = s + j.at(j.length() - 2);
s = s + j.at(j.length() - 1);
stringstream ss;
ss << s;
int n, result = 0;
ss >> n;
int mod = n % 4;
if (mod == 0) result = 7 + 6;
if (mod == 1) result = 5 + 4;
if (mod == 2) result = 13 + 6;
if (mod == 3) result = 15 + 4;
result++;
cout << result % 5 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main(void) {
int n;
cin >> n >> s;
int l = 0, r = 0;
for (auto &c : s)
if (c == 'L')
++l;
else
++r;
cout << r + l + 1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, buka = 0, tutup = 0, awal = 0, hsl = 0;
string s;
cin >> n >> s;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '(')
buka++;
else
tutup++;
}
if (buka != tutup) {
cout << -1 << endl;
return;
}
tutup = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == ')') {
tutup++;
if (tutup == 1) awal = i;
} else {
tutup--;
if (tutup == 0) hsl += (i - awal + 1);
}
}
cout << hsl << endl;
}
int main() { solve(); }
| 2 |
#include <bits/stdc++.h>
using namespace std;
int input() {
int res = 0;
char c = ' ';
while (c < '0') c = getchar();
while (c >= '0') res = res * 10 + (c - '0'), c = getchar();
return res;
}
const int N = 1e5 + 1;
long long fact[N];
int main() {
fact[1] = 1;
for (long long i = 2; i <= 13; ++i) fact[i] = fact[i - 1] * i;
long long a, b;
cin >> a >> b;
cout << fact[min(a, b)];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string tostring(int a) {
ostringstream temp;
temp << a;
return temp.str();
}
int gcd(int a, int b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
bool isPrime(unsigned long long n) {
if (n <= 3) {
return n > 1;
}
if (n % 2 == 0 || n % 3 == 0) {
return false;
}
for (unsigned long long i = 5; i * i <= n; i += 6) {
if (n % i == 0 || n % (i + 2) == 0) {
return false;
}
}
return true;
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
void multiply(long long F[2][2], long long M[2][2]);
void power(long long F[2][2], long long n);
long long fib(long long n) {
long long F[2][2] = {{1, 1}, {1, 0}};
if (n == 0) return 0;
power(F, n - 1);
return F[0][0];
}
void power(long long F[2][2], long long n) {
if (n == 0 || n == 1) return;
long long M[2][2] = {{1, 1}, {1, 0}};
power(F, n / 2);
multiply(F, F);
if (n % 2 != 0) multiply(F, M);
}
void multiply(long long F[2][2], long long M[2][2]) {
long long x = F[0][0] * M[0][0] + F[0][1] * M[1][0];
long long y = F[0][0] * M[0][1] + F[0][1] * M[1][1];
long long z = F[1][0] * M[0][0] + F[1][1] * M[1][0];
long long w = F[1][0] * M[0][1] + F[1][1] * M[1][1];
F[0][0] = x;
F[0][1] = y;
F[1][0] = z;
F[1][1] = w;
}
long long sumOfDigits(long long in) {
long long sum = 0;
while (in > 0) {
sum += in % 10;
in /= 10;
}
return sum;
}
long long fact(long long in) {
long long res = 1, mult = 2;
while (mult < in + 1) {
res *= mult;
mult++;
}
return res;
}
struct str {
int x, y, z;
bool operator<(const str rhs) const {
if (x < rhs.x) {
return true;
} else if (x == rhs.x) {
if (y < rhs.y) {
return true;
} else if (y == rhs.y) {
return z < rhs.z;
}
}
return false;
}
} struct1[100];
int n, m, r;
char alph[26] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
multiset<string> ms;
vector<char> vec;
pair<long long, long long> p[170000];
queue<int> que;
map<int, int> mp;
set<string> st;
char t[107][107];
int main() {
cin >> n >> m;
int w = n - m, e = 0, o = 0, i = 0;
long long sum = 0;
int* d = new int[n];
for (int i = 0; i < n; i++) {
cin >> d[i];
if (d[i] % 2 == 0) {
e++;
} else {
o++;
}
sum += d[i];
}
again:
if (w - i == 0) {
if (sum % 2 == 0) {
cout << "Daenerys" << endl;
} else {
cout << "Stannis" << endl;
}
return 0;
}
if (o == 0) {
cout << "Daenerys" << endl;
} else if (e == 0) {
if (sum % 2 == 0) {
if ((w - i) % 2 == 0) {
cout << "Daenerys" << endl;
} else {
cout << "Stannis" << endl;
}
} else {
if ((w - i) % 2 == 1) {
cout << "Daenerys" << endl;
} else {
cout << "Stannis" << endl;
}
}
} else {
if (i % 2 == 0) {
if (sum % 2 == 0 && i == w - 1) {
o--;
sum--;
} else {
e--;
}
} else {
if (sum % 2 == 0 && i == w - 1) {
e--;
} else {
o--;
sum--;
}
}
i++;
goto again;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int b[1000001];
for (int i = 0; i < 1000001; i++) {
b[i] = 1;
}
for (int i = 2; i < (int)sqrt(1000001) + 1; i++) {
if (b[i - 2]) {
for (int j = 2 * i; j < 1000001; j += i) {
b[j - 2] = 0;
}
}
}
int x2;
scanf("%d", &x2);
int p = 1;
int inter1 = 1;
while (p * p <= x2) {
if (x2 % p == 0) {
if (b[x2 / p - 2]) {
if (x2 / p > inter1) {
inter1 = x2 / p;
}
} else if (b[p - 2]) {
if (p > inter1) {
inter1 = p;
}
}
}
p++;
}
int ans = x2;
for (int x1 = x2; x1 > x2 - inter1; x1--) {
int p = 2;
int inter2 = 1;
while (p * p <= x1) {
if (x1 % p == 0) {
if (b[x1 / p - 2]) {
if (x1 / p > inter2) {
inter2 = x1 / p;
}
} else if (b[p - 2]) {
if (p > inter2) {
inter2 = p;
}
}
}
p++;
}
if (x1 - inter2 + 1 < ans) ans = x1 - inter2 + 1;
}
if (ans < 3) {
printf("3");
} else {
printf("%d", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long S;
class Line {
public:
long long a, b;
long long dd;
};
long long cachetime(Line p, Line q) {
long long a = q.a - p.a, b = p.b - q.b;
return (b + a - 1) / a;
}
const int maxn = 200000 + 10;
Line q[maxn];
int head, tail;
struct VC {
long long v, c;
};
bool operator<(VC a, VC b) { return a.c < b.c || (a.c == b.c && a.v > b.v); }
VC b[maxn];
int n;
void init() {
cin >> n >> S;
for (int i = 0; i < n; i++) {
int v, c;
scanf("%d%d", &v, &c);
b[i].v = v;
b[i].c = c;
}
sort(b, b + n);
int j = 0;
for (int i = 0; i < n; i++) {
if (j && b[i].v <= b[j - 1].v) {
} else {
b[j++] = b[i];
}
}
n = j;
}
long long work() {
head = 0, tail = -1;
Line l;
l.a = b[0].v;
l.b = 0;
q[++tail] = l;
int i = 1;
while (i < n) {
long long tl = (b[i].c - q[head].b + q[head].a - 1) / q[head].a;
long long ts = (S - q[head].b + q[head].a - 1) / q[head].a;
if (head < tail && q[head + 1].dd <= tl) {
if (q[head + 1].dd >= ts) {
return ts;
}
head++;
continue;
}
if (tl >= ts) {
return ts;
}
long long mon = tl * (q[head].a - b[i].v) + (q[head].b - b[i].c);
l.a = b[i].v;
l.b = mon;
while (head <= tail) {
l.dd = cachetime(q[tail], l);
if (l.dd <= q[tail].dd) {
tail--;
} else {
break;
}
}
if (l.dd <= S) {
q[++tail] = l;
}
i++;
}
while (true) {
long long ts = (S - q[head].b + q[head].a - 1) / q[head].a;
if (head == tail) return ts;
if (q[head + 1].dd >= ts) return ts;
head++;
}
return 0;
}
int main() {
init();
long long res = work();
cout << res << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int ok(int a, int b) {
if (a * (b / a) == b)
return 1;
else
return 0;
}
int main() {
int n, m, i, j, k = 0, a[50], b[50], c[2500];
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
cin >> m;
for (i = 0; i < m; i++) cin >> b[i];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (ok(a[i], b[j])) {
c[k] = (b[j] / a[i]);
k++;
}
}
}
int max = c[0];
int d = 0;
for (i = 0; i < k; i++)
if (c[i] > max) max = c[i];
for (i = 0; i < k; i++)
if (c[i] == max) d++;
cout << d << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000000;
const int MAXN = 160;
const int INF2 = 100000;
int ans = INF;
bitset<MAXN> cn;
bitset<MAXN> cn2;
bitset<MAXN> op1[MAXN];
bitset<MAXN> op2[MAXN];
bitset<MAXN> go[MAXN];
bitset<MAXN> go2[MAXN];
bitset<MAXN> ago[MAXN];
int ff[MAXN][MAXN];
int n, m;
vector<tuple<int, int, int> > eds;
void pow2(int b) {
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) ago[i][j] = (i == j);
for (int i = 0; i < n; ++i) go2[i] = go[i];
while (b) {
while (!(b & 1)) {
b >>= 1;
for (int i = 0; i < n; ++i) op1[i] = go2[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) op2[i][j] = go2[j][i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) go2[i][j] = (op1[i] & op2[j]).any();
}
--b;
for (int i = 0; i < n; ++i) op1[i] = ago[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) op2[i][j] = go2[j][i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) ago[i][j] = (op1[i] & op2[j]).any();
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int a, b, d;
scanf("%d%d%d", &a, &b, &d);
--a;
--b;
eds.push_back(make_tuple(d, a, b));
}
sort(eds.begin(), eds.end());
cn[0] = 1;
int lst = 0;
for (int i = 0; i < (int)eds.size(); ++i) {
int a, b, d;
tie(d, a, b) = eds[i];
pow2(d - lst);
for (int j = 0; j < n; ++j) cn2[j] = (ago[j] & cn).any();
cn = cn2;
lst = d;
go[b][a] = 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (go[j][i])
ff[i][j] = 1;
else
ff[i][j] = INF2;
for (int k = 0; k < n; ++k)
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (ff[i][k] + ff[k][j] < ff[i][j]) ff[i][j] = ff[i][k] + ff[k][j];
for (int i = 0; i < n; ++i)
if (cn[i]) {
if (ff[i][n - 1] < INF2 && lst + ff[i][n - 1] < ans)
ans = lst + ff[i][n - 1];
}
}
if (ans >= INF)
cout << "Impossible\n";
else
cout << ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t < f) t = f;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
const int R = 4;
const int S = R * R / 2;
int uf[4000010];
int root(int x) { return (uf[x] < 0) ? x : (uf[x] = root(uf[x])); }
bool conn(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return 0;
if (uf[x] > uf[y]) swap(x, y);
uf[x] += uf[y];
uf[y] = x;
return 1;
}
int N;
inline int _(int x, int y) { return x * N + y; }
int A[2010][2010];
int B[2010][2010];
int C[2010][2010];
vector<pair<int, int> > ps[4000010];
int main() {
int x, y;
int r;
for (; ~scanf("%d", &N);) {
for (x = 0; x < N; ++x)
for (y = 0; y < N; ++y) {
A[x][y] = in();
}
for (x = 0; x < N; ++x)
for (y = 0; y < N; ++y) {
B[x + 1][y + 1] = B[x + 1][y] + B[x][y + 1] - B[x][y] + A[x][y];
}
for (x = 0; x + R <= N; ++x)
for (y = 0; y + R <= N; ++y) {
C[x][y] = B[x + R][y + R] - B[x + R][y] - B[x][y + R] + B[x][y];
}
memset(uf, ~0, sizeof(uf));
for (x = 0; x + R <= N; ++x)
for (y = 0; y + R <= N; ++y)
if (C[x][y] > S) {
if (x)
if (C[x - 1][y] > S) conn(_(x - 1, y), _(x, y));
if (y)
if (C[x][y - 1] > S) conn(_(x, y - 1), _(x, y));
}
for (r = 0; r < N * N; ++r) {
ps[r].clear();
}
for (x = 0; x + R <= N; ++x)
for (y = 0; y + R <= N; ++y)
if (C[x][y] > S) {
r = root(_(x, y));
ps[r].push_back(make_pair(x, y));
}
int ansC = 0, ansS = 0;
for (r = 0; r < N * N; ++r)
if (!ps[r].empty()) {
int sz = ps[r].size(), i;
if (sz < 30) continue;
double ox = 0, oy = 0;
for (i = 0; i < sz; ++i) {
x = ps[r][i].first;
y = ps[r][i].second;
ox += x;
oy += y;
}
ox /= sz;
oy /= sz;
double rad = 0;
for (i = 0; i < sz; ++i) {
x = ps[r][i].first;
y = ps[r][i].second;
chmax(rad, (x - ox) * (x - ox) + (y - oy) * (y - oy));
}
double ratio = sz / rad;
(ratio > 2.7) ? ++ansC : ++ansS;
}
printf("%d %d\n", ansC, ansS);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int val[200005];
int main() {
ios::sync_with_stdio(false);
long long n;
while (cin >> n) {
for (int i = 0; i < n; i++) cin >> val[i];
sort(val, val + n);
long long ans;
long long suma = 1, sumb = 1;
int i = 1;
while (i < n && val[i] == val[0]) {
suma++;
i++;
}
i = n - 2;
while (i >= 0 && val[i] == val[n - 1]) {
sumb++;
i--;
}
if (val[0] != val[n - 1])
ans = suma * sumb;
else
ans = n * (n - 1) / 2;
cout << val[n - 1] - val[0] << " " << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 7;
const long long maxn = (long long)1e6 + 5;
const int nnn = 1048590;
const int inf = numeric_limits<int>::max() - 1;
long long dx[] = {0, 1, 0, -1};
long long dy[] = {1, 0, -1, 0};
long long dxx[] = {0, 1, 0, -1, 1, 1, -1, -1};
long long dyy[] = {1, 0, -1, 0, 1, -1, 1, -1};
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
const long long N = 1e5 + 5;
long long p[N];
long long good[maxn];
long long find(long long a) {
if (a == p[a]) return a;
return p[a] = find(p[a]);
}
vector<long long> v[N];
vector<pair<long long, long long> > ans;
struct node {
long long x, y, cost;
} g[maxn];
void merge(long long a, long long b, long long j) {
a = find(a);
b = find(b);
if (v[a].size() > v[b].size()) swap(a, b);
for (auto i : v[a]) {
if (good[i]) continue;
if (find(g[i].y) == a) swap(g[i].x, g[i].y);
if (find(g[i].y) == b) {
ans.push_back({i, g[j].cost});
continue;
}
v[b].push_back(i);
}
p[a] = b;
return;
}
void solve() {
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= n; i++) p[i] = i;
memset(good, 0, sizeof(good));
vector<pair<long long, long long> > tmp;
for (long long i = 1; i <= m; i++) {
long long x, y, cost;
cin >> x >> y >> cost;
v[x].push_back(i);
v[y].push_back(i);
g[i] = {x, y, cost};
tmp.push_back({cost, i});
}
sort(tmp.begin(), tmp.end());
for (auto [dump, i] : tmp) {
if (find(g[i].x) == find(g[i].y)) continue;
good[i] = 1;
merge(g[i].x, g[i].y, i);
}
sort(ans.begin(), ans.end());
for (auto [dump, u] : ans) cout << u << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long T = 1;
while (T--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[1000005], b[1000005], arr[1000005], LDS[1000005];
bool cmp(int a, int b) { return a > b; }
int main() {
int n, x, y;
cin >> n;
for (int(i) = (0); (i) < (n); (i)++) cin >> a[i];
for (int(i) = (0); (i) < (n); (i)++) {
scanf("%d", &y);
b[y] = i;
}
for (int(i) = (0); (i) < (n); (i)++) arr[i] = b[a[i]];
int lds = 0;
for (int(i) = (0); (i) < (n); (i)++) {
int p2 = lower_bound(LDS, LDS + lds, arr[i], cmp) - LDS;
LDS[p2] = arr[i];
lds = max(lds, p2 + 1);
}
cout << lds << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<long long, long long> a[200005];
long long ans, mx;
pair<long long, long long> t[4 * 200005];
pair<long long, long long> merge(pair<long long, long long> a,
pair<long long, long long> b) {
if (a.first != b.first) return min(a, b);
return make_pair(a.first, (a.second + b.second) % 1000000007ll);
}
void upd(int v, int l, int r, int pos, pair<long long, long long> val) {
if (l == r) {
t[v] = val;
return;
}
int m = (l + r) >> 1;
if (pos <= m)
upd(v * 2, l, m, pos, val);
else
upd(v * 2 + 1, m + 1, r, pos, val);
t[v] = merge(t[v * 2], t[v * 2 + 1]);
}
pair<long long, long long> get(int v, int l, int r, int i, int j) {
if (i > j) return make_pair(1000000007ll, 0);
if (l == i && r == j) return t[v];
int m = (l + r) >> 1;
return merge(get(v * 2, l, m, i, min(j, m)),
get(v * 2 + 1, m + 1, r, max(m + 1, i), j));
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%lld%lld", &a[i].second, &a[i].first);
sort(a + 1, a + 1 + n);
reverse(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
int l, r, m, pos = 0;
l = 1;
r = i - 1;
while (l <= r) {
m = (l + r) >> 1;
if (a[m].first >= a[i].second) {
pos = m;
l = m + 1;
} else
r = m - 1;
}
if (pos) {
pair<long long, long long> mn = get(1, 1, n, 1, pos);
upd(1, 1, n, i,
make_pair(mn.first - a[i].second + a[i].first, mn.second));
} else
upd(1, 1, n, i, make_pair(a[i].first, 1));
}
cout << get(1, 1, n, 1, n).second << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(const pair<int, int>& p1, const pair<int, int>& p2) {
return p2.first > p1.first;
}
bool cmp2(const pair<int, int>& p1, const pair<int, int>& p2) {
return p2.second > p1.second;
}
int main(int argc, char* argv[]) {
int n, k;
int aux[123];
scanf("%d %d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &aux[i]);
}
vector<pair<int, int> > v;
v.resize(n);
for (int i = 0; i < n; ++i) {
v[i].first = aux[i];
v[i].second = i + 1;
}
sort(v.begin(), v.end(), cmp);
int ans = 0;
int i;
for (i = 0; i < n; ++i) {
ans += v[i].first;
if (ans > k) break;
}
sort(v.begin(), v.begin() + i, cmp2);
printf("%d\n", i);
if (i)
printf("%d", v[0].second);
else
return 0;
for (int j = 1; j < i; ++j) {
printf(" %d", v[j].second);
}
cout << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 1e3 + 4;
struct matrix {
long long mat[2][2];
void null() { memset(mat, 0, sizeof(mat)); }
void identity() {
null();
mat[0][0] = mat[1][1] = 1;
}
matrix operator*(matrix &obj) {
matrix res;
res.null();
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
long long here = (mat[i][k] * obj.mat[k][j]) % mod;
res.mat[i][j] = (res.mat[i][j] + here) % mod;
}
}
}
return res;
}
};
matrix me(matrix a, long long b) {
matrix res;
res.identity();
while (b) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
int main() {
long long a, b, n, x;
cin >> a >> b >> n >> x;
matrix base;
base.identity();
base.mat[0][0] = a;
base.mat[0][1] = 1;
matrix res = me(base, n);
long long ans = (res.mat[0][0] * x) % mod;
long long val = (res.mat[0][1] * b) % mod;
ans = (ans + val) % mod;
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int s;
cin >> s;
long long int p = s / 9;
if (s % 9 == 0)
cout << s + p - 1 << endl;
else
cout << s + p << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
int n, m;
int mem[1010][1010];
int p[1010][1010];
int solve_bottomup(int i, int j) {
if (i == n) return (m - j);
if (j == m) return (n - i);
int& res = mem[i][j];
if (res != -1) return res;
res = (1 << 20);
if (s[i] == t[j])
res = solve_bottomup(i + 1, j + 1);
else
res = min(res, min(1 + solve_bottomup(i + 1, j + 1),
min(1 + solve_bottomup(i + 1, j),
1 + solve_bottomup(i, j + 1))));
return res;
}
int solve(int i, int j) {
if (i == 0) return j;
if (j == 0) return i;
int& res = mem[i][j];
if (res != -1) return res;
res = (1 << 20);
if (s[i] == t[j])
res = solve(i - 1, j - 1);
else
res = min(res, min(1 + solve(i - 1, j - 1),
min(1 + solve(i - 1, j), 1 + solve(i, j - 1))));
return res;
}
int dp[1010][1010];
int main() {
ios::sync_with_stdio(false);
cin >> s;
cin >> t;
n = s.length();
m = t.length();
memset(mem, -1, sizeof mem);
for (int i = 0; i <= m; i++) dp[0][i] = i;
for (int i = 0; i <= n; i++) dp[i][0] = i;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
dp[i][j] = min((s[i - 1] != t[j - 1]) + dp[i - 1][j - 1],
1 + min(dp[i - 1][j], dp[i][j - 1]));
cout << dp[n][m] << endl;
int i = n, j = m;
while (i > 0 || j > 0) {
if (s[i - 1] == t[j - 1]) {
i--;
j--;
} else {
if ((i - 1 >= 0) && (j - 1 >= 0) && dp[i][j] == 1 + dp[i - 1][j - 1]) {
cout << "REPLACE " << i << " " << t[j - 1] << endl;
i--;
j--;
} else if ((i - 1 >= 0) && dp[i][j] == 1 + dp[i - 1][j]) {
cout << "DELETE " << i << endl;
i--;
} else if ((j - 1 >= 0) && dp[i][j] == 1 + dp[i][j - 1]) {
cout << "INSERT " << i + 1 << " " << t[j - 1] << endl;
j--;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int sz = 1 << 15;
char inbuf[sz], outbuf[sz];
char *pinbuf = inbuf + sz;
char *poutbuf = outbuf;
inline char _getchar() {
if (pinbuf == inbuf + sz) fread(inbuf, 1, sz, stdin), pinbuf = inbuf;
return *(pinbuf++);
}
inline void _putchar(char x) {
if (poutbuf == outbuf + sz) fwrite(outbuf, 1, sz, stdout), poutbuf = outbuf;
*(poutbuf++) = x;
}
inline void flush() {
if (poutbuf != outbuf)
fwrite(outbuf, 1, poutbuf - outbuf, stdout), poutbuf = outbuf;
}
} // namespace IO
inline int read() {
int x = 0, p = 1;
char c = IO::_getchar();
while (c < '0' || c > '9') {
if (c == '-') p = -1;
c = IO::_getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = IO::_getchar();
return x * p;
}
const int Maxn = 1e6 + 5;
char c[Maxn];
int n;
struct br {
int v, m;
br() { v = m = 0; }
br(int _v, int _m) { v = _v, m = _m; }
br(char __) {
int _x = (__ == '(') ? 1 : -1;
v = _x, m = min(0, _x);
}
br operator+(br x) { return br(v + x.v, min(m, v + x.m)); }
};
const long long mod1 = 998244353;
const long long mod2 = 1e9 + 9;
int H1[Maxn][22], H2[Maxn][22];
br pre[Maxn], suf[Maxn];
long long pw1[25], pw2[25];
bool cmp(int x, int y) {
int lim = 1;
while ((1 << lim) <= n) lim++;
for (int i = lim - 1; i >= 0; i--) {
if (H1[x][i] == H1[y][i] && H2[x][i] == H2[y][i]) {
x += 1 << i;
y += 1 << i;
if (x > n) x -= n;
if (y > n) y -= n;
}
}
return c[x] < c[y];
}
int main() {
scanf("%s", c + 1);
n = strlen(c + 1);
for (int i = 1; i <= n; i++) H1[i][0] = H2[i][0] = c[i];
pw1[0] = 3948243;
for (int i = 1; i < 25; i++) pw1[i] = pw1[i - 1] * pw1[i - 1] % mod1;
pw2[0] = 3948243;
for (int i = 1; i < 25; i++) pw2[i] = pw2[i - 1] * pw2[i - 1] % mod2;
for (int i = 1, j = 2; j <= n; i++, j <<= 1) {
for (int k = 1; k <= n; k++) {
int nk = k + (j >> 1);
if (nk > n) nk -= n;
H1[k][i] = (1ll * H1[k][i - 1] * pw1[i - 1] + H1[nk][i - 1]) % mod1;
H2[k][i] = (1ll * H2[k][i - 1] * pw2[i - 1] + H2[nk][i - 1]) % mod2;
}
}
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + br(c[i]);
}
for (int i = n; i >= 1; i--) {
suf[i] = br(c[i]) + suf[i + 1];
}
int tot = min(pre[n].v, 0);
int ans = -1;
for (int i = 1; i <= n; i++) {
br tmp = suf[i] + pre[i - 1];
if (tmp.m == tot) {
if (ans == -1)
ans = i;
else {
if (cmp(i, ans)) ans = i;
}
}
}
tot = pre[n].v;
string res;
for (int i = ans; i <= n; i++) res += c[i];
for (int i = 1; i < ans; i++) res += c[i];
if (tot > 0) {
for (int i = 0; i < tot; i++) res += ')';
} else {
string tmp;
for (int i = 0; i < (-tot); i++) tmp += '(';
res = tmp + res;
}
printf("%s\n", res.c_str());
return ~~(0 ^ 0 ^ 0);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int ar[200001];
int main() {
long long t = 1, a, b, m, n;
cin >> t;
while (t--) {
cin >> a >> b >> m >> n;
if (m + n <= a + b and n <= min(a, b))
cout << "yes" << '\n';
else
cout << "no" << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
const int inf = (int)1e9 + 1;
const long long big = (long long)1e18 + 1;
const int P = 239;
const int MOD = (int)1e9 + 7;
const int MOD1 = (int)1e9 + 9;
const double eps = 1e-9;
const double pi = atan2(0, -1);
const int ABC = 26;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
long long n;
cin >> n;
long long l = 0, r = 1500000000, mid;
while (r - l > 1) {
mid = (l + r) / 2;
if (mid * (mid + 1) * 3 <= n)
l = mid;
else
r = mid;
}
long long cnt[6] = {0, 0, 0, 0, 0, 0};
long long dx[6] = {1, -1, -2, -1, 1, 2};
long long dy[6] = {2, 2, 0, -2, -2, 0};
cnt[5] += l;
n -= l * (l + 1) * 3;
if (n > 0) {
cnt[0]++;
n--;
}
long long d;
d = min(l, n);
cnt[1] += d;
n -= d;
d = min(l + 1, n);
cnt[2] += d;
n -= d;
d = min(l + 1, n);
cnt[3] += d;
n -= d;
d = min(l + 1, n);
cnt[4] += d;
n -= d;
d = min(l + 1, n);
cnt[5] += d;
n -= d;
d = min(l + 1, n);
cnt[0] += d;
n -= d;
long long x = 0, y = 0;
for (int i = 0; i < 6; i++) {
x += dx[i] * cnt[i];
y += dy[i] * cnt[i];
}
cout << x << " " << y << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, x[300010], g[300010], h[300010], w[300010], p;
long long f[300010];
inline void orz(int i) {
int k = min(x[i], x[i + 1]);
if (k) {
w[++p] = i;
x[i] -= k;
x[i + 1] -= k;
}
}
int main() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &x[i]);
f[1] = 2 * x[1];
g[1] = 1;
f[2] = 2 * x[2];
g[2] = 1;
for (i = 3; i <= n; i++)
if (f[i - 2] + 2 * x[i] < f[i - 3] + 2 * max(x[i], x[i - 1])) {
f[i] = f[i - 2] + 2 * x[i];
g[i] = 1;
} else {
f[i] = f[i - 3] + 2 * max(x[i], x[i - 1]);
g[i] = 2;
}
for (i = (f[n] < f[n - 1] ? n : (n - 1)); i > 0; i -= g[i] + 1)
h[i] = h[i - g[i] + 1] = 1;
for (i = 1; i <= n; i++)
if (h[i] == 1 && h[i + 1] == 1) orz(i);
for (i = 1; i <= n; i++)
if (h[i] == 1) orz(i - 1), orz(i);
printf("%d\n", p);
for (i = 1; i <= p; i++) printf("%d\n", w[i]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
const int N = 1505;
const int MOD = 1000000007;
int n, m, a, b, k, jc[100005], ny[100005], pre[N], f[N][N], s[N][N], p[N];
int ksm(int x, int y) {
if (y < 0) return 0;
int ans = 1;
while (y) {
if (y & 1) ans = (long long)ans * x % MOD;
x = (long long)x * x % MOD;
y >>= 1;
}
return ans;
}
int C(int n, int m) {
if (n < m) return 0;
return (long long)jc[n] * ny[m] % MOD * ny[n - m] % MOD;
}
int main() {
scanf("%d%d%d%d%d", &n, &m, &a, &b, &k);
a = (long long)a * ksm(b, MOD - 2) % MOD;
jc[0] = jc[1] = ny[0] = ny[1] = 1;
for (int i = 2; i <= k; i++)
jc[i] = (long long)jc[i - 1] * i % MOD,
ny[i] = (long long)(MOD - MOD / i) * ny[MOD % i] % MOD;
for (int i = 2; i <= k; i++) ny[i] = (long long)ny[i - 1] * ny[i] % MOD;
for (int i = 1; i <= m; i++)
p[i] = (long long)ksm(a, i - 1) * ksm(1 + MOD - a, k - i + 1) % MOD *
C(k, i - 1) % MOD,
pre[i] = (pre[i - 1] + p[i]) % MOD;
f[0][m] = s[0][m] = 1;
for (int i = 1; i <= n; i++) {
int w = 0;
for (int j = 1; j <= m; j++) {
(w += (long long)p[j] * (s[i - 1][m] + MOD - s[i - 1][j - 1]) % MOD) %=
MOD;
f[i][j] =
(long long)(w + MOD - (long long)s[i - 1][m - j] * pre[j] % MOD) *
p[m - j + 1] % MOD;
s[i][j] = (s[i][j - 1] + f[i][j]) % MOD;
}
}
printf("%d", s[n][m]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 100;
struct segment {
long long l, r, cnt, disL, disR, ans;
};
segment tree[4 * N];
vector<pair<long long, pair<long long, long long> > > query;
vector<long long> vec;
long long a[N], tmp[N];
long long n, m, sz;
inline long long id(long long x) {
return lower_bound(vec.begin(), vec.end(), x) - vec.begin();
}
inline long long ID(long long x) {
return upper_bound(vec.begin(), vec.end(), x) - vec.begin();
}
inline void make(long long i, long long l, long long r, long long cnt,
long long disL, long long disR, long long ans) {
tree[i].l = l;
tree[i].r = r;
tree[i].cnt = cnt;
tree[i].disL = disL;
tree[i].disR = disR;
tree[i].ans = ans;
}
inline segment makeNull(long long l, long long r) {
segment null;
null.l = l;
null.r = r;
null.cnt = null.disL = null.disR = null.ans = 0;
return null;
}
inline segment merge(segment a, segment b) {
segment res;
res.l = a.l;
res.r = b.r;
res.cnt = a.cnt + b.cnt;
res.disL = a.disL + b.cnt * (vec[a.r] - vec[a.l]) + b.disL;
res.disR = b.disR + a.cnt * abs(vec[b.r] - vec[b.l]) + a.disR;
res.ans = a.ans + b.ans + abs(a.cnt * b.disL) + (b.cnt * a.disR);
return res;
}
void build(long long i = 1, long long L = 0, long long R = sz) {
make(i, L, R, 0, 0, 0, 0);
if (R - L == 1) return;
long long m = (L + R) / 2;
build(2 * i, L, m);
build(2 * i + 1, m, R);
}
void insert(long long ind, long long i = 1, long long L = 0, long long R = sz) {
if (R - L == 1) {
make(i, L, R, 1, 0, (R == sz ? 0 : vec[R] - vec[L]), 0);
return;
}
long long m = (L + R) / 2;
if (ind < m)
insert(ind, 2 * i, L, m);
else
insert(ind, 2 * i + 1, m, R);
tree[i] = merge(tree[2 * i], tree[2 * i + 1]);
}
void remove(long long ind, long long i = 1, long long L = 0, long long R = sz) {
if (R - L == 1) {
make(i, L, R, 0, 0, 0, 0);
return;
}
long long m = (L + R) / 2;
if (ind < m)
remove(ind, 2 * i, L, m);
else
remove(ind, 2 * i + 1, m, R);
tree[i] = merge(tree[2 * i], tree[2 * i + 1]);
}
segment get(long long l, long long r, long long i = 1, long long L = 0,
long long R = sz) {
if (r <= L || R <= l) return makeNull(L, R);
if (l <= L && R <= r) return tree[i];
long long m = (L + R) / 2;
return merge(get(l, r, 2 * i, L, m), get(l, r, 2 * i + 1, m, R));
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
tmp[i] = a[i];
vec.push_back(a[i]);
}
cin >> m;
for (long long i = 0; i < m; i++) {
long long t, l, r, p, d;
cin >> t;
if (t == 1) {
cin >> p >> d;
tmp[--p] += d;
vec.push_back(tmp[p]);
query.push_back(pair<long long, pair<long long, long long> >(t, {p, d}));
} else {
cin >> l >> r;
query.push_back(pair<long long, pair<long long, long long> >(t, {l, r}));
}
}
sort(vec.begin(), vec.end());
vector<long long>::iterator it = unique(vec.begin(), vec.end());
vec.resize(distance(vec.begin(), it));
sz = vec.size();
build();
for (long long i = 0; i < n; i++) insert(id(a[i]));
for (auto [t, q] : query) {
if (t == 1) {
auto [p, d] = q;
remove(id(a[p]));
a[p] += d;
insert(id(a[p]));
} else {
auto [l, r] = q;
segment res;
res = get(id(l), ID(r));
cout << res.ans << '\n';
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool check(long long n, long long pos) { return n & (1LL << pos); }
long long Set(long long n, long long pos) { return n = n | (1LL << pos); }
pair<long long, long long> arr[200];
int main() {
long long i, j, k, l, m, n, o, r, q;
long long testcase;
long long input, flag, tag, ans;
scanf("%lld", &n);
for (long long cs = 1; cs <= n; cs++) {
scanf("%lld", &arr[cs].first);
scanf("%lld", &arr[cs].second);
}
for (i = 1; i <= n; i++) {
input = arr[i].first + arr[i].second;
for (j = 1; j <= n; j++) {
if (i != j)
if (arr[j].first == input)
if (arr[j].first + arr[j].second == arr[i].first) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> v;
v.resize(n + 1);
v[0] = 0;
for (int i = 0, _n = (n); i < _n; i++) {
int x, y;
cin >> x >> y;
v[i + 1] = v[i] + x * y;
}
int ix = 0;
for (int i = 0, _n = (m); i < _n; i++) {
int x;
cin >> x;
while (v[ix] < x) {
ix++;
}
cout << ix << endl;
ix--;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dp[42][64][64];
int main() {
int n, m;
cin >> n >> m;
if (m < n) m ^= n, n ^= m, m ^= n;
int mask = (1 << n) - 1;
memset(dp, 63, sizeof(dp));
dp[0][mask][0] = 0;
for (int i = 1; i <= m + 1; i++)
for (int x = 0; x <= mask; x++)
for (int y = 0; y <= mask; y++)
for (int z = 0; z <= mask; z++) {
bool valid[8], ok = true;
for (int b = 1; b <= n; b++) valid[b] = false;
for (int b = 0; b < n; b++) {
if ((1 << b) & x) valid[b + 1] = true;
if ((1 << b) & y) valid[b + 1] = valid[b] = valid[b + 2] = true;
if ((1 << b) & z) valid[b + 1] = true;
}
for (int b = 1; b <= n; b++)
if (!valid[b]) ok = false;
if (!ok) continue;
dp[i][y][z] =
min(dp[i][y][z], dp[i - 1][x][y] + __builtin_popcount(z));
}
int ans = 0;
for (int i = 0; i <= mask; i++) ans = max(ans, n * m - dp[m + 1][i][0]);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T inline Abs(const T& x) {
return x < 0 ? -x : x;
}
template <class T>
T inline Sqr(const T& x) {
return x * x;
}
const int dx[4] = {0, 0, -1, +1};
const int dy[4] = {-1, +1, 0, 0};
const int maxn = 1610;
int a[maxn][maxn];
int s[maxn][maxn];
int c[maxn][maxn];
int b[maxn][maxn];
int color = 0;
vector<vector<pair<int, int> > > comps;
vector<int> ans;
int h, w;
void Dfs(int y, int x) {
c[y][x] = color;
comps[color].push_back(make_pair(y, x));
for (int i = 0; i < 4; ++i) {
int ny = y + dy[i];
int nx = x + dx[i];
if (ny >= 1 && ny <= h && nx >= 1 && nx <= w && c[ny][nx] == 0 &&
a[ny][nx] == 1) {
Dfs(ny, nx);
}
}
}
int cc;
void Dfs2(int y, int x) {
++cc;
b[y][x] = 1;
for (int i = 0; i < 4; ++i) {
int ny = y + dy[i];
int nx = x + dx[i];
if (ny >= 1 && ny <= h && nx >= 1 && nx <= w && c[ny][nx] == color &&
!b[ny][nx]) {
Dfs2(ny, nx);
}
}
}
int GetSum(int Yy1, int Xx1, int y2, int x2) {
--Yy1;
--Xx1;
return s[y2][x2] - s[Yy1][x2] - s[y2][Xx1] + s[Yy1][Xx1];
}
int main(int argc, char* argv[]) {
cin >> h >> w;
for (int i = 1; i <= h; ++i) {
for (int j = 1; j <= w; ++j) {
scanf("%d", &a[i][j]);
s[i][j] = a[i][j] + s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1];
}
}
for (int i = 1; i <= h; ++i) {
for (int j = 1; j <= w; ++j) {
if (c[i][j] == 0 && a[i][j] > 0) {
++color;
comps.resize(color + 1);
Dfs(i, j);
}
}
}
for (int i = 1; i <= h; ++i) {
for (int j = 1; j <= w; ++j) {
bool in = false;
in = in || i >= 4 && j >= 4 && GetSum(i - 3, j - 3, i, j) == 16;
in = in || i >= 4 && j + 3 <= w && GetSum(i - 3, j, i, j + 3) == 16;
in = in || i + 3 <= h && j >= 4 && GetSum(i, j - 3, i + 3, j) == 16;
in = in || i + 3 <= h && j + 3 <= w && GetSum(i, j, i + 3, j + 3) == 16;
if (in) {
c[i][j] = -1;
}
}
}
ans.resize(comps.size());
memset(b, 0, sizeof(b));
for (int i = 1; i < comps.size(); ++i) {
color = i;
for (int j = 0; j < comps[i].size(); ++j) {
int y = comps[i][j].first;
int x = comps[i][j].second;
if (c[y][x] == i && !b[y][x]) {
cc = 0;
Dfs2(y, x);
if (cc >= 20) {
++ans[i];
}
}
}
}
ans.erase(ans.begin(), ans.begin() + 1);
sort(ans.begin(), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); ++i) {
printf("%d ", ans[i]);
}
cout << endl;
return 0;
}
| 7 |
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
typedef long long ll;
//#define int long long
#define bug(i) cout<<"++"<<i<<endl
#define bug1(i,j) cout<<"++"<<i<<" "<<j<<endl
#define MEM(arr,w) memset(arr,w,sizeof(arr));
const int N=1e5+2100;
const int INF=1e9;
int n,m,t,k;
int ans=0;
signed main()
{
cin>>t;
while(t--)
{
cin>>n;
if(n<=3)
{
cout<<n-1<<endl;
}
else
{
if(n%2)
{
cout<<3<<endl;
}
else
{
cout<<2<<endl;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string str;
int ANS[4] = {4, 0, 0, 0}, sol;
int main() {
cin >> str;
if (str.size() >= 4) str = str.substr(str.size() - 3, 3);
for (int i = 0; i < str.size(); i++) {
sol *= 10;
sol += str[i] - '0';
}
sol %= 4;
cout << ANS[sol] << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, ans = 0;
cin >> n;
string s;
cin >> s;
int help[4] = {0}, flag = 0;
if (s[0] == 'R')
help[0] = 1;
else if (s[0] == 'L')
help[1] = 1;
else if (s[0] == 'U')
help[2] = 1;
else if (s[0] == 'D')
help[3] = 1;
for (i = 1; i < s.length(); i++) {
if (s[i] == 'R' && help[1] == 1) {
ans++;
help[0] = 1;
help[1] = help[2] = help[3] = 0;
} else if (s[i] == 'L' && help[0] == 1) {
ans++;
help[1] = 1;
help[0] = help[2] = help[3] = 0;
} else if (s[i] == 'U' && help[3] == 1) {
ans++;
help[2] = 1;
help[0] = help[1] = help[3] = 0;
} else if (s[i] == 'D' && help[2] == 1) {
ans++;
help[3] = 1;
help[0] = help[1] = help[2] = 0;
} else {
if (s[i] == 'R')
help[0] = 1;
else if (s[i] == 'L')
help[1] = 1;
else if (s[i] == 'U')
help[2] = 1;
else
help[3] = 1;
flag = 1;
}
}
cout << ans + 1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, i, j, sum = 0, a;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> a;
sum += a;
}
sum += (n - 1);
if (sum > m || sum < m)
cout << "NO\n";
else
cout << "YES\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
const int mod = 1e9 + 7;
int sum[N + 5];
long long fact[N + 5];
long long myPow(long long a, long long n) {
long long ans = 1;
while (n != 0) {
if (n & 1) {
(ans *= a) %= mod;
}
(a *= a) %= mod;
n >>= 1;
}
return ans;
}
long long nCk(long long k, long long n) {
long long d = (fact[n - k] * fact[k]) % mod;
return (fact[n] * myPow(d, mod - 2)) % mod;
}
int main() {
string s;
cin >> s;
int i, n = s.size();
fact[0] = 1;
for (i = 1; i <= 2e5; i++) {
fact[i] = (fact[i - 1] * (long long)i) % mod;
}
for (i = n - 1; i >= 0; i--) {
if (s[i] == ')') {
sum[i]++;
}
sum[i] += sum[i + 1];
}
long long ans = 0;
int d = 0;
for (i = 0; i < n; i++) {
if (s[i] == '(') {
d++;
} else {
continue;
}
(ans += nCk(d, d + sum[i] - 1)) %= mod;
}
printf("%I64d", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, x, y, maxx, maxy, minx, miny, max, z;
maxx = pow(10, 9) * (-1) - 1;
maxy = pow(10, 9) * (-1) - 1;
minx = pow(10, 9) + 1;
miny = pow(10, 9) + 1;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x >> y;
if (x > maxx) maxx = x;
if (x < minx) minx = x;
if (y > maxy) maxy = y;
if (y < miny) miny = y;
}
z = maxx - minx;
if (fabs(maxy - miny) > fabs(z)) z = maxy - miny;
max = pow(z, 2);
cout << max;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int N = 2e5 + 5;
double dp[N];
int t[N];
double sum[3][N];
double getVal(int l, int r) {
return sum[1][r] - sum[1][l - 1] -
sum[0][l - 1] * (sum[2][r] - sum[2][l - 1]);
}
void solve(int l, int r, int pl, int pr) {
if (l > r) return;
int mid = (l + r) >> 1;
double ans = 1e18, tot;
int s = -1;
for (int j = std::max(mid + 1, pl); j <= pr; j++) {
tot = getVal(mid, j - 1);
if (tot + dp[j] < ans) {
ans = tot + dp[j];
s = j;
}
}
solve(l, mid - 1, pl, s);
solve(mid + 1, r, s, pr);
dp[mid] = ans;
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", t + i);
sum[0][i] = sum[0][i - 1] + t[i];
sum[1][i] = sum[1][i - 1] + sum[0][i] / t[i];
sum[2][i] = sum[2][i - 1] + 1.0 / t[i];
}
for (int i = 1; i <= n; i++) dp[i] = 1e18;
while (k--) solve(1, n, 2, n + 1);
printf("%.10f\n", dp[1]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300000;
int gr[26][MAXN] = {0};
vector<int> sz;
int depth[MAXN];
void dfs0(int v) {
int size = 1;
for (int i = 0; i < 26; ++i) {
if (gr[i][v] != 0) {
dfs0(gr[i][v]);
size += sz[gr[i][v]];
}
}
sz[v] = size;
return;
}
vector<pair<int, int>> undo;
int add = 0;
int merge(int v1, int v2) {
for (int i = 0; i < 26; ++i) {
if (gr[i][v1] == 0 && gr[i][v2] != 0) {
gr[i][v1] = gr[i][v2];
undo.push_back({v1, i});
add += sz[gr[i][v1]];
} else if (gr[i][v1] != 0 && gr[i][v2] != 0)
merge(gr[i][v1], gr[i][v2]);
}
return sz[v1];
}
void dfs1(int v, int d) {
for (int i = 0; i < 26; ++i) {
if (gr[i][v] != 0) {
dfs1(gr[i][v], d + 1);
}
}
int bs = 0, pos_bs = -1;
for (int i = 0; i < 26; ++i) {
if (gr[i][v] != 0 && sz[gr[i][v]] > bs) bs = sz[gr[i][v]], pos_bs = i;
}
if (pos_bs == -1) return;
int size = sz[v];
for (int i = 0; i < 26; ++i) {
if (gr[i][v] != 0 && i != pos_bs) merge(gr[pos_bs][v], gr[i][v]);
}
depth[d] += sz[v] - (sz[gr[pos_bs][v]] + add);
for (int i = 0; i < undo.size(); ++i) {
add = 0;
gr[undo[i].second][undo[i].first] = 0;
}
undo.clear();
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int a, b;
char c;
for (int i = 0; i < n - 1; ++i) {
cin >> a >> b >> c;
--a;
--b;
gr[c - 'a'][a] = b;
}
sz.resize(n);
dfs0(0);
dfs1(0, 1);
int mm = 0, pos = 0;
for (int i = 0; i < MAXN; ++i) {
if (depth[i] > mm) {
mm = depth[i];
pos = i;
}
}
cout << sz[0] - mm << endl << pos;
return 0;
}
| 8 |
#include <bits/stdc++.h>
double p, a[100000], b[1000000], sum = 0, ans = 0;
int n;
double check(double t) {
int i;
double temp = 0, sum = p * t;
for (i = 0; i < n; i++) {
temp = t * a[i];
if (temp > b[i]) sum -= temp - b[i];
if (sum < 0) return 0;
}
return 1;
}
int main() {
int i;
scanf("%d%lf", &n, &p);
for (i = 0; i < n; i++) {
scanf("%lf%lf", &a[i], &b[i]);
sum += a[i];
}
if (sum <= p)
printf("-1\n");
else {
double left = 0, right = 1e12, mid;
while (right - left > 1e-4) {
mid = (left + right) / 2;
if (check(mid)) {
ans = mid;
left = mid;
} else
right = mid;
}
printf("%.10lf\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
std::pair<int, int> operator+(std::pair<int, int> a, std::pair<int, int> b) {
return {a.first + b.first, a.second + b.second};
}
std::pair<long long, long long> operator+(std::pair<long long, long long> a,
std::pair<long long, long long> b) {
return {a.first + b.first, a.second + b.second};
}
std::ostream& operator<<(std::ostream& out, std::pair<int, int> a) {
out << a.first << " " << a.second << "\n";
return out;
}
std::ostream& operator<<(std::ostream& out, std::pair<long long, long long> a) {
out << a.first << " " << a.second << "\n";
return out;
}
std::istream& operator>>(std::istream& in, std::pair<int, int>& a) {
in >> a.first >> a.second;
return in;
}
std::istream& operator>>(std::istream& in, std::pair<long long, long long>& a) {
in >> a.first >> a.second;
return in;
}
int pow(int x, int y) {
int temp;
if (y == 0) return 1;
temp = pow(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
bool prime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
using namespace std;
void solve() {
long long i, n, c = 0, a, mx = -1, b;
cin >> n;
long long A[n + 10], Ans[n + 10], k;
for (i = 1; i <= n; ++i) {
cin >> A[i];
Ans[i] = 1;
}
for (i = 1; i <= n; ++i) {
for (k = i + i; k <= n; k += i) {
if (A[k] > A[i]) Ans[k] = max(Ans[k], Ans[i] + 1);
}
mx = max(Ans[i], mx);
}
cout << mx << "\n";
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 800 + 10;
int n, m, r, c, N, M;
char P[Maxn][Maxn], T[Maxn][Maxn];
bitset<Maxn> R[Maxn], G[26][Maxn];
bitset<Maxn> calc(const bitset<Maxn>& b, int len, int l) {
return (b >> l) | (b << (len - l));
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", P[i]);
scanf("%d%d", &r, &c);
for (int i = 0; i < r; i++) scanf("%s", T[i]);
for (int i = 0; i < n + r; i++)
for (int j = 0; j < m + c; j++) P[i][j] = P[i % n][j % m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) R[i].set(j);
for (int ch = 0; ch < 26; ch++)
for (int i = 0; i < n + r; i++)
for (int j = 0; j < m + c; j++)
if (P[i][j] == ch + 'a') G[ch][i].set(j);
for (int x = 0; x < r; x++)
for (int y = 0; y < c; y++) {
if (T[x][y] == '?') continue;
for (int k = 0; k < n; k++)
R[k] = R[k] & calc(G[T[x][y] - 'a'][(k + x) % n], m, y);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) putchar(R[i][j] + '0');
putchar('\n');
}
}
int main() {
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p;
cin >> n >> p;
string a;
cin >> a;
int i;
for (i = n - 1; i >= 0; i--) {
if (a[i] == 'a' + p - 1) continue;
if (a[i] + 1 == a[i - 1])
if (a[i] + 1 == 'a' + p - 1)
continue;
else if (a[i] + 2 == a[i - 2])
if (a[i] + 2 == 'a' + p - 1)
continue;
else {
a[i] += 3;
break;
}
else {
a[i] += 2;
break;
}
if (a[i] + 1 == a[i - 2])
if (a[i] + 1 == 'a' + p - 1)
continue;
else if (a[i] + 2 == a[i - 1])
if (a[i] + 2 == 'a' + p - 1)
continue;
else {
a[i] += 3;
break;
}
else {
a[i] += 2;
break;
}
a[i]++;
break;
}
if (i == -1)
cout << "NO";
else {
int k = 1;
for (int j = i + 1; j < n; j++) {
if (a[i] == 'b') {
if (a[i - 1] == 'a') {
switch (k % 3) {
case 1:
a[j] = 'c';
break;
case 2:
a[j] = 'a';
break;
case 0:
a[j] = 'b';
break;
}
k++;
continue;
} else {
switch (k % 3) {
case 1:
a[j] = 'a';
break;
case 2:
a[j] = 'c';
break;
case 0:
a[j] = 'b';
break;
}
k++;
continue;
}
}
if (a[i - 1] == 'a') {
switch (k % 3) {
case 1:
a[j] = 'b';
break;
case 2:
a[j] = 'a';
break;
case 0:
a[j] = 'c';
break;
}
k++;
continue;
}
switch (k % 3) {
case 1:
a[j] = 'a';
break;
case 2:
a[j] = 'b';
break;
case 0:
a[j] = 'c';
break;
}
k++;
}
cout << a;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 1000 * 100 + 100;
int ans[MN], cnt[MN];
struct block {
int el, k;
bool operator<(const block &nw) const { return (el < nw.el); }
};
block a[MN];
int main() {
int n, k = 0, m = 0;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].el);
a[i].k = i;
cnt[a[i].el]++;
k = max(k, a[i].el);
m = max(m, cnt[a[i].el]);
}
for (int i = 2; i <= k; i++) {
if (!cnt[1] || !cnt[i] || cnt[i] > cnt[i - 1]) {
cout << "-1";
return 0;
}
}
for (int i = 0; i < n; i++) ans[i] = cnt[a[i].el]--;
cout << m << endl;
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T LCM(T a, T b) {
return a * (b / gcd(a, b));
}
template <typename T>
T expo(T b, T e, const T &m) {
if (e <= 1) return e == 0 ? 1 : b;
return (e & 1) == 0 ? expo((b * b) % m, e >> 1, m)
: (b * expo((b * b) % m, e >> 1, m)) % m;
}
template <typename T>
T modinv(T a) {
return expo(a, 1000000007ll - 2);
}
long long n, k;
long long fib[65] = {0};
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
fib[0] = 1, fib[1] = 1;
for (__typeof(60) i = 2; i <= 60; i++) {
fib[i] = fib[i - 1] + fib[i - 2];
}
vector<long long> result;
long long idx = 1;
while (idx < n) {
if (k <= fib[n - idx]) {
result.push_back(idx);
idx++;
} else {
result.push_back(idx + 1);
result.push_back(idx);
k -= fib[n - idx];
idx += 2;
}
}
if (idx == n) {
result.push_back(idx);
}
for (__typeof(n) i = 0; i < n; i++) {
cout << result[i] << ' ';
}
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 2 * acos(0.0), eps = 1e-7, inf = 1111111111;
int n, r, v, s, t;
long double get_t(long double x, long double y) {
y -= x;
long double ll = (y - r) / v, rr = (y + r) / v;
for (int i = 0; i < 50; ++i) {
long double mid = (ll + rr) / 2;
long double d = v * mid + r * cos(v * mid / r);
if (d < y) {
ll = mid;
} else {
rr = mid;
}
}
return ll;
}
long double f(long double x) { return get_t(x, t) - get_t(x, s); }
int main() {
scanf("%d%d%d", &n, &r, &v);
while (n--) {
scanf("%d%d", &s, &t);
long double q = (s + t) / 2.0;
long double dd = 2 * pi * r;
int k = (t - s) / dd;
q -= (k + 2) * dd;
double ans = min(f(q - pi * r / 2), f(q - 3 * pi * r / 2));
printf("%.10f\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, Next[600010][26], tot;
int dis[600010], Size[600010], cnt[600010], len;
int dfs1(int st) {
Size[st] = 1;
for (int i = 0; i < (26); i++) {
int v = Next[st][i];
if (v == 0) continue;
dis[v] = dis[st] + 1;
Size[st] += dfs1(v);
}
cnt[dis[st]] += Size[st];
return Size[st];
}
int Merge(int x, int y) {
if (!x || !y) return x + y;
int rt = ++tot;
Size[rt] = 1;
for (int i = 0; i < (26); i++) {
Next[rt][i] = Merge(Next[x][i], Next[y][i]);
Size[rt] += Size[Next[rt][i]];
}
return rt;
}
void dfs2(int st) {
int rt = 0;
for (int i = 0; i < (26); i++) {
if (Next[st][i]) dfs2(Next[st][i]);
}
for (int i = 0; i < (26); i++) rt = Merge(rt, Next[st][i]);
cnt[dis[st]] -= max(1, Size[rt]);
}
int main() {
scanf("%d", &n);
tot = n;
for (int i = 1; i < (n); i++) {
int u, v;
char ch;
scanf("%d %d %c", &u, &v, &ch);
Next[u][ch - 'a'] = v;
}
dfs1(1);
for (int i = 1; i < (n + 1); i++) len = max(len, dis[i]);
dfs2(1);
int pos = 0;
for (int i = 1; i < (len + 1); i++)
if (cnt[i] > cnt[pos]) pos = i;
printf("%d\n%d\n", n - cnt[pos], pos + 1);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const double pi = 3.141593;
int a[500000];
vector<int> v;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 4) a[i] = 1;
if (a[i] == 8) a[i] = 2;
if (a[i] == 15) a[i] = 3;
if (a[i] == 16) a[i] = 4;
if (a[i] == 23) a[i] = 5;
if (a[i] == 42) a[i] = 6;
}
map<int, int> m;
for (int i = 1; i < 7; i++) m[i] = 0;
for (int i = 0; i < n; i++)
if (a[i] == 1)
m[1]++;
else {
if (m[a[i] - 1]) {
m[a[i] - 1]--;
m[a[i]]++;
}
}
cout << n - m[6] * 6;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
const int N = 1005;
int n, a[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = (0); i < (n); i++) {
cin >> a[i];
}
vector<pair<int, int>> inv;
for (int i = (0); i < (n); i++)
for (int j = (i + 1); j < (n); j++) {
if (a[i] > a[j]) {
inv.emplace_back(i, j);
}
}
sort(inv.begin(), inv.end(), [&](pair<int, int> p, pair<int, int> q) {
return make_tuple(-p.second, a[p.first], p.first) <
make_tuple(-q.second, a[q.first], q.first);
});
cout << ((int)(inv).size()) << '\n';
for (auto &p : inv) {
cout << p.first + 1 << ' ' << p.second + 1 << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void smn(T &a, const T &b) {
if (b < a) a = b;
}
template <class T>
inline void smx(T &a, const T &b) {
if (b > a) a = b;
}
template <class T>
inline T _rev(const T &a) {
T _ = a;
reverse(_.begin(), _.end());
return _;
}
const double eps = 1e-8;
const long double leps = 1e-14;
const int MN = 1000000;
int n, m, k;
int f[MN];
int l1[MN], r1[MN], l2[MN], r2[MN];
long long d[MN], s[MN];
int start[MN];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> start[i];
for (int i = 0; i < m; i++) cin >> l1[i] >> r1[i] >> d[i], l1[i]--, r1[i]--;
;
for (int i = 0; i < k; i++) {
cin >> l2[i] >> r2[i];
l2[i]--, r2[i]--;
f[l2[i]]++;
f[r2[i] + 1]--;
}
int now = 0;
for (int i = 0; i < m; i++) now += f[i], d[i] *= now;
for (int i = 0; i < m; i++) s[l1[i]] += d[i], s[r1[i] + 1] -= d[i];
long long temp = 0;
for (int i = 0; i < n; i++) temp += s[i], cout << temp + start[i] << " ";
cout << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int oo = 0x3f3f3f3f;
const int maxN = 512;
int N, IR, IC, R, C;
string cmd;
string bt;
bool grid[maxN][maxN];
int walk[maxN][maxN];
set<int> col[maxN];
set<int> row[maxN];
int cnt;
void turnon(int r, int c) {
if (grid[r][c]) return;
cmd += '1';
grid[r][c] = 1;
cnt++;
}
void turnoff(int r, int c) {
if (!grid[r][c]) return;
cmd += '2';
grid[r][c] = 0;
cnt--;
}
int main() {
cin >> N >> IR >> IC;
cnt = 0;
for (int r = (1); r < (N + 1); r++)
for (int c = (1); c < (N + 1); c++) {
int tmp;
cin >> tmp;
grid[r][c] = tmp;
if (tmp) {
cnt++;
row[r].insert(c);
col[c].insert(r);
}
}
R = IR;
C = IC;
turnon(R, C);
while (true) {
if (int((row[R]).size())) {
int tc = *row[R].begin();
if (tc == C) {
row[R].erase(C);
} else {
if (tc < C) {
C--;
cmd += 'L';
bt += 'L';
} else {
C++;
cmd += 'R';
bt += 'R';
};
turnon(R, C);
}
} else if (int((col[C]).size())) {
int tr = *col[C].begin();
if (tr == R) {
col[C].erase(R);
} else {
if (tr < R) {
R--;
cmd += 'U';
bt += 'U';
} else {
R++;
cmd += 'D';
bt += 'D';
};
turnon(R, C);
}
} else if (int((bt).size())) {
switch (bt.back()) {
case 'D':
cmd += 'U';
R--;
break;
case 'U':
cmd += 'D';
R++;
break;
case 'L':
cmd += 'R';
C++;
break;
case 'R':
cmd += 'L';
C--;
break;
}
bt.pop_back();
} else {
break;
}
}
string tmpcmd = "";
swap(tmpcmd, cmd);
R = IR;
C = IC;
int PR = -1, PC = -1;
for (char c : tmpcmd) {
switch (c) {
case 'D':
R++;
break;
case 'U':
R--;
break;
case 'L':
C--;
break;
case 'R':
C++;
break;
}
if (PR != R || PC != C) {
walk[R][C]++;
}
PR = R;
PC = C;
}
R = IR;
C = IC;
PR = -1, PC = -1;
for (char c : tmpcmd) {
switch (c) {
case 'D':
R++;
break;
case 'U':
R--;
break;
case 'L':
C--;
break;
case 'R':
C++;
break;
}
if (PR != R || PC != C) {
walk[R][C]--;
}
cmd += c;
if (!walk[R][C]) turnoff(R, C);
PR = R;
PC = C;
}
turnoff(R, C);
if (cnt == 0) {
cout << "YES" << endl;
cout << cmd << endl;
} else {
cout << "NO" << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void run();
int main() {
ios::sync_with_stdio(0);
run();
}
struct {
int v[2000001];
int off;
int &operator[](int x) { return v[x + off]; }
} v;
void run() {
int n;
cin >> n;
for (int i = n; i--;) v[i] = i + 1;
for (int k = 2; k <= n; k++) {
++v.off;
v[n] = v[-1];
for (int i = 0, j = v[n]; i < n; i += k) swap(v[min(i + k, n) - 1], j);
}
for (int i = 0; i < n; i++) cout << v[i] << (i + 1 == n ? '\n' : ' ');
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 99999999;
int a[100005];
int b[100005];
int s[2];
int fp(int a, int k, int m) {
int res = 1;
while (k) {
if (k & 1) res = 1LL * res * a % m;
a = 1LL * a * a % m;
k >>= 1;
}
return res;
}
int main() {
int n, m;
cin >> m >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s[0] = (s[0] + a[i]) % m;
s[1] = (s[1] + 1LL * a[i] * a[i]) % m;
}
if (n == 1) {
printf("%d 0\n", a[1]);
return 0;
}
sort(a + 1, a + n + 1);
for (int i = 2; i <= n; i++) {
long long d = (a[i] - a[1] + m) % m;
long long x = (s[0] - 1LL * n * (n - 1) / 2 % m * d % m + m) % m *
fp(n, m - 2, m) % m;
long long ans = 1LL * n * x % m * x % m;
ans = (ans + 1LL * n * (n - 1) % m * d % m * x % m) % m;
ans = (ans + 1LL * n * (n - 1) * (2 * n - 1) / 6 % m * d % m * d % m) % m;
if (ans == s[1]) {
b[1] = x;
for (int j = 2; j <= n; j++) {
b[j] = b[j - 1] + d;
b[j] %= m;
}
sort(b + 1, b + n + 1);
bool flag = true;
for (int j = 1; j <= n; j++) {
if (a[j] != b[j]) {
flag = false;
break;
}
}
if (flag) {
printf("%I64d %I64d\n", x, d);
return 0;
}
}
}
printf("-1\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
char ch;
inline void read(int &x) {
x = 0;
ch = getchar();
while (ch <= 32) ch = getchar();
while (ch > 32) {
x = x * 10 + ch - 48;
ch = getchar();
};
};
inline int min(int a, int b) { return a < b ? a : b; }
int n, m;
struct data {
int l, r, t;
};
inline bool operator<(data a, data b) { return a.t > b.t; };
data a[100005];
int _tmp[100005 * 2];
struct segnode {
segnode *l, *r;
int x;
} _seg[100005 * 2 * 2], *stot = _seg;
inline segnode *build(int n) {
segnode *ret = ++stot;
ret->x = 1100000000;
if (n > 1) {
int mid = n >> 1;
ret->l = build(mid);
ret->r = build(n - mid);
};
return ret;
};
inline void cover(segnode *a, int l, int r, int x, int n) {
if (l == 1 && r == n) {
a->x = x;
return;
};
int mid = n >> 1;
if (r <= mid) {
cover(a->l, l, r, x, mid);
} else if (l > mid) {
cover(a->r, l - mid, r - mid, x, n - mid);
} else {
cover(a->l, l, mid, x, mid);
cover(a->r, 1, r - mid, x, n - mid);
};
};
struct event {
int t, dk, db;
} e[100005 * 2 * 2];
inline bool operator<(event a, event b) { return a.t < b.t; };
int ecnt;
inline void add_event(int t, int dk, int db) {
e[++ecnt] = (event){t, dk, db};
};
inline void add_seg(int t, int l, int r) {
add_event(t - r, 1, 1 - t + r);
add_event(t - l + 1, -1, -l + t);
};
inline void dfs(segnode *a, int x, int n, int pos) {
x = min(x, a->x);
if (n == 1) {
if (x == 1100000000) return;
if (_tmp[pos] == _tmp[pos + 1]) return;
add_seg(x, _tmp[pos], _tmp[pos + 1] - 1);
return;
};
int mid = n >> 1;
dfs(a->l, x, mid, pos);
dfs(a->r, x, n - mid, pos + mid);
};
int main() {
read(n);
read(m);
int i;
for (i = 1; i <= m; i++) {
int l, r, t;
read(l);
read(r);
read(t);
a[i] = (data){l, r - 1, t};
_tmp[i] = l, _tmp[i + m] = r;
};
std::sort(a + 1, a + m + 1);
std::sort(_tmp + 1, _tmp + m + m + 1);
_tmp[m + m + 1] = _tmp[m + m + 1];
segnode *root = build(2 * m);
for (i = 1; i <= m; i++) {
cover(root, std::lower_bound(_tmp + 1, _tmp + m + m + 1, a[i].l) - _tmp,
std::lower_bound(_tmp + 1, _tmp + m + m + 1, a[i].r + 1) - _tmp - 1,
a[i].t, m + m);
};
dfs(root, 1100000000, m + m, 1);
std::sort(e + 1, e + ecnt + 1);
int k = 0, b = 0;
int now = 1;
for (i = 1; i <= n; i++) {
int x;
read(x);
while (now <= ecnt && e[now].t <= x) {
k += e[now].dk;
b += e[now].db;
++now;
};
int ans = 1LL * k * x + b;
printf("%d\n", ans);
};
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long sub(char s1[1000], char s2[1000], long long M, long long N) {
for (long long i = 0; i <= N - M; i++) {
long long j;
for (j = 0; j < M; j++)
if (s2[i + j] != s1[j]) break;
if (j == M) return i;
}
return 0;
}
long long automaton(string s, string t) {
long long n = s.length();
long long m = t.length();
long long i = 0, j = 0;
if (n > m) {
while (n != i) {
if (s[i] == t[j]) {
i++;
j++;
} else
i++;
}
if (j == m)
return 1;
else
return 0;
}
return 0;
}
long long arr(string s, string t) {
long long n = s.length();
long long m = t.length();
if (n == m) {
char a[n], b[n];
for (long long i = 0; i < n; i++) {
a[i] = s[i];
b[i] = t[i];
}
sort(a, a + n);
sort(b, b + n);
for (long long i = 0; i < n; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
return 0;
}
long long both(string s, string t) {
long long n = s.length();
long long m = t.length();
if (n > m) {
char a[n], b[m];
for (long long i = 0; i < n; i++) a[i] = s[i];
for (long long i = 0; i < m; i++) b[i] = t[i];
sort(a, a + n);
sort(b, b + m);
for (long long i = 0; i < n; i++) s[i] = a[i];
for (long long i = 0; i < m; i++) t[i] = b[i];
if (automaton(s, t)) return 1;
return 0;
}
return 0;
}
signed main() {
string s, t;
cin >> s >> t;
if (arr(s, t))
cout << "array";
else if (automaton(s, t))
cout << "automaton";
else if (both(s, t))
cout << "both";
else
cout << "need tree";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int inf = 1e9;
const int M = 1e9;
int n, d[1 << N], c[N][N], a[N][N], m, b[N][N];
string s[N];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int mx = 0;
for (int k = 0; k < n; k++)
if (s[i][j] == s[k][j]) {
b[i][j] |= (1 << k);
c[i][j] += a[k][j];
mx = max(mx, a[k][j]);
}
c[i][j] -= mx;
}
for (int i = 1; i < 1 << n; i++) d[i] = inf;
for (int i = 1; i < 1 << n; i++) {
int lowbit = -1;
for (int j = 0; j < n; j++)
if ((i >> j) & 1) {
lowbit = j;
break;
}
for (int j = 0; j < m; j++) {
d[i] = min(d[i], d[i & (i ^ b[lowbit][j])] + c[lowbit][j]);
d[i] = min(d[i], d[i ^ (1 << lowbit)] + a[lowbit][j]);
}
}
cout << d[(1 << n) - 1];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6;
int n, a[500001];
long long x, y, ans = 1LL << 60, ps[500001];
bool isp[MAX + 5];
int main() {
fill_n(isp, MAX + 5, true);
isp[0] = isp[1] = false;
for (int i = 2; i * i <= MAX; ++i)
if (isp[i])
for (int j = 2; i * j <= MAX; ++j) isp[i * j] = false;
cin >> n >> x >> y;
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
ps[0] = a[0];
for (int i = 1; i < n; ++i) ps[i] = ps[i - 1] + a[i];
for (int g = 2; g <= MAX; ++g) {
if (!isp[g]) continue;
long long curr = 0;
for (int k = g; k - g <= MAX; k += g) {
int r = upper_bound(a, a + n, k) - a - 1,
l = upper_bound(a, a + n, k - g) - a;
int f = lower_bound(a + l, a + r + 1, k - (long double)x / y) - a;
curr +=
x * (f - l) + y * ((long long)k * (r - f + 1) - (ps[r] - ps[f - 1]));
}
ans = min(ans, curr);
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
using namespace std;
const int maxn = 3e5 + 11;
const double PI = acos(-1.0);
const double eps = 1e-6;
struct DFT {
struct Complex {
double x, y;
Complex() {}
Complex(double x_, double y_) : x(x_), y(y_) {}
Complex operator-(const Complex& oth) const {
return Complex(x - oth.x, y - oth.y);
}
Complex operator+(const Complex& oth) const {
return Complex(x + oth.x, y + oth.y);
}
Complex operator*(const Complex& oth) const {
return Complex(x * oth.x - y * oth.y, x * oth.y + y * oth.x);
}
};
Complex A[maxn << 2], B[maxn << 2], C[maxn << 2];
int N, M, L;
void init(int n, int m) {
N = n;
M = m;
}
void change(Complex y[], int len) {
int i, j, k;
for (i = 1, j = len >> 1; i < len - 1; i++) {
if (i < j) swap(y[i], y[j]);
k = len / 2;
while (j >= k) {
j = j - k;
k = k / 2;
}
if (j < k) j += k;
}
}
void FFT(Complex y[], int len, int on) {
change(y, len);
for (int h = 2; h <= len; h <<= 1) {
Complex wn(cos(2 * PI / h), sin(on * 2 * PI / h));
for (int j = 0; j < len; j += h) {
Complex w(1, 0);
for (int k = j; k < j + h / 2; k++) {
Complex u = y[k];
Complex t = w * y[k + h / 2];
y[k] = u + t;
y[k + h / 2] = u - t;
w = w * wn;
}
}
}
if (on == -1) {
for (int i = 0; i < len; i++) {
y[i].x /= len;
}
}
}
void multiply(int a[], int b[]) {
int i, len = 1;
while (len < 2 * N || len < 2 * M) len <<= 1;
L = len;
for (i = 0; i < N; ++i) {
A[i] = Complex(a[i], 0);
}
for (i = 0; i < M; ++i) {
B[i] = Complex(b[i], 0);
}
for (i = N; i < len; ++i) {
A[i] = Complex(0, 0);
}
for (i = M; i < len; ++i) {
B[i] = Complex(0, 0);
}
FFT(A, len, 1);
FFT(B, len, 1);
for (i = 0; i < len; ++i) {
C[i] = A[i] * B[i];
}
FFT(C, len, -1);
}
};
DFT dt;
int a[maxn], b[maxn];
int cost[maxn >> 1][7][7];
char S[maxn], T[maxn];
int N, M;
void solve(char fi, char se) {
int i;
dt.init(N + 1, M + 1);
for (i = 0; i < N; ++i) a[i] = (fi == S[i]);
for (i = 0; i < M; ++i) b[i] = (se == T[i]);
dt.multiply(a, b);
for (i = 0; i < dt.L; ++i) {
if (i >= M - 1 && i < N) {
cost[i][fi - 'a'][se - 'a'] += (dt.C[i].x > 0.5);
}
}
}
int f[14];
void init() {
int i;
for (i = 0; i < 14; ++i) {
f[i] = i;
}
}
int find(int x) {
if (f[x] == x) return x;
return f[x] = find(f[x]);
}
void unionset(int x, int y) {
x = find(x), y = find(y);
f[x] = y;
}
int main() {
int i, j, k;
scanf("%s", S);
scanf("%s", T);
N = strlen(S), M = strlen(T);
reverse(T, T + M);
for (i = 0; i < 6; ++i) {
for (j = 0; j < 6; ++j) {
if (i != j) {
solve(i + 'a', j + 'a');
}
}
}
for (i = M - 1; i < N; ++i) {
init();
int cnt = 0;
for (j = 0; j < 6; ++j) {
for (k = 0; k < 6; ++k) {
if (cost[i][j][k] && find(j) != find(k)) {
unionset(j, k);
++cnt;
}
}
}
printf("%d ", cnt);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
const int INF = 1e9;
const int C = 62;
int n, m;
int tmax[C][4 * N], tupd[4 * N];
string w;
char s[N];
bool isdel[N];
vector<int> vdel;
int getCode(char c) {
if (c >= 'a' && c <= 'z') return (int)(c - 'a');
if (c >= 'A' && c <= 'Z') return (int)(c - 'A') + 26;
return (int)(c - '0') + 52;
}
void build(int ind, int v, int tl, int tr) {
if (tl == tr) {
if (getCode(s[tl]) == ind)
tmax[ind][v] = tl;
else
tmax[ind][v] = -INF;
tupd[v] = 0;
return;
}
int tm = (tl + tr) / 2;
build(ind, v * 2, tl, tm);
build(ind, v * 2 + 1, tm + 1, tr);
tmax[ind][v] = max(tmax[ind][v * 2], tmax[ind][v * 2 + 1]);
tupd[v] = 0;
}
void addToVertex(int ind, int v, int val) {
if (tmax[ind][v] != -INF) tmax[ind][v] += val;
}
void push(int v) {
if (tupd[v] != 0) {
for (int i = 0; i < C; i++) {
addToVertex(i, v * 2, tupd[v]);
addToVertex(i, v * 2 + 1, tupd[v]);
}
tupd[v * 2] += tupd[v];
tupd[v * 2 + 1] += tupd[v];
tupd[v] = 0;
}
}
void update(int v, int tl, int tr, int l, int r, int val) {
if (l > r) return;
if (l == tl && r == tr) {
for (int ind = 0; ind < C; ind++) {
addToVertex(ind, v, val);
}
tupd[v] += val;
return;
}
push(v);
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(r, tm), val);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, val);
for (int ind = 0; ind < C; ind++) {
tmax[ind][v] = max(tmax[ind][v * 2], tmax[ind][v * 2 + 1]);
}
}
void del(int ind, int v, int tl, int tr, int pos) {
if (tl == tr) {
tmax[ind][v] = -INF;
return;
}
push(v);
int tm = (tl + tr) / 2;
if (pos <= tm)
del(ind, v * 2, tl, tm, pos);
else
del(ind, v * 2 + 1, tm + 1, tr, pos);
tmax[ind][v] = max(tmax[ind][v * 2], tmax[ind][v * 2 + 1]);
}
pair<int, int> getpos(int ind, int v, int tl, int tr, int val) {
if (tmax[ind][v] < val) return make_pair(n + 1, n + 1);
if (tl == tr) return make_pair(tl, tmax[ind][v]);
push(v);
int tm = (tl + tr) / 2;
if (tmax[ind][v * 2] >= val) return getpos(ind, v * 2, tl, tm, val);
return getpos(ind, v * 2 + 1, tm + 1, tr, val);
}
int main() {
scanf("%d %d\n", &n, &m);
cin >> w;
scanf("\n");
for (int i = 1; i <= n; i++) s[i] = w[i - 1];
for (int i = 1; i <= n; i++) isdel[i] = false;
for (int i = 0; i < C; i++) build(i, 1, 1, n);
for (int i = 1; i <= m; i++) {
int l, r;
char c;
int cd;
scanf("%d %d %c\n", &l, &r, &c);
cd = getCode(c);
int pos = l;
vdel.clear();
while (pos <= r) {
pair<int, int> p = getpos(cd, 1, 1, n, pos);
if (p.second > r) break;
int j = p.first;
del(cd, 1, 1, n, j);
isdel[j] = true;
vdel.push_back(j);
pos = p.second + 1;
}
for (int x : vdel) {
update(1, 1, n, x, n, -1);
}
}
for (int i = 1; i <= n; i++) {
if (!isdel[i]) printf("%c", s[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int num[110], to[110][110], cnt, n, ans[110];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%1d", &to[i][j]);
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
int flag = 0, t = 0;
while (1) {
++t, flag = 0;
for (int i = 1; i <= n; i++)
if (num[i] == 0 && ans[i] == 0) {
ans[i] = 1, cnt++;
for (int j = 1; j <= n; j++)
if (to[i][j] == 1) num[j]--;
flag = 1;
break;
}
if (flag == 0) break;
if (t > n) {
printf("-1\n");
return 0;
}
}
printf("%d\n", cnt);
for (int i = 1; i <= n; i++)
if (ans[i]) printf("%d ", i);
}
| 7 |
#include <bits/stdc++.h>
void debug() {}
const int N = 1e5 + 5;
long long n, m, dp[N * 5];
struct Node {
long long weight, cost, ratio;
bool operator<(const Node &rhs) const { return ratio > rhs.ratio; }
} A[N];
int main() {
scanf("%lld %lld", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%lld %lld", &A[i].weight, &A[i].cost);
A[i].ratio = A[i].cost * 6 / A[i].weight;
}
std::sort(A + 1, A + 1 + n);
long long sum = 0;
for (int i = 1; i <= n; ++i) {
long long w = A[i].weight, c = A[i].cost;
sum += w;
for (int j = sum; j >= std::max(w, sum - 50); --j) {
dp[j] = std::max(dp[j], dp[j - w] + c);
}
}
long long ans = 0;
for (int i = m; i >= 0; --i) ans = std::max(ans, dp[i]);
printf("%lld\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lim = 5e5;
int main() {
long long m, a, b;
cin >> m >> a >> b;
long long g = gcd(a, b);
lim -= lim % g;
lim = min(m + 1, lim);
vector<bool> can(lim + 10, false);
can[0] = true;
long long it = 1, valf = 1, sumf = 1;
while (it < lim) {
if (it >= a and can[it - a]) {
queue<long long> q;
q.push(it);
while (!q.empty()) {
long long t = q.front();
q.pop();
if (!can[t]) {
valf++;
can[t] = true;
if (t + a <= it) q.push(t + a);
if (t - b >= 0) q.push(t - b);
}
}
}
sumf += valf;
++it;
}
long long add = 0;
long long siz = m - lim + 1;
add += g * (siz / g) * (siz / g + 1) / 2;
cerr << siz << " " << add << " " << g << endl;
add += ((siz - 1) / g + 1) * (siz % g);
cerr << add << endl;
cout << sumf + siz * (lim / g) + add << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long int INFLL = 0x3f3f3f3f3f3f3f3f;
const int maxn = 300010;
int T;
int n;
vector<int> g[maxn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> T;
while (T--) {
priority_queue<int, vector<int>, greater<int>> heap;
cin >> n;
for (register int i = (0); i <= (n); i++) {
g[i].clear();
}
for (register int i = (1); i <= (n); i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
}
long long int ans = 0;
for (register int i = (n - 1); i >= (0); i--) {
for (register int j = (0); j <= ((int)g[i].size() - 1); j++) {
heap.push(g[i][j]);
}
while (heap.size() > n - i) {
ans += heap.top();
heap.pop();
}
}
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long int l, r, ans;
long long int get(long long int x) {
long long int now = 1, k, a[2] = {0, 0};
int id = 0;
while (x > 0) {
k = min(now, x);
a[id] = (k + a[id]) % mod;
id ^= 1;
now *= 2;
x -= k;
}
return (a[0] * (a[0]) % mod + a[1] * (a[1] + 1) % mod) % mod;
}
int main(int argc, char const *argv[]) {
scanf("%lld%lld", &l, &r);
printf("%lld\n", (get(r) - get(l - 1) + mod) % mod);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long sum, num, maxi = -10e9, maxn = -10e9, mini = 10e9, minn = 10e9;
string n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n;
cout << n;
for (int i = n.size() - 1; i >= 0; i--) {
cout << n[i];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9;
const int SIZE = 1e6 + 5;
const long long INF = 1LL << 55;
const double eps = 1e-10;
multiset<int> adj[100009];
vector<int> ec;
vector<int> od;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < (m); ++i) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
adj[x].insert(y);
adj[y].insert(x);
}
for (int i = 0; i < (n); ++i) {
if (((int)(adj[i]).size()) % 2) od.push_back(i);
}
for (int i = 0; i < (((int)(od).size()) / 2); ++i) {
adj[od[i]].insert(od[((int)(od).size()) - 1 - i]);
adj[od[((int)(od).size()) - 1 - i]].insert(od[i]);
m++;
}
if (m % 2) {
adj[0].insert(0);
m++;
adj[0].insert(0);
}
stack<int> st;
int cur = 0;
while (true) {
if (((int)(adj[cur]).size()) == 0) {
if (((int)(st).size()) == 0) break;
ec.push_back(cur);
cur = st.top();
st.pop();
} else {
int ncur = *adj[cur].begin();
adj[cur].erase(adj[cur].begin());
adj[ncur].erase(adj[ncur].find(cur));
st.push(cur);
cur = ncur;
}
}
printf("%d\n", m);
ec.push_back(0);
for (int i = 0; i < (((int)(ec).size()) - 1); ++i) {
if (i % 2)
printf("%d %d\n", ec[i] + 1, ec[i + 1] + 1);
else
printf("%d %d\n", ec[i + 1] + 1, ec[i] + 1);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 14;
const int Q = 111;
long long memo[N][N][1 << N];
int most[1 << N];
int adj[N];
int eu[N], ev[N];
int qu[Q], qv[Q], qp[Q];
int n, q, m;
long long dp(int u, int p, int mask) {
long long &ans = memo[u][p][mask];
if (ans != -1) return ans;
if (mask == (1 << u)) return ans = 1;
ans = 0;
int child = adj[u];
if (child & (1 << p)) child ^= 1 << p;
for (int rem = mask ^ (1 << u), first = rem; first;
first = (first - 1) & rem) {
if (first & most[rem]) {
for (int v = 0; v < n; ++v)
if (first & (1 << v)) {
if ((first ^ (1 << v)) & child) continue;
bool checkEdge = 1;
for (int i = 0; i < m; ++i)
if (eu[i] != u && ev[i] != u &&
(first >> eu[i] & 1) != (first >> ev[i] & 1)) {
checkEdge = 0;
break;
}
if (checkEdge) {
bool checkLCA = 1;
for (int i = 0; i < q; ++i)
if ((mask & (1 << qu[i])) && (mask & (1 << qv[i]))) {
if (!(mask & (1 << qp[i]))) {
checkLCA = 0;
break;
}
bool uIn = first & (1 << qu[i]);
bool vIn = first & (1 << qv[i]);
if ((uIn && vIn && !(first & (1 << qp[i]))) ||
(uIn != vIn && qp[i] != u)) {
checkLCA = 0;
break;
}
}
if (checkLCA) {
ans += dp(v, u, first) * dp(u, p, mask ^ first);
}
}
}
}
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> q;
for (int i = 1; i < (1 << n); ++i)
for (int j = 0; j < n; ++j)
if (i & (1 << j)) most[i] = 1 << j;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
adj[u] |= 1 << v;
adj[v] |= 1 << u;
eu[i] = u;
ev[i] = v;
}
for (int i = 0; i < q; ++i) {
int u, v, p;
cin >> u >> v >> p;
--u;
--v;
--p;
qu[i] = u;
qv[i] = v;
qp[i] = p;
if (u == v && u != p) {
cout << 0 << endl;
return 0;
}
}
memset(memo, -1, sizeof(memo));
cout << dp(0, N - 1, (1 << n) - 1) << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int64_t> rd;
int n;
cin >> n;
int sumf = 0;
for (int i = 0; i < n; i++) {
float f;
cin >> f;
if (((float)(f - (int)f)) == 0) {
rd.push_back(14092002 + (int)f);
sumf += (int)f;
continue;
}
if (f < 0) {
rd.push_back((int)f - 1);
sumf += (int)f - 1;
continue;
}
if (f > 0) {
rd.push_back((int)f);
sumf += (int)f;
continue;
}
}
int summed = 0;
if (sumf < 0) {
sumf = abs(sumf);
for (int i = 0; summed < sumf; i++) {
if (rd[i] > 100000) continue;
summed++;
rd[i]++;
}
} else {
for (int i = 0; summed < sumf; i++) {
if (rd[i] > 100000) continue;
summed++;
rd[i]--;
}
}
for (int i = 0; i < rd.size(); i++) {
if (rd[i] > 100000) {
cout << rd[i] - 14092002 << '\n';
continue;
}
cout << rd[i] << '\n';
}
return 0;
}
| 3 |
/*
{
######################
# Author #
# Gary #
# 2021 #
######################
*/
#include<bits/stdc++.h>
#define rb(a,b,c) for(int a=b;a<=c;++a)
#define rl(a,b,c) for(int a=b;a>=c;--a)
#define LL long long
#define IT iterator
#define PB push_back
#define II(a,b) make_pair(a,b)
#define FIR first
#define SEC second
#define FREO freopen("check.out","w",stdout)
#define rep(a,b) for(int a=0;a<b;++a)
#define SRAND mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#define random(a) rng()%a
#define ALL(a) a.begin(),a.end()
#define POB pop_back
#define ff fflush(stdout)
#define fastio ios::sync_with_stdio(false)
#define check_min(a,b) a=min(a,b)
#define check_max(a,b) a=max(a,b)
using namespace std;
inline int read(){
int x=0;
char ch=getchar();
while(ch<'0'||ch>'9'){
ch=getchar();
}
while(ch>='0'&&ch<='9'){
x=(x<<1)+(x<<3)+(ch^48);
ch=getchar();
}
return x;
}
const int INF=0x3f3f3f3f;
typedef pair<int,int> mp;
const int MAXN=1e5+1;
const int MAGIC=300;
int n;
struct FWTTT{
int tree[MAXN];
FWTTT(){
memset(tree,0,sizeof(tree));
}
void add(int pos,int val){
while(pos<=n){
tree[pos]+=val;
pos+=pos&-pos;
}
}
int lower_bound(int val){
int now=0;
int sum=0;
rl(i,16,0){
if(now+(1<<i)>n) continue;
if(sum+tree[now|(1<<i)]<val){
now|=1<<i;
sum+=tree[now];
}
}
return now+1;
}
int query(int pos){
int sum=0;
while(pos){
sum+=tree[pos];
pos^=pos&-pos;
}
return sum;
}
}fwt[MAXN/MAGIC+3];
vector<int> ope[MAXN/MAGIC+3];
int b[MAXN];
bool z[MAXN];
void build(int id){
z[id]=0;
for(auto it:ope[id]) fwt[id].add(it,-1);
ope[id].clear();
int l,r;
l=(id-1)*MAGIC+1;
r=min(n,id*MAGIC);
rb(i,l,r){
int x=fwt[id].lower_bound(b[i]);
ope[id].PB(x);
fwt[id].add(x,1);
}
}
int main(){
scanf("%d",&n);
rb(i,1,n) b[i]=read(),b[i]=i-b[i];
rb(i,1,(n+MAGIC-1)/MAGIC){
z[i]=1;
rb(j,1,n) fwt[i].tree[j]=j&-j;
}
int q;
scanf("%d",&q);
while(q--){
int ty;
ty=read();
if(ty==1){
int p,x;
p=read();
x=read();
b[p]=p-x;
p=(p+MAGIC-1)/MAGIC;
z[p]=1;
}
else{
int x;
x=read();
int ans=b[x];
for(int i=x+1;i<=n;){
if(i%MAGIC==1){
if(z[i/MAGIC+1]) build(i/MAGIC+1);
ans=fwt[i/MAGIC+1].query(ans);
i+=MAGIC;
}
else{
ans+=ans>=b[i];
i++;
}
}
printf("%d\n",ans);
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005], b[100005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = n; i >= 1; --i) {
b[i] = a[i] + a[i + 1];
}
for (int i = 1; i <= n; ++i) {
cout << b[i] << " ";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gl(int a) {
int c = 0;
while (a != 0) {
c = max(c, a % 10);
a /= 10;
}
return c;
}
int cc(int a, int b, int ba) {
int sa = floor(log10(a)) + 1;
int sb = floor(log10(b)) + 1;
if (sb > sa) swap(a, b);
int carr = 0;
int c = 0;
while (a != 0) {
c++;
int l1, l2;
l1 = a % 10;
if (b != 0)
l2 = b % 10;
else
l2 = 0;
if (l1 + l2 + carr >= ba)
carr = 1;
else
carr = 0;
b /= 10;
a /= 10;
}
return max(sa, sb) + carr;
}
int main() {
int a, b;
cin >> a >> b;
int c = max(gl(a), gl(b));
c++;
cout << cc(a, b, c) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int b;
bool x;
edge *next;
} E[100010], *rt[100010];
int o = 0;
int mi = 100000000;
int N;
void addedge(int a, int b) {
edge *p = &E[o++];
p->b = b;
p->x = false;
p->next = rt[a];
rt[a] = p;
p = &E[o++];
p->b = a;
p->x = true;
p->next = rt[b];
rt[b] = p;
}
int S[10010];
bool jud[10010];
void init() {
for (int i = 1; i <= N; i++) {
jud[i] = false;
S[i] = 0;
}
}
void pdfs(int n) {
jud[n] = true;
for (edge *p = rt[n]; p != NULL; p = p->next) {
int b = p->b;
if (!jud[b]) {
pdfs(b);
S[n] += S[b];
if (p->x) S[n]++;
}
}
}
void dfs(int n, int s0, int s1) {
jud[n] = true;
int b, s, t0, t1;
for (edge *p = rt[n]; p != NULL; p = p->next) {
b = p->b;
if (!jud[b]) {
s = S[n];
mi = min(mi, s + s0);
t0 = s + s0 - S[b];
if (p->x)
s = S[n] - 1;
else
s = S[n] + 1;
mi = min(mi, s + s1);
t1 = s + s1 - S[b];
s = S[n] - (p->x == true);
mi = min(mi, s + s0);
t1 = min(t1, s + s0 - S[b]);
dfs(b, t0, t1);
}
}
}
int main() {
o = 0;
int i, j, k;
int a, b, s;
scanf("%d", &N);
if (N == 1) {
printf("0\n");
return 0;
}
for (i = 0; i <= N; i++) {
rt[i] = NULL;
}
for (i = 1; i < N; i++) {
scanf("%d%d", &a, &b);
addedge(a, b);
}
for (i = 1; i <= N; i++) {
init();
pdfs(i);
for (j = 0; j <= N; j++) jud[j] = false;
dfs(i, 0, 0);
}
printf("%d\n", mi);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= (2 * n / 3); i++) {
printf("0 %d\n", i);
}
for (int i = 1; i <= (n - (2 * n / 3)); i++) {
printf("3 %d\n", i * 2);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> mp;
string str[10010];
char s[111][111];
int cnt[26];
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
cout << '?' << ' ' << 1 << ' ' << n << endl;
int m = n * (n + 1) / 2;
for (int i = 1; i <= m; i++) {
cin >> str[i];
sort(str[i].begin(), str[i].end());
mp[str[i]]++;
}
if (n == 1) {
cout << '!' << ' ' << str[1] << endl;
return 0;
}
cout << '?' << ' ' << 2 << ' ' << n << endl;
for (int i = 1; i <= n * (n - 1) / 2; i++) {
string t;
cin >> t;
sort(t.begin(), t.end());
mp[t]--;
}
for (int i = 1; i <= m; i++) {
if (mp[str[i]]) {
int sz = str[i].size();
int len = 0;
for (int j = 0; j < sz; j++) {
s[sz][j + 1] = str[i][j];
}
}
}
cout << '!' << ' ' << s[1][1];
for (int i = 2; i <= n; i++) {
memset(cnt, 0, sizeof cnt);
for (int j = 1; j <= i - 1; j++) {
cnt[s[i - 1][j] - 'a']++;
}
for (int j = 1; j <= i; j++) {
cnt[s[i][j] - 'a']--;
}
for (int j = 0; j < 26; j++) {
if (cnt[j]) {
cout << (char)('a' + j);
}
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int p[100];
int q[100];
int z;
void haku(int c) {
if (c == 0) {
int t = 0;
for (int a = 0; a < n; a++) {
for (int b = a + 1; b < n; b++) {
if (p[a] > p[b]) t++;
}
}
q[t]++;
z++;
return;
}
for (int a = 0; a < n; a++) {
for (int b = a + 1; b <= n; b++) {
reverse(p + a, p + b);
haku(c - 1);
reverse(p + a, p + b);
}
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> p[i];
haku(k);
double e = 0;
for (int i = 0; i < 100; i++) {
e += i * (double)q[i] / z;
}
printf("%.12lf\n", e);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int t;
int flag = 0;
char s[N];
int num[50];
int main() {
scanf("%d", &t);
int x;
while (t--) {
scanf("%s", s);
flag = 0;
int l = strlen(s);
memset(num, 0, sizeof(num));
for (int i = 0; i < l; i++) {
num[s[i] - 'a']++;
}
int ans = 0;
for (int i = 0; i < 26; i++) {
if (num[i] == 1) {
if (flag)
ans++, flag = 0;
else
flag = 1;
} else if (num[i] > 1)
ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:128777216")
const int null = 0;
using namespace std;
template <class T>
int size(const T &a) {
return int(a.size());
}
template <class T>
T abs(const T &a) {
return (a < 0 ? -a : a);
}
template <class T>
T sqr(const T &a) {
return a * a;
}
vector<int> st;
int a[100010];
int main() {
int n;
scanf("%d", &n);
int res = -1;
for (int i = 0; i < n; i++) {
int t;
scanf("%d", &t);
a[i] = t;
while (!st.empty() && st.back() < t) {
st.pop_back();
}
if (!st.empty()) {
res = max(res, st.back() ^ t);
}
st.push_back(t);
}
st.clear();
for (int i = n - 1; i >= 0; i--) {
int t = a[i];
while (!st.empty() && st.back() < t) {
st.pop_back();
}
if (!st.empty()) {
res = max(res, st.back() ^ t);
}
st.push_back(t);
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int sum[512][512][10];
int pd[512][512][10];
int dx[5] = {0, 0, 1, 1};
int dy[5] = {0, 1, 0, 1};
int n, m, ans;
char c;
int main() {
int i, j, k, t;
cin >> n >> m;
for (i = 1; i <= n; ++i) {
cin.get();
for (j = 1; j <= m; ++j) {
c = cin.get();
sum[i][j][0] = (c == '*' ? 1 : 0);
}
}
for (k = 1; (1 << k) <= n && (1 << k) <= m; ++k)
for (i = 1; i + (1 << k) - 1 <= n; ++i)
for (j = 1; j + (1 << k) - 1 <= m; ++j) {
for (t = 0; t < 4; ++t) {
sum[i][j][k] +=
sum[i + (dx[t] << (k - 1))][j + (dy[t] << (k - 1))][k - 1];
if (sum[i + (dx[t] << (k - 1))][j + (dy[t] << (k - 1))][k - 1] ==
(1 << (2 * (k - 1))))
pd[i][j][k] ^= (1 << t);
}
if (k > 1) {
for (t = 0; t < 4; ++t)
if ((pd[i][j][k] & (1 << t)) == 0 &&
pd[i][j][k] !=
pd[i + (dx[t] << (k - 1))][j + (dy[t] << (k - 1))][k - 1]) {
pd[i][j][k] = -1;
break;
}
if (pd[i][j][k] != -1) ++ans;
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#define takes(x) cin >> x;
#define output(x) cout << x << endl;
#define int long long int
#define VectL vector<long long>
#define ll long long
#define VB vector<bool>
#define debug(x) cout << #x << " " << x << endl;
#define f(i, n) for (ll i = 0; i < n; i++)
#define fe(i, n) for (ll i = 1; i <= n; i++)
#define mod 1000000007
using namespace std;
VectL dp(110, -1);
int sum;
void takeArr(VectL &v, int n)
{
f(i, n)
{
cin >> v[i];
}
}
void printArr(VectL &v)
{
f(i, v.size())
cout
<< v[i] << " ";
cout << "\n";
}
void print2DArr(vector<VectL> &v)
{
f(i, v.size())
{
f(j, v[i].size())
{
cout << v[i][j] << " ";
}
cout << "\n";
}
}
int numberOfDigits(int n)
{
int f = 0;
while (n != 0)
{
n = n / 10;
f++;
}
return f;
}
vector<int> BFS(vector<VectL> matrix, int n)
{
vector<int> prev(n, -1);
vector<bool> visited(n, false);
queue<int> q;
q.push(0);
visited[0] = true;
while (!q.empty())
{
int x = q.front();
cout << x << endl;
q.pop();
f(i, n)
{
if (matrix[x][i] == 1)
{
if (visited[i] == false)
{
q.push(i);
visited[i] = true;
prev[i] = x;
}
}
}
}
return prev;
}
ll sumArr(VectL &v)
{
ll ans = 0;
f(i, v.size())
{
ans = ans + v[i];
}
return ans;
}
void yesno(int ans)
{
if (ans)
cout << "Yes\n";
else
cout << "No\n";
}
ll power(ll x, ll y)
{
ll temp;
if (y == 0)
return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return (temp * temp);
else
return (x * temp * temp);
}
void DFS(vector<VectL> &v, VB &visited, int x, int &sum)
{
visited[x] = true;
f(i, v[x].size())
{
if (visited[v[x][i]] == false)
{
sum++;
DFS(v, visited, v[x][i], sum);
}
}
}
void printMap(map<int, int> mp)
{
for (auto it = mp.begin(); it != mp.end(); it++)
{
cout << it->first << " " << it->second << endl;
}
cout << endl;
}
void solve(vector<int> &length)
{
int n = length.size();
vector<int> dp(n + 1, INT_MAX);
dp[0] = 0;
for (int i = 0; i < n; i++)
{
for (int j = i + 1; j <= i + length[i]; j++)
{
dp[j] = min(dp[j], dp[i] + 1);
}
}
printArr(dp);
}
int solve()
{
int a, b;
cin >> a >> b;
int c, d;
cin >> c >> d;
int e, f;
cin >> e >> f;
int ans = 0;
if (a == c && c == e)
{
if ((f > b && f < d) || (f > d && f < b))
ans = 2;
}
if (b == f && f == d)
{
if ((e > a && e < c) || (e > c && e < a))
ans = 2;
}
ans = ans + abs(c - a) + abs(d - b);
return ans;
}
int32_t main()
{
int t;
t = 1;
cin >> t;
while (t--)
{
cout << solve() << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int a[300300];
int dp[300300][50];
int sum[300300];
int main() {
int n;
gn(n);
for (int i = 1; i <= n; i++) gn(a[i]), sum[i] = sum[i - 1] + a[i];
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j < 50; j++) {
if (a[i] == 1000) smin(dp[i][j], dp[i - 1][j - 1] + a[i]);
if (a[i] == 2000 && j > 1) smin(dp[i][j], dp[i - 1][j - 2] + a[i]);
}
for (int j = 1; j < 50; j++) {
for (int k = min(j, a[i] / 100); k >= 0; k--) {
smin(dp[i][j - k], dp[i - 1][j] + a[i] - 100 * k);
}
}
}
int ans = 0x3f3f3f3f;
for (int i = 0; i < 25; i++) smin(ans, dp[n][i]);
for (int i = 1; i <= n; i++) {
smin(ans, sum[n] - min(sum[i], sum[n] - sum[i]) / 10);
}
println(ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101;
const int oo = 1000000007;
int f[11][maxn], c[maxn][maxn];
int a[maxn];
int n;
int main() {
int i, j, k;
c[0][0] = 1;
for (i = 1; i < maxn; i++) {
c[i][0] = 1;
for (j = 1; j <= i; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % oo;
}
scanf("%d", &n);
for (int i = 0; i < 10; i++) scanf("%d", &a[i]);
f[10][0] = 1;
for (i = 9; i; i--)
for (j = a[i]; j <= n; j++)
for (k = a[i]; k <= j; k++)
f[i][j] = (f[i][j] + ((long long)f[i + 1][j - k] * c[j][k]) % oo) % oo;
for (j = max(a[i], 1); j <= n; j++)
for (k = a[i]; k <= j; k++)
f[i][j] =
(f[i][j] + ((long long)f[i + 1][j - k] * c[j - 1][k]) % oo) % oo;
k = 0;
for (i = 1; i <= n; i++) k = (k + f[0][i]) % oo;
printf("%d\n", k);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> b[31], q;
int n, a[200020], f[31];
long long ans;
int main() {
scanf("%d", &n);
ans = 1LL * n * (n + 1) / 2;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = n; i; i--)
for (int j = 0; j < 31; j++)
if (a[i] & (1 << j)) b[j].push_back(i);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 31; j++)
if (!b[j].empty() && b[j].back() == i) b[j].pop_back();
int l = 0, r = n + 1;
while (!q.empty() && a[q.back()] < a[i]) q.pop_back();
if (!q.empty()) l = q.back();
q.push_back(i);
for (int j = 0; j < 31; j++)
if (!(a[i] & (1 << j))) {
l = max(f[j], l);
if (!b[j].empty()) r = min(r, b[j].back());
}
ans -= 1LL * (i - l) * (r - i);
for (int j = 0; j < 31; j++)
if (a[i] & (1 << j)) f[j] = i;
}
printf("%lld\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
while (b > 0) {
a %= b;
swap(a, b);
}
return a;
}
template <class _T>
inline _T sqr(const _T& first) {
return first * first;
}
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
const double EPS = 1e-9;
char TEMPORARY_CHAR;
const int INF = 1e9;
inline void input(int& a) {
a = 0;
while (((TEMPORARY_CHAR = getchar()) > '9' || TEMPORARY_CHAR < '0') &&
(TEMPORARY_CHAR != '-')) {
}
char neg = 0;
if (TEMPORARY_CHAR == '-') {
neg = 1;
TEMPORARY_CHAR = getchar();
}
while (TEMPORARY_CHAR <= '9' && TEMPORARY_CHAR >= '0') {
a = 10 * a + TEMPORARY_CHAR - '0';
TEMPORARY_CHAR = getchar();
}
if (neg) a = -a;
}
inline void out(long long a) {
if (!a) putchar('0');
if (a < 0) {
putchar('-');
a = -a;
}
char s[20];
int i;
for (i = 0; a; ++i) {
s[i] = '0' + a % 10;
a /= 10;
}
for (int j = (i)-1; j >= 0; j--) putchar(s[j]);
}
inline int nxt() {
int(ret);
input((ret));
;
return ret;
}
void apply(vector<int>& first, const vector<int>& p) {
vector<int> res(first.size());
int n = first.size();
for (int i = 0; i < n; ++i) {
res[p[i]] = first[i];
}
first.swap(res);
}
void multiply(vector<int>& first, const vector<int>& p) {
vector<int> res(first.size());
int n = first.size();
for (int i = 0; i < n; ++i) {
res[i] = p[first[i]];
}
first.swap(res);
}
void apply(vector<int> p, int k, vector<int>& first) {
while (k) {
if (k & 1) {
apply(first, p);
}
multiply(p, p);
k >>= 1;
}
}
int main() {
srand(33);
string s;
cin >> s;
int n = s.length();
int(q);
input((q));
;
vector<int> shiftLeft(n);
for (int i = 0; i < n; ++i) {
shiftLeft[i] = (i - 1 + n) % n;
}
vector<int> shiftRight(n);
for (int i = 0; i < n; ++i) {
shiftRight[i] = (i + 1) % n;
}
vector<int> first(n);
for (int i = 0; i < n; ++i) {
first[i] = i;
}
while (q--) {
int(k);
input((k));
;
int(d);
input((d));
;
vector<int> sort(n);
for (int i = 0; i < n; ++i) {
sort[i] = i;
}
int sz = 0;
for (int i = 0; i < d; ++i) {
for (int j = 0; j * d + i < k; ++j) {
sort[j * d + i] = sz++;
}
}
multiply(sort, shiftLeft);
apply(sort, n - k + 1, first);
apply(shiftRight, n - k + 1, first);
for (int i = 0; i < n; ++i) {
putchar(s[first[i]]);
}
puts("");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a, n, i, k, l, r, d, kol1, kol2, ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> a;
if (a < k)
kol1++;
else if (a > k)
kol2++;
}
l = n;
r = n * 3;
while (l <= r) {
d = (l + r) / 2;
if (((d + 1) / 2 - 1 >= kol1) && (d - (d + 1) / 2 >= kol2)) {
r = d - 1;
ans = d - n;
} else
l = d + 1;
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long LLINF = 1e18;
const int INF = 1e9;
const int MOD = 998244353;
const int HMOD = 999959;
const int VMOD = 5000000;
const int MAXN = 3e5 + 10;
const int MAXM = 5e5 + 10;
const int INV = 10050505;
const long long LLINV = 1e18;
const double eps = 1e-3;
int dirx[5] = {0, -1, 1, 0, 0}, diry[5] = {0, 0, 0, -1, 1};
int n, k;
void solve() {
scanf("%d%d", &n, &k);
if (n > k && (n - k) % 2 == 0)
puts("0");
else if (n > k)
puts("1");
else
printf("%d\n", k - n);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int T;
scanf("%d", &T);
while (T--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int ara[n], sum = 0;
for (long long int i = 0; i < n; i++) {
cin >> ara[i];
sum += ara[i];
}
long long int t1 = 0, t2 = 0, c = 1, d = 1, magi = sum;
sum = sum / n;
sort(ara, ara + n);
for (long long int i = 0, j = n - 1; (c == 1 || d == 1) && (i < n && j >= 0);
i++, j--) {
if (c == 1) {
if (ara[i] >= sum)
c = 0;
else {
t1 += sum - ara[i];
}
}
if (magi % n != 0 && d == 1) {
if (ara[j] <= (sum + 1))
d = 0;
else {
t2 += ara[j] - (sum + 1);
}
}
}
if (t1 > t2)
cout << t1 << endl;
else
cout << t2 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int di[] = {-1, 0, 1, 0, 1, -1, 1, -1};
const int dj[] = {0, 1, 0, -1, 1, -1, -1, 1};
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n;
cin >> n;
vector<int> num(n);
int tg = 0;
for (int i = 0; i < n; i++) cin >> num[i], tg = gcd(tg, num[i]);
if (tg > 1) {
cout << "YES" << endl << 0 << endl;
return 0;
}
int a, b, r = 0;
for (int i = 0; i < n - 1; i++) {
if (abs(num[i]) % 2 == 1 && abs(num[i + 1]) % 2 == 1) {
while (num[i] % 2 == 1 || num[i + 1] % 2 == 1) {
a = num[i], b = num[i + 1];
num[i] = a - b, num[i + 1] = a + b;
r++;
}
}
}
for (int i = 0; i < n - 1; i++) {
while (abs(num[i]) % 2 == 1) {
a = num[i], b = num[i + 1];
num[i] = a - b, num[i + 1] = a + b;
r++;
}
}
while (abs(num[n - 1]) % 2 == 1) {
a = num[n - 2], b = num[n - 1];
num[n - 2] = a - b, num[n - 1] = a + b;
r++;
}
cout << "YES" << endl;
cout << r << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int calc_lowbit(int a) {
if (a & 1)
return 1;
else {
for (int i = 0; i < 20; i++) {
if (a & (1 << i)) return (1 << i);
}
}
}
bool mySort(pair<int, int> a, pair<int, int> b) {
if (a.first > b.first)
return true;
else if (a.first < b.first)
return false;
else {
if (a.second >= b.second)
return true;
else
return false;
}
}
int main() {
int sum;
int limit;
cin >> sum >> limit;
vector<pair<int, int>> arr;
int calcsum = 0;
for (int i = 1; i <= limit; i++) {
int lb = calc_lowbit(i);
arr.push_back({lb, i});
calcsum += lb;
}
if (calcsum < sum) {
cout << "-1";
return 0;
}
sort(arr.begin(), arr.end(), mySort);
int tempsum = 0;
deque<bool> ans(arr.size(), false);
int i = 0;
while (i < arr.size()) {
if (tempsum + arr[i].first < sum) {
tempsum += arr[i].first;
ans[i] = true;
} else if (tempsum + arr[i].first == sum) {
ans[i] = true;
break;
}
i++;
}
int l = 0;
for (int j = 0; j < ans.size(); j++) {
if (ans[j]) l++;
}
cout << l << "\n";
for (int j = 0; j < ans.size(); j++) {
if (ans[j]) cout << arr[j].second << " ";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const double eps = 1e-9;
const int inf = 1e9;
int deg[N];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, x;
scanf("%d%d", &n, &x);
for (int i = 0; i < n + 10; i++) deg[i] = 0;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
deg[u]++;
deg[v]++;
}
if (deg[x] < 2)
printf("Ayush\n");
else {
if (n & 1)
printf("Ashish\n");
else
printf("Ayush\n");
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin >> a;
bool res = false;
for (char it : a) {
if (it == 'Q' || it == 'H' || it == '9') {
res = true;
}
}
cout << (res ? "YES" : "NO");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
if (n < 4) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
if (n % 2 == 0) {
cout << "1 * 2 = 2" << endl;
cout << "2 * 3 = 6" << endl;
cout << "4 * 6 = 24" << endl;
for (int i = n; i > 4; i -= 2) {
cout << i << " - " << i - 1 << " = " << 1 << endl;
}
for (int i = n; i > 4; i -= 2) {
cout << "24 * 1 = 24" << endl;
}
} else {
cout << "2 + 3 = 5" << endl;
cout << "4 * 5 = 20" << endl;
cout << "20 + 5 = 25" << endl;
cout << "25 - 1 = 24" << endl;
for (int i = n; i > 5; i -= 2) {
cout << i << " - " << i - 1 << " = " << 1 << endl;
}
for (int i = n; i > 5; i -= 2) {
cout << "24 * 1 = 24" << endl;
}
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.