solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, p = 1, c = 0, m = 0;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
if (a[i] > m) m = a[i];
}
long long int k = a[n - 1];
for (int i = n - 2; i >= 0; i--) {
if (a[i] > k) {
c++;
k = a[i];
} else if (k == m)
break;
}
cout << c << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
vector<tuple<int, int, int> > S, C;
int SV[100002];
int CV[100002];
int SL[100002][2];
int CL[100002][2];
int go1(int i) {
int c = get<1>(S[i]);
int j = SL[i][1];
if (j == -1) {
return c;
}
int ni = CL[j][1];
if (ni == -1) {
return -1;
} else {
int r = go1(ni);
return min(c, r);
}
}
long long go2(int i, int minc, bool givenup) {
int c = get<1>(S[i]);
int j = SL[i][1];
if (c == minc && !givenup) {
c = 0;
givenup = true;
SV[i] = -2;
} else {
if (!givenup) {
SV[i] = SL[i][1];
} else {
SV[i] = SL[i][0];
}
}
if (j == -1 || CL[j][1] == -1) {
return c;
}
return c + go2(CL[j][1], minc, givenup);
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
int c, s;
scanf("%d%d", &c, &s);
S.push_back(make_tuple(s, c, i + 1));
}
scanf("%d", &M);
for (int i = 0; i < M; ++i) {
int d, l;
scanf("%d%d", &d, &l);
C.push_back(make_tuple(l, d, i + 1));
}
sort(S.begin(), S.end());
sort(C.begin(), C.end());
memset(SV, -1, sizeof(SV));
memset(CV, -1, sizeof(CV));
memset(SL, -1, sizeof(SL));
memset(CL, -1, sizeof(CL));
long long sales = 0;
int i = 0;
int j = 0;
int lb = get<0>(C[0]);
while (i < N && j < M) {
int c = get<1>(S[i]);
int s = get<0>(S[i]);
int l = get<0>(C[j]);
if (s < l) {
++i;
continue;
}
if (s > l + 1) {
++j;
continue;
}
int cnt = 0;
int q = -1;
int k = j;
for (; k < M && get<0>(C[k]) == l; ++k) {
if (get<1>(C[k]) >= c && CV[k] == -1) {
if (++cnt == 1) q = k;
}
}
if (cnt > 1 || (cnt == 1 && s == l + 1 && CL[q][0] == -1)) {
SV[i] = q;
CV[q] = i;
if (SL[i][0] != -1) {
CL[SL[i][0]][1] = -1;
SL[i][0] = -1;
}
sales += c;
++i;
} else if (cnt == 1) {
if (s == l) {
SL[i][1] = q;
CL[q][0] = i;
++i;
} else {
SL[i][0] = q;
CL[q][1] = i;
j = k;
}
} else {
if (s == l)
++i;
else
j = k;
}
}
for (int i = 0; i < N; ++i) {
if (SV[i] == -1) {
int minc = go1(i);
sales += go2(i, minc, false);
}
}
cout << sales << endl;
int cnt = 0;
for (int i = 0; i < N; ++i) cnt += SV[i] >= 0;
cout << cnt << endl;
for (int i = 0; i < N; ++i) {
if (SV[i] >= 0) {
cout << get<2>(C[SV[i]]) << " " << get<2>(S[i]) << endl;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long N, M, K, S, A, B, X, Y, Z, C, a, b, c, d, i, j, k;
void solve() {
cin >> N >> M;
vector<long long> V[N];
map<pair<long long, long long>, bool> Mm;
for (int i = 0; i < M; i++) {
cin >> a >> b;
a--;
b--;
V[a].push_back(b);
V[b].push_back(a);
Mm[{a, b}] = 1;
Mm[{b, a}] = 1;
}
vector<long long> U[3];
U[0].push_back(0);
set<long long> S;
S.insert(0);
for (int i = 1; i < N; i++) {
if (Mm.find({0, i}) == Mm.end()) {
U[0].push_back(i);
S.insert(i);
}
}
for (int i = 1; i < N; i++) {
if (Mm.find({0, i}) != Mm.end()) {
U[1].push_back(i);
S.insert(i);
for (int j = 0; j < N; j++) {
if (i != j && Mm.find({j, i}) == Mm.end()) {
U[1].push_back(j);
if (S.find(j) != S.end()) {
cout << "-1" << endl;
return;
}
S.insert(j);
}
}
break;
}
}
for (int i = 0; i < N; i++) {
if (S.find(i) == S.end()) {
U[2].push_back(i);
S.insert(i);
for (int j = 0; j < N; j++) {
if (i != j && Mm.find({j, i}) == Mm.end()) {
U[2].push_back(j);
if (S.find(j) != S.end()) {
cout << "-1" << endl;
return;
}
S.insert(j);
}
}
break;
}
}
a = U[0].size();
b = U[1].size();
c = U[2].size();
if (b == 0 || c == 0 || a == 0 || (a + b + c != N) ||
(a * b + b * c + c * a != M)) {
cout << "-1" << endl;
return;
}
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
if (Mm.find({U[0][i], U[1][j]}) == Mm.end()) {
cout << "-1" << endl;
return;
}
}
}
for (int i = 0; i < a; i++) {
for (int j = 0; j < c; j++) {
if (Mm.find({U[0][i], U[2][j]}) == Mm.end()) {
cout << "-1" << endl;
return;
}
}
}
for (int i = 0; i < c; i++) {
for (int j = 0; j < b; j++) {
if (Mm.find({U[2][i], U[1][j]}) == Mm.end()) {
cout << "-1" << endl;
return;
}
}
}
long long ans[N];
for (int i = 0; i < a; i++) ans[U[0][i]] = 1;
for (int i = 0; i < b; i++) ans[U[1][i]] = 2;
for (int i = 0; i < c; i++) ans[U[2][i]] = 3;
for (int i = 0; i < N; i++) cout << ans[i] << " ";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1, p = 1;
while (t <= p) {
solve();
t++;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n, p = 0, l = 0;
n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] == 'o')
p++;
else
l++;
}
if (l == 0 || p == 0) {
cout << "YES";
return 0;
}
if (l % p == 0)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, x, y, z, p;
cin >> n >> m >> x >> y >> z >> p;
x %= 4;
if (y % 2 != 0)
x = (z % 4 + x) % 4;
else {
x = 4 - x;
x = (z % 4 + x) % 4;
}
while (p--) {
long long i, j;
scanf("%llu%llu", &i, &j);
if (y % 2 != 0) {
j = m - j + 1;
if (x == 0)
printf("%llu %llu\n", i, j);
else if (x == 1)
printf("%llu %llu\n", m - j + 1, i);
else if (x == 2)
printf("%llu %llu\n", n - i + 1, m - j + 1);
else
printf("%llu %llu\n", j, n - i + 1);
} else {
if (x == 0)
printf("%llu %llu\n", i, j);
else if (x == 1)
printf("%llu %llu\n", m - j + 1, i);
else if (x == 2)
printf("%llu %llu\n", n - i + 1, m - j + 1);
else
printf("%llu %llu\n", j, n - i + 1);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int f(int n, int m, int x) {
x *= 2;
if (x > min(n, m)) return 0;
return ((n - x) * (m - x) + 1) / 2;
}
int main() {
int n, m, x;
scanf("%d %d %d", &n, &m, &x);
if (2 * (x - 1) >= min(n, m))
printf("0\n");
else
printf("%d\n", f(n, m, x - 1) - f(n, m, x));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5, M = 1e4 + 5, OO = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int n, ans = OO;
void solve(int a, int b, int cnt) {
if (a == 1 && b == 1) ans = min(ans, cnt);
if (a - b > 0) solve(a - b, b, cnt + 1);
if (b - a > 0) solve(a, b - a, cnt + 1);
}
int main() {
cin >> n;
if (n == 1) return cout << 0, 0;
for (int a = 1; a < n; ++a) solve(a, n - a, 1);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T a) {
return (a) * (a);
}
template <class T>
T abs(T a) {
return (a < 0) ? -(a) : (a);
}
const double Pi = acos(-1.0);
const double eps = 1e-9;
const int INF = 101e7;
bool big(char a) { return (a >= 'A' && a <= 'Z'); }
int main() {
int n;
long long p[12], m[12], z;
scanf("%d\n", &n);
long long a;
long long ans;
for (int i = 0, _n = (11) - 1; i <= _n; i++) {
p[i] = 0;
m[i] = 0;
}
z = 0;
for (int i = 0, _n = (n)-1; i <= _n; i++) {
cin >> a;
if (a > 0)
p[a]++;
else if (a < 0)
m[-a]++;
else
z++;
}
ans = 0;
for (int i = (1), _b = (10); i <= _b; i++) {
ans += (long long)p[i] * m[i];
}
if (z > 0) ans += (long long)(z * (z - 1)) / 2;
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
const int M = 18;
const int K = 10;
int par[N][M];
vector<int> path[N][M];
int n, m, q;
vector<int> adj[N], ids[N];
int c[N];
int d[N];
vector<int> uni(vector<int> a, vector<int> b) {
vector<int> res;
int aa = 0, bb = 0;
while (a.size() > aa && b.size() > bb && res.size() < K) {
if (a[aa] < b[bb]) {
res.push_back(a[aa++]);
} else {
res.push_back(b[bb++]);
}
}
while (res.size() < K && aa < a.size()) {
res.push_back(a[aa++]);
}
while (res.size() < K && bb < b.size()) {
res.push_back(b[bb++]);
}
return res;
}
void dfs(int v, int p) {
if (p != -1) d[v] = d[p] + 1;
par[v][0] = p;
for (int i = 1; i < M; i++) {
if (par[v][i - 1] != -1) {
par[v][i] = par[par[v][i - 1]][i - 1];
}
}
if (p != -1) path[v][0] = ids[p];
for (int i = 1; i < M; i++) {
if (par[v][i] != -1) {
path[v][i] = uni(path[v][i - 1], path[par[v][i - 1]][i - 1]);
}
}
for (int u : adj[v])
if (u != p) {
dfs(u, v);
}
}
vector<int> lca(int v, int u) {
if (v == u) return ids[v];
if (d[v] < d[u]) swap(v, u);
vector<int> res = ids[v];
for (int i = M - 1; i >= 0; i--) {
if (par[v][i] != -1 && d[par[v][i]] >= d[u]) {
res = uni(res, path[v][i]);
v = par[v][i];
}
}
if (v == u) return res;
res = uni(res, ids[u]);
for (int i = M - 1; i >= 0; i--) {
if (par[v][i] != par[u][i]) {
res = uni(res, path[v][i]);
v = par[v][i];
res = uni(res, path[u][i]);
u = par[u][i];
}
}
return uni(res, ids[par[v][0]]);
;
}
vector<int> get(int v, int u) {
if (v == u) return ids[v];
vector<int> res;
for (int i = M - 1; i >= 0; i--) {
if (par[v][i] != -1 && d[par[v][i]] >= d[u]) {
res = uni(res, path[v][i]);
v = par[v][i];
}
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
scanf("%d %d %d", &n, &m, &q);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 1; i <= m; i++) {
scanf("%d", c + i);
ids[c[i]].push_back(i);
}
memset(par, -1, sizeof par);
dfs(1, -1);
while (q--) {
int v, u, a;
scanf("%d %d %d", &v, &u, &a);
vector<int> res = lca(v, u);
printf("%d", min(a, int(res.size())));
for (int i = 0; i < min(a, int(res.size())); i++) {
printf(" %d", res[i]);
}
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int s[400005];
int main() {
int t, n, m;
scanf("%d", &t);
while (t--) {
int a[3] = {0, 0, 0};
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &s[i]);
}
int u = n / 2;
for (int i = 1; i <= u; i++) {
if (s[i] != s[i + 1]) {
if (a[0] == 0)
a[0] = i;
else if (a[1] == 0 || a[1] <= a[0])
a[1] = i - a[0];
a[2] = i - a[1] - a[0];
}
}
if (a[0] == 0 || a[1] == 0 || a[2] == 0) {
a[0] = 0;
a[1] = 0;
a[2] = 0;
}
if (a[1] <= a[0] || a[2] <= a[0]) {
a[0] = 0;
a[1] = 0;
a[2] = 0;
}
printf("%d %d %d\n", a[0], a[1], a[2]);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
a:
double h, l;
cin >> h >> l;
printf("%.10f\n", (l * l - h * h) / (2.0 * h));
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 510, inf = 1e9, mod = 998244353;
int n, cnt1, cnt2, cnt3, cnt4;
int a[maxn], b[maxn], f[maxn], g[maxn], ans1[maxn], ans[maxn], nxt[maxn],
ru[maxn], G[maxn];
int A[maxn][maxn], C[maxn][maxn], s[maxn][maxn];
bool v[maxn];
template <typename T>
inline void read(T &k) {
int f = 1;
k = 0;
char c = getchar();
while (c < '0' || c > '9') c == '-' && (f = -1), c = getchar();
while (c <= '9' && c >= '0') k = k * 10 + c - '0', c = getchar();
k *= f;
}
void dfs(int x, int fa) {
v[x] = 1;
if (nxt[x]) {
if (!v[nxt[x]])
dfs(nxt[x], fa);
else
cnt3++;
} else {
if (fa > n && x > n)
cnt4++;
else if (fa <= n && x > n)
cnt1++;
else if (fa > n && x <= n)
cnt2++;
}
}
inline void init() {
s[0][0] = C[0][0] = A[0][0] = 1;
for (int i = 1; i <= n; i++) {
C[i][0] = A[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = ((C[i - 1][j - 1] + C[i - 1][j]) >= mod
? (C[i - 1][j - 1] + C[i - 1][j]) - mod
: (C[i - 1][j - 1] + C[i - 1][j]));
A[i][j] = (1ll * j * A[i - 1][j - 1] + A[i - 1][j]) % mod;
s[i][j] = (1ll * (i - 1) * s[i - 1][j] + s[i - 1][j - 1]) % mod;
}
}
}
inline void getans(int n, int *f) {
for (int i = 0; i <= n; i++) {
for (int j = i; j <= n; j++)
f[i] =
(f[i] + 1ll * C[n][j] * s[j][i] % mod * A[n - j + cnt4][n - j]) % mod;
}
memset(G, 0, sizeof(G));
for (int i = 0; i <= n; i++) {
for (int j = i, fz = 1; j <= n; j++, fz = -fz)
G[i] = (G[i] + 1ll * C[j][i] * f[j] % mod * fz + mod) % mod;
}
memcpy(f, G, sizeof(G));
}
int main() {
read(n);
for (int i = 1; i <= (n << 1); i++) v[i] = 1;
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= n; i++) read(b[i]);
for (int i = 1; i <= n; i++) {
int x = a[i] ? a[i] : i + n, y = b[i] ? b[i] : i + n;
v[x] = v[y] = 0;
if (x <= n || y <= n) nxt[x] = y, ru[y]++;
}
for (int i = 1; i <= (n << 1); i++)
if (!v[i] && !ru[i]) dfs(i, i);
for (int i = 1; i <= (n << 1); i++)
if (!v[i]) dfs(i, i);
init();
getans(cnt1, f);
getans(cnt2, g);
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= i; j++)
ans1[i] = (ans1[i] + 1ll * f[j] * g[i - j]) % mod;
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= i; j++)
ans[i] = (ans[i] + 1ll * ans1[j] * s[cnt4][i - j]) % mod;
ans[i] = 1ll * ans[i] * A[cnt4][cnt4] % mod;
}
for (int i = 0; i < n; i++)
printf("%d ", (n - i - cnt3 < 0) ? 0 : ans[n - i - cnt3]);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long double pi = acos(-1);
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie();
long long t;
cin >> t;
long long p, maxy = 0, s = 0;
vector<pair<long long, long long> > q(t);
for (long long i = 0; i < t; i++) {
cin >> q[i].first;
for (long long j = 0; j < q[i].first; j++) {
cin >> p;
q[i].second = max(q[i].second, p);
}
maxy = max(q[i].second, maxy);
}
for (long long i = 0; i < t; i++) {
s += (maxy - q[i].second) * q[i].first;
}
cout << s;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n >> s;
int sum = 0;
bool f = 0;
for (int i = 0; i < n; i++) {
if (sum < 0 && f == 1)
break;
else if (sum < 0)
f = 1, sum += 1;
if (s[i] == '(')
sum += 1;
else
sum -= 1;
}
if ((sum == 0 && f == 0) || (sum == 1 && f == 1))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| 2 |
#include <bits/stdc++.h>
int removeDuplicate(int a[], int size) {
int prev = 0;
for (int i = 0; i < size; i++) {
if (a[i] != a[prev]) a[++prev] = a[i];
}
int count = prev + 1;
return count;
}
using namespace std;
int main() {
int n, i, j, count, m, p;
vector<int> v1;
cin >> n;
int a[n], b[n];
for (i = 0; i < n; i++) {
cin >> a[i];
v1.push_back(a[i]);
}
sort(a, a + n);
count = removeDuplicate(a, n);
m = 1;
p = 1;
for (i = count - 1; i >= 0; i--) {
for (j = 0; j < n; j++) {
if (a[i] == v1[j]) {
b[j] = m;
p++;
}
}
m = p;
}
for (i = 0; i < n; i++) cout << b[i] << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400 * 1000;
int n, k, a[N], b[N] = {};
long long int r = 0;
map<int, int> mp;
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
int m = 0;
for (int i = 0, t; i < n; ++i) {
cin >> t;
if (mp.count(t))
a[i] = mp[t];
else
a[i] = mp[t] = m++;
}
for (int i = 0, j = 0; i < n; ++i) {
++b[a[i]];
if (b[a[i]] == k) {
int c = 1;
while (a[j] != a[i]) {
--b[a[j++]];
++c;
}
r += 1ll * c * (n - i);
--b[a[i]];
++j;
}
}
cout << r << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int md = 65;
string s[md];
int n, m, T;
int row[md], col[md];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> T;
while (T--) {
int tot = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> s[i];
s[i] = '#' + s[i];
for (int j = 1; j <= m; j++) tot += (s[i][j] == 'P');
}
if (tot == n * m)
cout << "MORTAL\n";
else if (tot == 0)
cout << "0\n";
else {
for (int i = 1; i <= n; i++) {
row[i] = 0;
for (int j = 1; j <= m; j++)
if (s[i][j] == 'P') row[i] = 1;
row[i] += row[i - 1];
}
int res = 4;
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int j = 1; j <= m; j++) cnt += (s[i][j] == 'P');
if (cnt == m) continue;
int dir = (row[i - 1] > 0) + (row[n] - row[i] > 0);
if (cnt == 0)
res = min(res, dir);
else if (s[i][1] == 'A' || s[i][m] == 'A')
res = min(res, dir + 1);
else
res = min(res, dir + 2);
}
for (int j = 1; j <= m; j++) {
col[j] = 0;
for (int i = 1; i <= n; i++)
if (s[i][j] == 'P') col[j] = 1;
col[j] += col[j - 1];
}
for (int j = 1; j <= m; j++) {
int cnt = 0;
for (int i = 1; i <= n; i++) cnt += (s[i][j] == 'P');
if (cnt == n) continue;
int dir = (col[j - 1] > 0) + (col[m] - col[j] > 0);
if (cnt == 0)
res = min(res, dir);
else if (s[1][j] == 'A' || s[n][j] == 'A')
res = min(res, dir + 1);
else
res = min(res, dir + 2);
}
cout << res << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 52;
const long long MOD = 1e9 + 7;
int n, p, c[N];
long long C[N][N];
long long f[N][N][N][N];
void add(long long& x, long long y) {
x += y;
x %= MOD;
}
void upd(int i, int j, int k, int x) {
if (f[i][j][k][x] == 0) return;
int y = (n - i + 1) - (j + k + x);
if (i == 1) return;
for (int col = 0; col < 2; col++) {
if (c[i - 1] == -1 || c[i - 1] == col) {
if (col == 0) {
long long w0 = ((1LL << x) % MOD) * ((1LL << y) / 2 % MOD) % MOD;
long long w1 = ((1LL << x) % MOD) * ((1LL << y) % MOD) % MOD - w0;
w1 = (w1 % MOD + MOD) % MOD;
long long P = (1LL << (j + k)) % MOD;
(w0 *= P) %= MOD;
(w1 *= P) %= MOD;
add(f[i - 1][j + 1][k][x], f[i][j][k][x] * w0);
add(f[i - 1][j][k + 1][x], f[i][j][k][x] * w1);
}
if (col == 1) {
long long w0 = ((1LL << j) % MOD) * ((1LL << k) / 2 % MOD) % MOD;
long long w1 = ((1LL << j) % MOD) * ((1LL << k) % MOD) % MOD - w0;
w1 = (w1 % MOD + MOD) % MOD;
long long P = (1LL << (x + y)) % MOD;
(w0 *= P) %= MOD;
(w1 *= P) %= MOD;
add(f[i - 1][j][k][x + 1], f[i][j][k][x] * w0);
add(f[i - 1][j][k][x], f[i][j][k][x] * w1);
}
}
}
}
int main() {
scanf("%d%d", &n, &p);
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
}
f[n + 1][0][0][0] = 1;
for (int i = n + 1; i >= 1; i--) {
int tot = n - i + 1;
for (int j = 0; j <= tot; j++) {
for (int k = 0; k + j <= tot; k++) {
for (int x = 0; k + j + x <= tot; x++) {
upd(i, j, k, x);
}
}
}
}
long long ans = 0;
for (int j = 0; j <= n; j++)
for (int k = 0; k + j <= n; k++)
for (int x = 0; j + k + x <= n; x++) {
int y = n - (j + k + x);
if ((k + y) % 2 == p) add(ans, f[1][j][k][x]);
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline t read(t &x) {
bool f = 0;
char c = getchar();
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int N = 305;
int n;
pair<int, int> a[N];
bitset<N> b[N][N];
long long all, C3, C4;
pair<int, int> operator-(pair<int, int> first, pair<int, int> second) {
return {first.first - second.first, first.second - second.second};
}
long long cj(pair<int, int> a, pair<int, int> b) {
return 1ll * a.first * b.second - 1ll * a.second * b.first;
}
signed main() {
read(n);
all = 1ll * n * (n - 1) / 2 * (n - 2) / 3 * (n - 3) / 4 * (n - 4) / 5;
for (int i = 0; i < n; i++) read(a[i].first), read(a[i].second);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
for (int k = j + 1; k < n; k++) {
if (cj(a[j] - a[i], a[k] - a[i]) >= 0)
b[i][j][k] = b[j][k][i] = b[k][i][j] = 1;
else
b[i][k][j] = b[j][i][k] = b[k][j][i] = 1;
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
for (int k = j + 1; k < n; k++) {
int w = (b[i][j][k] ? b[i][j] & b[j][k] & b[k][i]
: b[i][k] & b[k][j] & b[j][i])
.count();
C3 += w * (w - 1) / 2;
C4 += w;
}
C4 = C4 * (n - 4) / 2 - C3 * 2;
write(all - C3 - C4);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 987654321;
const int MOD = 1000000007;
int order(const vector<int>& A, const vector<int>& B) {
int n = A.size(), ret = 0;
multiset<int> ratings(B.begin(), B.end());
for (int ai = 0; ai < n; ++ai) {
if (*ratings.rbegin() < A[ai]) {
ratings.erase(ratings.begin());
ret++;
} else {
ratings.erase(ratings.lower_bound(A[ai]));
}
}
return ret;
}
int order2(const vector<int>& A, const vector<int>& B) {
int n = A.size(), ret = 0;
multiset<int> ratings(B.begin(), B.end());
for (int ai = 0; ai < n; ++ai) {
if (*ratings.rbegin() <= A[ai])
ratings.erase(ratings.begin());
else {
ratings.erase(ratings.upper_bound(A[ai]));
ret++;
}
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string str1, str2;
cin >> str1 >> str2;
vector<int> arr1(n), arr2(n);
for (int i = 0; i < (n); ++i) arr1[i] = str1[i] - '0';
for (int i = 0; i < (n); ++i) arr2[i] = str2[i] - '0';
sort(arr1.begin(), arr1.end());
sort(arr2.begin(), arr2.end());
int sol1 = order(arr1, arr2);
int sol2 = order2(arr1, arr2);
cout << sol1 << '\n' << sol2;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC("O3")
using namespace std;
string printBit(int x) {
string res;
while (res.size() < 12) {
res.push_back(x % 2 + '0');
x >>= 1;
}
reverse((res).begin(), (res).end());
return res;
}
long long MAX = 1e16;
int main() {
long long N;
scanf("%lld", &N);
--N;
long long sum = 0;
for (long long i = 2; i <= MAX; i <<= 1) {
sum += (i >> 1) * ((N + (i >> 1)) / i);
}
cout << sum << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> primes;
bool flag[46010];
void Sieve() {
for (int i = 2; i <= 46000; i++) {
if (!flag[i]) {
primes.push_back(i);
for (int j = i * i; j <= 46000; j += i) flag[j] = 1;
}
}
}
int main() {
Sieve();
int N, M;
scanf("%d", &N);
M = (N * (N + 1)) >> 1;
for (int i = 0; primes[i] * primes[i] <= M; i++) {
if (M % primes[i] == 0) {
puts("Yes");
printf("1 %d\n", primes[i]);
printf("%d", N - 1);
for (int j = 1; j <= N; j++) {
if (j == primes[i])
continue;
else
printf(" %d", j);
}
puts("");
return 0;
}
}
puts("No");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> a(n), p(n + 1);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
p[a[i]] = i;
}
int best = 1;
for (int i = 1; i <= n;) {
int j = i + 1;
while (j <= n && p[j] > p[j - 1]) j++;
best = max(best, j - i);
i = j;
}
printf("%d\n", n - best);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int solve(int w, int h, int S) {
if (S == (2 * w + 1) * (2 * h + 1)) return 2 * (w + 1) * (h + 1) - 1;
if (S > (2 * w + 1) * (2 * h + 1)) return 0;
S = (2 * w + 1) * (2 * h + 1) - S;
if (S & 3) return 0;
S /= 4;
int res = 0;
for (int w2 = 0; w2 < w; w2++) {
if (S % (w - w2)) continue;
int h2 = h - S / (w - w2);
if (h2 < 0 || h2 >= h) continue;
res++;
}
return 2 * res;
}
int main() {
int W, H, s;
while (scanf("%d%d%d", &W, &H, &s) >= 1) {
long long ans = 0;
for (int w = 0; 2 * w + 1 <= W; w++) {
for (int h = 0; 2 * h + 1 <= H; h++) {
ans += solve(w, h, s) * (long long)(W - (2 * w + 1) + 1) *
(H - (2 * h + 1) + 1);
}
}
printf(
"%lld"
"\n",
ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000 * 1000 * 1000 + 7;
long long mod(long long n) { return (n % MOD + MOD) % MOD; }
long long fp(long long n, long long p) {
if (p == 0) return 1;
long long t = fp(n, p >> 1);
if (p & 1)
return mod(mod(t * t) * n);
else
return mod(t * t);
}
long long mdiv(long long a, long long b) { return mod(a * fp(b, MOD - 2)); }
pair<long long, long long> sum(pair<long long, long long> a,
pair<long long, long long> b) {
return {mod(a.first * b.second + b.first * a.second),
mod(a.second * b.second)};
}
pair<long long, long long> mul(pair<long long, long long> a,
pair<long long, long long> b) {
return {mod(a.first * b.first), mod(a.second * b.second)};
}
const long long N = 50;
const long long K = 10001;
pair<long long, long long> dp[K][N];
vector<pair<long long, long long> > get(long long n, long long k) {
for (long long i = 0; i < K; ++i) {
for (long long j = 0; j < N; ++j) dp[i][j] = {0, 1};
}
dp[0][n] = {1, 1};
for (long long i = 1; i <= k; ++i) {
for (long long j = 0; j <= n; ++j) {
for (long long t = j; t <= n; ++t) {
dp[i][j] = sum(dp[i][j], mul(dp[i - 1][t], {1, t + 1}));
}
}
}
vector<pair<long long, long long> > ans;
for (long long i = 0; i <= n; ++i) ans.push_back(dp[k][i]);
return ans;
}
vector<long long> v, cnt;
vector<vector<pair<long long, long long> > > p;
pair<long long, long long> ans = {0, 1};
void gen(long long i, pair<long long, long long> cp, long long f) {
f = mod(f);
if (i == v.size()) {
cp.first = mod(cp.first * f);
ans = sum(ans, cp);
return;
}
long long cf = 1;
for (long long pw = 0; pw <= cnt[i]; ++pw) {
gen(i + 1, mul(cp, p[i][pw]), f * cf);
cf *= v[i];
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
for (long long d = 2; d * d <= n; ++d) {
while (n % d == 0) {
v.push_back(d);
n /= d;
}
}
if (n != 1) v.push_back(n);
map<long long, long long> d;
for (auto e : v) d[e]++;
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
for (auto e : v) {
cnt.push_back(d[e]);
p.push_back(get(d[e], k));
}
gen(0, {1, 1}, 1);
cout << mdiv(ans.first, ans.second) << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, mod = 1e9 + 7, inf = 1e9 + 7;
const long long linf = (long long)1e18 + 7;
const long double eps = 1e-15, pi = 3.141592;
const int dx[] = {-1, 0, 1, 0, 1, -1, -1, 1},
dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
int n;
int l[N], c[N];
map<int, int> dp;
inline void upd(int &x, int y) {
if (!x)
x = y;
else
x = min(x, y);
}
inline int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a | b;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &l[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &c[i]);
dp[0] = 0;
for (int i = 1; i <= n; ++i) {
map<int, int> dp2;
for (auto it : dp) upd(dp2[gcd(it.first, l[i])], it.second + c[i]);
for (auto it : dp2) upd(dp[it.first], it.second);
}
if (!dp[1]) dp[1] = -1;
cout << dp[1];
exit(0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
cout << (n / 5) * (m / 5) + ((n + 4) / 5) * ((m + 1) / 5) +
((n + 3) / 5) * ((m + 2) / 5) + ((n + 2) / 5) * ((m + 3) / 5) +
((n + 1) / 5) * ((m + 4) / 5)
<< endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int tt, n, i, j, k, l, m, ma[505], mi, h[505], t[505], no, p, aa, bb, dp[305];
int a[201010], b[201010], v[201010], d[2010][2020], sx;
string ans, s;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
cin >> m;
for (i = 1; i <= m; i++) {
cin >> k;
if (k == 1) {
cin >> l >> j;
a[l] = j;
b[l] = i;
} else {
cin >> v[i];
}
}
for (i = m - 1; i >= 1; i--) {
v[i] = max(v[i + 1], v[i]);
}
for (i = 1; i <= n; i++) {
cout << max(a[i], v[b[i] + 1]) << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 3e5 + 10;
const long long mod = 1e9 + 7;
long long pw(long long a, long long b, long long md = mod) {
long long res = 1;
while (b) {
if (b & 1) {
res = (a * res) % md;
}
a = (a * a) % md;
b >>= 1;
}
return (res);
}
const int sq = 400;
int n, m, q;
vector<pair<int, int> > seg[maxn];
struct tr {
int a, b, c;
friend bool operator<(tr a, tr b) {
return make_pair(pair<int, int>(a.a, a.b), a.c) <
make_pair(pair<int, int>(b.a, b.b), b.c);
}
};
vector<tr> block[sq];
deque<int> dq[sq];
multiset<int> st;
bool chk(int i, int l, int r) {
int pos = lower_bound(seg[i].begin(), seg[i].end(), pair<int, int>(l, 0)) -
seg[i].begin();
if (pos == int(seg[i].size())) return 0;
return seg[i][pos].second <= r;
}
void build(int i) {
sort(block[i].begin(), block[i].end());
st.clear();
for (int i = 0; i < sq; i++) dq[i].clear();
for (int l = 0, r = 0; l < int(block[i].size()); l++) {
while (r < int(block[i].size()) and int(st.size()) < sq) {
tr x = block[i][r++];
dq[x.c % sq].push_back(x.b);
if (int(dq[x.c % sq].size()) == 1) st.insert(x.b);
}
if (int(st.size()) < sq)
seg[n + i].push_back(pair<int, int>(block[i][l].a, 1e9 + 10));
else
seg[n + i].push_back(pair<int, int>(block[i][l].a, *st.rbegin()));
int v = block[i][l].c % sq;
st.erase(st.find(dq[v].front()));
dq[v].pop_front();
if (!dq[v].empty()) st.insert(dq[v].front());
}
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> q >> m;
for (int i = 1; i <= m; i++) {
int l, r, x;
cin >> l >> r >> x;
x--;
seg[x].push_back({l, r});
}
for (int i = 0; i < n; i++) {
sort(seg[i].begin(), seg[i].end());
for (int j = int(seg[i].size()) - 2; j >= 0; j--)
seg[i][j].second = min(seg[i][j].second, seg[i][j + 1].second);
for (auto [l, r] : seg[i]) block[i / sq].push_back({l, r, i});
}
for (int i = 0; i < sq; i++) build(i);
while (q--) {
int l, r, a, b;
cin >> a >> b >> l >> r;
a--;
bool ok = 1;
while (ok and a < b and a % sq) ok &= chk(a, l, r), a++;
while (ok and a < b and b % sq) b--, ok &= chk(b, l, r);
while (ok and a < b) ok &= chk(n + a / sq, l, r), a += sq;
cout << ((ok) ? "yes" : "no") << endl;
}
return (0);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, T, cnt, top, m;
struct poi {
int x, y;
poi() {}
poi(int x, int y) : x(x), y(y) {}
friend bool operator==(const poi &r1, const poi &r2) {
return r1.x == r2.x && r1.y == r2.y;
}
friend bool operator<(const poi &r1, const poi &r2) {
if (r1.x == r2.x) return r1.y < r2.y;
return r1.x < r2.x;
}
friend int operator^(const poi &r1, const poi &r2) {
return r1.x * r2.y - r2.x * r1.y;
};
friend poi operator-(const poi &r1, const poi &r2) {
return poi(r1.x - r2.x, r1.y - r2.y);
};
} a[810000], st[810000], b[810000];
int xl[810000], xr[810000], yl[810000], yr[810000];
int onleft(poi p1, poi p2, poi p3) { return ((p1 - p2) ^ (p3 - p2)) >= 0; }
int check(int x, int y) {
for (int i = 0; i <= 1; i++)
for (int j = 0; j <= 1; j++)
if (xl[y + j] > x + i || xr[y + j] < x + i || yl[x + i] > y + j ||
yr[x + i] < y + j)
return 0;
return 1;
}
int main() {
memset(xl, 0x3f, sizeof(xl));
memset(yl, 0x3f, sizeof(yl));
while (scanf("%d%d", &n, &m) != EOF && n) {
top = 0;
cnt = 0;
for (int i = 1, x, y; i <= m; i++) {
scanf("%d%d", &x, &y);
b[i] = poi(x, y);
xl[y] = min(xl[y], x);
xr[y] = max(xr[y], x);
yl[x] = min(yl[x], y);
yr[x] = max(yr[x], y);
}
for (int i = 1; i <= m; i++)
for (int j = 0; j <= 1; j++)
for (int k = 0; k <= 1; k++)
if (check(b[i].x - j, b[i].y - k))
a[++cnt] = poi(b[i].x - j, b[i].y - k);
sort(a + 1, a + 1 + cnt);
cnt = unique(a + 1, a + 1 + cnt) - a - 1;
for (int i = 1; i <= cnt; i++) {
while (top >= 2 && onleft(st[top], st[top - 1], a[i])) top--;
st[++top] = a[i];
}
int t = top;
for (int i = cnt - 1; i >= 1; i--) {
while (top > t && onleft(st[top], st[top - 1], a[i])) top--;
st[++top] = a[i];
}
printf("%d\n", top - 1);
for (int i = 1; i < top; i++) printf("%d %d\n", st[i].x, st[i].y);
for (int i = 1, x, y; i <= m; i++) {
x = b[i].x;
y = b[i].y;
xl[y] = 1 << 30;
xr[y] = 0;
yl[x] = 1 << 30;
yr[x] = 0;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int t, n;
int a[200001];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
bool flag = false;
for (int i = 2; i <= n; i++)
if (abs(a[i] - a[i - 1]) > 1) {
flag = true;
printf("YES\n");
printf("%d %d\n", i - 1, i);
break;
}
if (!flag) printf("NO\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int d = 0, arr[10005], m, n, a, b, c;
int main() {
cin >> m >> n;
while (n--) {
cin >> a >> b >> c;
arr[a] += c;
arr[b] += (-1) * c;
}
for (int i = 0; i < 10005; i++) {
if (arr[i] < 0) d -= arr[i];
}
cout << d;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int T, N, K = 1, root = 1, t[1000010][26], k, dp[1000010][2];
vector<int> g[1000010];
bool v[1000010];
void insert(int &nod, string &s, int p) {
if (nod == 0) {
nod = ++K;
g[nod].clear();
memset(t[nod], 0, sizeof(t[nod]));
}
if (p == (int)s.length()) return;
insert(t[nod][s[p] - 'a'], s, p + 1);
}
void gete(int nod, int o) {
if (o == 0) return;
if (o != 1) {
g[nod].push_back(o);
g[o].push_back(nod);
}
for (int i = 0; i < 26; i++)
if (t[nod][i] != 0) gete(t[nod][i], t[o][i]);
}
void dfs(int nod, int f) {
v[nod] = 1;
dp[nod][0] = dp[nod][1] = 0;
int s1 = 0, s2 = 0;
for (int nxt : g[nod]) {
if (nxt == f) continue;
dfs(nxt, nod);
s1 += dp[nxt][0], s2 += dp[nxt][1];
}
dp[nod][1] = s1;
dp[nod][0] = max(1 + s2, s1);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> T;
int i;
for (int k = 1; k <= T; k++) {
cin >> N;
K = 1, root = 1;
g[1].clear();
for (i = 0; i < 26; i++) t[1][i] = 0;
for (i = 1; i <= N; i++) {
string s;
cin >> s;
insert(root, s, 0);
}
for (i = 0; i < 26; i++)
if (t[1][i] != 0) gete(t[1][i], 1);
for (i = 1; i <= K; i++) v[i] = 0;
int res = 0;
for (i = 2; i <= K; i++)
if (!v[i]) {
dfs(i, 0);
res += dp[i][0];
}
cout << res << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
if (n <= 2) {
for (int i = 0; (i) < (int)(n); (i)++) {
printf("%d %d\n", i, 0);
}
return 0;
}
n *= 2;
int w = n / 3;
int h = (int)((n + w - 1) / w);
n /= 2;
int c = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (i & 1) {
if (j & 1) {
printf("%d %d\n", i, j);
c++;
if (c == n) {
exit(0);
}
}
} else {
if (j % 2 == 0) {
printf("%d %d\n", i, j);
c++;
if (c == n) {
exit(0);
}
}
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
class union_find {
public:
vector<int> arr;
union_find(int n) {
arr.resize(n);
fill(arr.begin(), arr.end(), -1);
}
int find(int x) { return arr[x] < 0 ? x : arr[x] = find(arr[x]); }
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
if (arr[x] > arr[y]) swap(x, y);
arr[x] += arr[y];
arr[y] = x;
}
bool connected(int x, int y) { return find(x) == find(y); }
int size(int x) { return -arr[find(x)]; }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tt;
cin >> tt;
while (tt--) {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> b(m);
for (int i = 0; i < m; i++) cin >> b[i];
union_find uf(n);
for (int i = 0; i < m; i++) {
uf.unite(b[i], b[i] - 1);
}
for (int i = 0; i < n; i++) {
int j = i;
while (j < n && uf.connected(i, j)) j++;
j--;
vector<int> c;
for (int k = i; k <= j; k++) {
c.push_back(a[k]);
}
sort(c.begin(), c.end());
for (int k = i; k <= j; k++) {
a[k] = c[k - i];
}
i = j;
}
bool bo = true;
for (int i = 1; i < n; i++) {
if (a[i] < a[i - 1]) bo = false;
}
if (bo)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const char nl = '\n';
string g[60];
vector<vector<bool> > vs(60, vector<bool>(60));
long long X1, Y1, X2, Y2, N;
const int dx[4] = {0, 0, -1, 1};
const int dy[4] = {-1, 1, 0, 0};
set<pair<long long, long long> > s1, s2;
void dfs1(long long ux, long long uy) {
if (min(ux, uy) < 0 or max(ux, uy) >= N or g[ux][uy] == '1' or vs[ux][uy])
return;
s1.insert({ux, uy});
vs[ux][uy] = 1;
for (int i = 0; i < 4; i++) {
long long vx = ux + dx[i], vy = uy + dy[i];
dfs1(vx, vy);
}
}
void dfs2(long long ux, long long uy) {
if (min(ux, uy) < 0 or max(ux, uy) >= N or g[ux][uy] == '1' or vs[ux][uy])
return;
s2.insert({ux, uy});
vs[ux][uy] = 1;
for (int i = 0; i < 4; i++) {
long long vx = ux + dx[i], vy = uy + dy[i];
dfs2(vx, vy);
}
}
void solve() {
long long i, j, k, l, n, r, m, u, v, x, y;
cin >> n >> X1 >> Y1 >> X2 >> Y2;
N = n;
for (i = 0; i < n; i++) cin >> g[i];
dfs1(X1 - 1, Y1 - 1);
if (s1.count({X2 - 1, Y2 - 1})) {
cout << 0 << nl;
return;
}
dfs2(X2 - 1, Y2 - 1);
long long ans = 1e16;
for (auto [x1, y1] : s1) {
for (auto [x2, y2] : s2) {
ans = min(ans, (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}
}
cout << ans << nl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1, i = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
struct sc {
long long c, p;
};
vector<sc> l[maxn];
long long n, k, m, M = 1, ma = 0, li, ri, ci, pi;
long long num[maxn << 2], sum[maxn << 2];
void update(long long p, long long c) {
num[M + p] += (long long)c;
sum[M + p] += (long long)c * p;
int j = M + p;
while (j >>= 1) {
sum[j] = sum[j << 1] + sum[j << 1 | 1];
num[j] = num[j << 1] + num[j << 1 | 1];
}
}
long long ok(long long s, long long t) {
long long ss = 0;
long long tt = t;
for (s += (M - 1), t += (M + 1); s ^ t ^ 1; s >>= 1, t >>= 1) {
if (s % 2 == 0) ss += num[s ^ 1];
if (t % 2 == 1) ss += num[t ^ 1];
}
if (ss >= k)
return ss;
else
return 0;
}
long long q() {
long long s = 1, t = ma, ans = ma;
while (s <= t) {
long long mid = (s + t) / 2;
if (!ok(1, mid)) {
s = mid + 1;
} else {
ans = mid;
t = mid - 1;
}
}
s = 1, t = ans;
long long ss = 0;
for (s += (M - 1), t += (M + 1); s ^ t ^ 1; s >>= 1, t >>= 1) {
if (s % 2 == 0) ss += sum[s ^ 1];
if (t % 2 == 1) ss += sum[t ^ 1];
}
if (ok(1, ans) <= k) return ss;
return ss - ans * (ok(1, ans) - k);
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k >> m;
for (int i = 0; i < m; i++) {
cin >> li >> ri >> ci >> pi;
l[li].push_back({ci, pi});
l[ri + 1].push_back({-ci, pi});
ma = max(pi, ma);
}
long long ans = 0;
while (M <= ma) M <<= 1;
for (long long i = 1; i <= n; i++) {
for (int j = 0; j < l[i].size(); j++) update(l[i][j].p, l[i][j].c);
ans += q();
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long ast[1000009];
long long pos[1000009];
long long val[1000009];
long long power(long long a, long long b) {
long long r = 1;
while (b != 0) {
if (b % 2 != 0) {
r = r * a;
r %= 1000000007;
}
a = a * a;
a = a % 1000000007;
b = b / 2;
}
return r;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
long long n, m, k, cr = 0, mm = 0;
cin >> n >> m >> k;
long long ast[m + 1], pos[n + 1];
pos[0] = 0;
for (int i = 1; i <= m; i++) {
cin >> ast[i];
pos[ast[i]] = -1;
}
long long val[k + 1];
for (int j = 1; j <= k; j++) {
cin >> val[j];
}
if (pos[0] == -1) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i < n; i++) {
if (pos[i] == -1) {
mm = max(mm, i - cr);
pos[i] = cr;
} else {
cr = i;
pos[i] = i;
}
}
long long ans = 1e18, v = 0;
if ((mm + 1) > k) {
cout << -1 << endl;
return 0;
}
for (int i = (mm + 1); i <= k; i++) {
long long j = 0;
v = 0;
while (j < n) {
if (pos[j] == j) {
v += val[i];
j = j + i;
} else {
v += val[i];
j = pos[j];
j = j + i;
}
}
ans = min(ans, v);
}
cout << ans << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s[2], in[2];
cin >> s[0] >> s[1];
cin >> n;
cout << s[0] << " " << s[1] << endl;
for (int i = 0; i < n; i++) {
cin >> in[0] >> in[1];
if (s[0] == in[0]) {
s[0] = in[1];
} else {
s[1] = in[1];
}
cout << s[0] << " " << s[1] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int)1e9 + 23111992;
const long long LINF = (long long)1e18 + 23111992;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline unsigned long long isqrt(unsigned long long k) {
unsigned long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() { return abs((int)mt()); }
void chemthan() {
vector<long long> vals;
vals.push_back(0);
for (int i1 = (0); i1 < (32); ++i1)
for (int i2 = (i1); i2 < (32); ++i2)
for (int i3 = (i2); i3 < (32); ++i3)
for (int i4 = (i3); i4 < (32); ++i4)
for (int i5 = (i4); i5 < (32); ++i5) {
int ar[] = {i1, i2, i3, i4, i5};
for (int k = (1); k < (5 + 1); ++k) {
long long r = 0;
for (int msk = (1); msk < (1 << k); ++msk) {
int t = 0;
for (int i = (0); i < (k); ++i)
if ((((msk) >> (i)) & 1)) {
t ^= ar[i];
}
r |= 1LL << t;
}
vals.push_back(r);
}
}
vals.push_back((1LL << 32) - 1);
sort((vals).begin(), (vals).end()),
(vals).erase(unique((vals).begin(), (vals).end()), (vals).end());
vector<vector<int> > g(int((vals).size()), vector<int>(int((vals).size())));
for (int i = (0); i < (int((vals).size())); ++i)
for (int j = (0); j < (int((vals).size())); ++j) {
long long x = vals[i];
long long y = vals[j];
long long z = x | y;
for (int u = (0); u < (32); ++u)
if ((((x) >> (u)) & 1)) {
for (int v = (0); v < (32); ++v)
if ((((y) >> (v)) & 1)) {
z |= 1LL << (u ^ v);
}
}
g[i][j] = lower_bound((vals).begin(), (vals).end(), z) - vals.begin();
assert(g[i][j] < int((vals).size()) && vals[g[i][j]] == z);
}
auto find_ix = [&](long long x) {
int k = lower_bound((vals).begin(), (vals).end(), x) - vals.begin();
assert(k < int((vals).size()) && vals[k] == x);
return k;
};
auto merge = [&](long long x, long long y) {
int ix = find_ix(x);
int iy = find_ix(y);
return vals[g[ix][iy]];
};
int n, m;
cin >> n >> m;
vector<vector<pair<int, int> > > adj(n);
vector<int> a(n), dj(n);
vector<long long> b(n);
for (int i = (0); i < (n); ++i) dj[i] = i;
function<int(int)> find = [&](int u) {
return dj[u] == u ? dj[u] : dj[u] = find(dj[u]);
};
auto join = [&](int u, int v) {
u = find(u);
v = find(v);
if (u ^ v) {
dj[u] = v;
b[v] = merge(b[v], b[u]);
}
};
map<pair<int, int>, int> hs;
for (int i = (0); i < (m); ++i) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
adj[u].push_back({v, w});
adj[v].push_back({u, w});
hs[make_pair(u, v)] = hs[make_pair(v, u)] = w;
}
map<pair<int, int>, int> mem;
vector<int> vis(n);
function<void(int, int)> dfs = [&](int u, int p) {
vis[u] = 1;
for (auto e : adj[u]) {
int v = e.first;
int w = e.second;
if (!v) continue;
if (!vis[v]) {
a[v] = a[u] ^ w;
join(u, v);
dfs(v, u);
} else if (v != p) {
auto& bb = b[find(u)];
if (!mem.count(make_pair(u, v))) {
bb = merge(bb, 1LL << (a[u] ^ a[v] ^ w));
mem[make_pair(u, v)] = mem[make_pair(v, u)] = 1;
}
}
}
};
for (int u = (1); u < (n); ++u)
if (!vis[u]) {
dfs(u, -1);
}
map<int, long long> hs2;
for (auto e : adj[0]) {
int v = e.first;
int w = e.second;
for (auto e2 : adj[v]) {
int v2 = e2.first;
int w2 = e2.second;
if (v < v2 && hs.count(make_pair(v2, 0))) {
hs2[find(v)] = 1LL << (w ^ w2 ^ hs[make_pair(v2, 0)]);
}
}
}
vector<int> dp(int((vals).size()));
dp[0] = 1;
for (int i = (1); i < (n); ++i)
if (dj[i] == i) {
long long x = b[i];
long long y = hs2.count(i) ? hs2[i] : -1LL;
int cx = 1;
if (y != -1) {
y = merge(x, y);
cx = 2;
}
vector<int> ndp = dp;
int xx = find_ix(x);
int yy = y != -1 ? find_ix(y) : -1;
for (int j = (0); j < (int((vals).size())); ++j)
if (dp[j]) {
int ix = g[xx][j];
addmod(ndp[ix], mult(dp[j], cx));
if (y != -1) {
int iy = g[yy][j];
addmod(ndp[iy], dp[j]);
}
}
dp = ndp;
}
int res = 0;
for (int i = (0); i < (int((vals).size())); ++i)
if (!(((vals[i]) >> (0)) & 1)) {
addmod(res, dp[i]);
}
cout << res << "\n";
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
chemthan();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e15;
long long memo[105][105][105];
int n, m, k, c[105], p[105][105];
long long dp(int x, int y, int z) {
if (x == 0 && y < 0) return 0;
if (x < 0 || y < 0) return INF;
if (memo[x][y][z] == -1) {
long long temp = INF;
if (c[y] == 0) {
for (int i = 1; i <= m; i++) {
if (i == z)
temp = min(dp(x, y - 1, i) + (long long)p[y][i], temp);
else
temp = min(dp(x - 1, y - 1, i) + (long long)p[y][i], temp);
}
} else {
if (c[y] == z)
temp = min(dp(x, y - 1, c[y]), temp);
else
temp = min(dp(x - 1, y - 1, c[y]), temp);
}
memo[x][y][z] = temp;
}
return memo[x][y][z];
}
int main() {
memset(memo, -1, sizeof(memo));
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &c[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &p[i][j]);
}
}
long long ans = dp(k, n - 1, 101);
if (ans >= INF)
printf("-1");
else
printf("%I64d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 1000 + 21;
const int maxl = 21;
long long n, a[maxn], tmp;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
for (int j = maxl - 1; j >= 0; j--)
if (i + (1 << j) < n) {
tmp += a[i];
a[i + (1 << j)] += a[i];
a[i] = 0;
}
cout << tmp << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e9 + 7;
signed main() {
long long n;
cin >> n;
long long a[n], b[n], x[2], y[2];
x[0] = y[0] = maxn;
x[1] = y[1] = -maxn;
multiset<long long> v, d;
long long sum = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i] >> b[i];
v.insert(a[i]);
d.insert(b[i]);
x[0] = min(x[0], a[i]);
y[0] = min(y[0], b[i]);
x[1] = max(x[1], a[i]);
y[1] = max(y[1], b[i]);
}
for (long long i = 0; i < n; i++) {
v.erase(v.find(a[i]));
d.erase(d.find(b[i]));
sum = max(sum, *v.rbegin() - a[i] + *d.rbegin() - b[i]);
sum = max(sum, *v.rbegin() - a[i] - *d.begin() + b[i]);
sum = max(sum, -*v.begin() + a[i] + *d.rbegin() - b[i]);
sum = max(sum, -*v.begin() + a[i] - *d.begin() + b[i]);
v.insert(a[i]);
d.insert(b[i]);
}
cout << sum * 2 << " ";
for (long long i = 4; i <= n; i++) {
cout << 2 * (x[1] + y[1] - x[0] - y[0]) << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long modexp(long long b, long long e) {
if (e == 0) return 1;
long long ans = modexp(b, e / 2);
ans = (ans * ans) % 1000000007;
if (e % 2) ans = (ans * b) % 1000000007;
return ans;
}
long long inv(long long a) { return modexp(a, 1000000007 - 2); }
long long calcdp(long long as, long long abs, long long k, long long pbab,
vector<vector<long long>>& dp) {
long long paab = (1000000007 + 1 - pbab) % 1000000007;
if (abs >= k) return abs;
if (dp[as][abs] != -1) return dp[as][abs];
dp[as][abs] = 0;
dp[as][abs] += paab * calcdp(as + 1, abs, k, pbab, dp);
dp[as][abs] %= 1000000007;
dp[as][abs] += pbab * calcdp(as, abs + as, k, pbab, dp);
dp[as][abs] %= 1000000007;
return dp[as][abs];
}
int main() {
long long k, pa, pb;
cin >> k >> pa >> pb;
vector<vector<long long>> dp(k + 1, vector<long long>(k + 1, -1));
long long pbab = (pb * inv(pa + pb)) % 1000000007;
for (int i = 0; i < (int)(k + 1); ++i) {
dp[k][i] = (1000000007 + k + i - 1 + inv(pbab)) % 1000000007;
}
cout << calcdp(1, 0, k, pbab, dp) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> insertVector(int n) {
vector<int> x;
for (int i = 0; i < n; i++) {
int y;
cin >> y;
x.push_back(y);
}
return x;
}
void displayVector(vector<int> x) {
for (auto i : x) cout << i << " ";
cout << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int x = n % 4;
if (x == 1)
cout << 0 << " "
<< "A";
else if (x == 2) {
cout << 1 << " "
<< "B";
} else if (x == 3) {
cout << 2 << " "
<< "A";
} else
cout << 1 << " "
<< "A";
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize(2)
using namespace std;
const int N = 2e5 + 10;
const int M = 2e5 + 100;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int n, m, k, x, y, t;
vector<int> v[2];
char s[M];
int a[M];
void solve() {
scanf("%d", &n);
scanf("%s", s);
int id = 0;
v[0].clear(), v[1].clear();
for (int i = 0; i < n; ++i) {
int x = (s[i] - '0') ^ 1;
if (v[x].empty()) {
v[x ^ 1].push_back(++id);
a[i] = id;
} else {
int k = v[x].back();
v[x].pop_back();
a[i] = k;
v[x ^ 1].push_back(k);
}
}
printf("%d\n", id);
for (int i = 0; i < n - 1; ++i) printf("%d ", a[i]);
printf("%d\n", a[n - 1]);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int T = 1;
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
cout << a * b / 2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, e, f[100005], g[100005], h[100005], i, j, top;
struct node {
long long x, y;
friend bool operator<(const node &x, const node &y) {
return x.x < y.x || (x.x == y.x && x.y < y.y);
}
};
struct node G[100005];
long long low, high, mid;
long long an1, an2;
int main() {
scanf("%I64d", &a);
for (i = 1; i <= a; i++) scanf("%I64d%I64d", &g[i], &h[i]);
scanf("%I64d", &b);
for (i = 1; i <= a; i++) {
G[i].x = b * h[i] - g[i];
G[i].y = b * h[i] + g[i];
}
sort(G + 1, G + a + 1);
for (i = 1; i <= a; i++) {
if (top == 0 || G[i].y >= f[top]) {
f[++top] = G[i].y;
continue;
}
low = 1;
high = top;
e = 0;
while (low <= high) {
mid = (low + high) >> 1;
if (G[i].y >= f[mid]) {
if (mid > e) e = mid;
low = mid + 1;
} else
high = mid - 1;
}
f[e + 1] = G[i].y;
}
an2 = top;
top = 0;
G[a + 1].x = 0;
G[a + 1].y = 0;
sort(G + 1, G + a + 1 + 1);
i = 1;
while (G[i].x != 0 || G[i].y != 0) i++;
i++;
for (; i <= a + 1; i++)
if (G[i].y >= 0) {
if (top == 0 || G[i].y >= f[top]) {
f[++top] = G[i].y;
continue;
}
low = 1;
high = top;
e = 0;
while (low <= high) {
mid = (low + high) >> 1;
if (G[i].y >= f[mid]) {
if (mid > e) e = mid;
low = mid + 1;
} else
high = mid - 1;
}
f[e + 1] = G[i].y;
}
an1 = top;
printf("%I64d %I64d\n", an1, an2);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
template <class T>
inline T biton(T n, T pos) {
return n | ((T)1 << pos);
}
template <class T>
inline T bitoff(T n, T pos) {
return n & ~((T)1 << pos);
}
template <class T>
inline T ison(T n, T pos) {
return (bool)(n & ((T)1 << pos));
}
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
inline int nxt() {
int aaa;
scanf("%d", &aaa);
return aaa;
}
inline long long int lxt() {
long long int aaa;
scanf("%lld", &aaa);
return aaa;
}
inline double dxt() {
double aaa;
scanf("%lf", &aaa);
return aaa;
}
template <class T>
inline T bigmod(T p, T e, T m) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
}
return (T)ret;
}
int ar[1000010];
int mark[1000010];
int main() {
int n = nxt();
int k = nxt();
int mn = (1e9) + 1000;
for (int i = 0; i < n; i++) {
ar[i] = nxt();
mn = min(mn, ar[i]);
mark[ar[i]]++;
}
sort(ar, ar + n);
for (int i = 1; i <= ar[n - 1]; i++) {
mark[i] += mark[i - 1];
}
int ans = (1e9) + 1000;
for (int i = mn; i >= 2; i--) {
bool f = 0;
int cnt = 0;
int last = i - 1;
for (int j = i; j <= ar[n - 1]; j += i) {
int up = min(j + k, j + i - 1);
up = min(up, ar[n - 1]);
cnt += mark[up] - mark[j - 1];
}
if (cnt == n) {
printf("%d\n", i);
return 0;
}
}
cout << 1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long sum = 0, sum1, a;
vector<long long> v(n);
vector<int> ans;
map<long long, set<int> > mp;
for (int i = 0; i < n; i++) {
cin >> a;
v[i] = a;
sum += a;
mp[a].insert(i);
}
for (int i = 0; i < n; i++) {
sum1 = sum - v[i];
if (sum1 % 2 == 0) {
if (mp.find(sum1 / 2) != mp.end()) {
if (mp[sum1 / 2].find(i) == mp[sum1 / 2].end() ||
mp[sum1 / 2].size() > 1) {
ans.push_back(i + 1);
}
}
}
}
cout << ans.size() << endl;
for (auto i : ans) {
cout << i << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec[3010];
int in[3010];
int dist[3010];
const int INF = 2000000000;
int main() {
int n, i, j, k, u, v, w;
while (scanf("%d", &n) != EOF) {
memset(in, 0, sizeof(in));
for (i = 1; i <= n; i++) {
vec[i].clear();
dist[i] = INF;
}
for (i = 0; i < n; i++) {
scanf("%d%d", &u, &v);
vec[u].push_back(v);
vec[v].push_back(u);
in[u]++;
in[v]++;
}
queue<int> que;
for (i = 1; i <= n; i++) {
if (in[i] == 1) que.push(i);
}
while (!que.empty()) {
u = que.front();
que.pop();
for (i = 0; i < vec[u].size(); i++) {
v = vec[u][i];
in[v]--;
if (in[v] == 1) que.push(v);
}
}
queue<int> q;
for (i = 1; i <= n; i++) {
if (in[i] == 2) {
dist[i] = 0;
q.push(i);
}
}
while (!q.empty()) {
u = q.front();
q.pop();
for (i = 0; i < vec[u].size(); i++) {
v = vec[u][i];
if (dist[u] + 1 < dist[v]) {
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
printf("%d", dist[1]);
for (i = 2; i <= n; i++) printf(" %d", dist[i]);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = numeric_limits<int>::max();
namespace SA {
const int MN = 100010;
int n, k, rsa[MN], tmp[MN];
bool cmp(int i, int j) {
if (rsa[i] != rsa[j]) return rsa[i] < rsa[j];
int ri = (i + k <= n) ? rsa[i + k] : -1;
int rj = (j + k <= n) ? rsa[j + k] : -1;
return ri < rj;
}
template <class S>
vector<int> build(const S &s) {
n = int(s.size());
vector<int> sa(n + 1);
for (int i = 0; i <= n; i++) {
sa[i] = i;
rsa[i] = i < n ? s[i] : -1;
}
for (k = 1; k <= n; k *= 2) {
sort(sa.begin(), sa.end(), cmp);
tmp[sa[0]] = 0;
for (int i = 1; i <= n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + int(cmp(sa[i - 1], sa[i]));
}
copy(tmp, tmp + n + 1, rsa);
}
return sa;
}
} // namespace SA
template <class S>
pair<int, int> match(const S &s, const S &t, const vector<int> &sa) {
int n = int(s.size()), m = int(t.size());
pair<int, int> ans;
int lw, hi;
lw = 0;
hi = n + 1;
while (hi - lw > 1) {
int mi = (lw + hi) / 2;
if (s.compare(sa[mi], m, t) < 0) {
lw = mi;
} else {
hi = mi;
}
}
ans.first = hi;
lw = 0;
hi = n + 1;
while (hi - lw > 1) {
int mi = (lw + hi) / 2;
if (s.compare(sa[mi], m, t) <= 0) {
lw = mi;
} else {
hi = mi;
}
}
ans.second = hi;
return ans;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
vector<int> sa = SA::build(s);
int q;
cin >> q;
for (int ph = 0; ph < q; ph++) {
int k;
string m;
cin >> k >> m;
pair<int, int> u = match(s, m, sa);
vector<int> v;
for (int i = u.first; i < u.second; i++) {
v.push_back(sa[i]);
}
sort(v.begin(), v.end());
int n = int(v.size());
if (n < k) {
cout << -1 << '\n';
continue;
}
int ans = INF;
for (int i = 0; i <= n - k; i++) {
ans = min(ans, v[i + k - 1] - v[i] + int(m.size()));
}
cout << ans << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 2e6 + 9;
long long mod = 1e9 + 7;
long long add(long long a, long long b) { return ((a + b) % mod + mod) % mod; }
long long sub(long long a, long long b) { return ((a - b) % mod + mod) % mod; }
long long mul(long long a, long long b) {
a %= mod;
b %= mod;
return (a * b) % mod;
}
long long fast(long long a, long long b) {
if (b == 0) return 1;
long long x = fast(a, b / 2);
long long ret = mul(x, x);
if (b & 1) return mul(a, ret);
return ret;
}
int is_prime[MAXN], u[MAXN];
int d[MAXN];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
is_prime[1] = 1;
for (int i = 1; i < MAXN; i++) u[i] = 1;
for (int i = 2; i < MAXN; i++) {
if (!is_prime[i]) {
u[i] = -1;
is_prime[i] = i;
for (int j = 2 * i; j < MAXN; j += i)
is_prime[j] = i, u[j] = (j % (i * 1LL * i)) ? -u[j] : 0;
}
}
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
for (long long j = 1; j * j <= x; j++) {
if (x % j == 0) {
long long a = x / j;
if (a != j) d[a]++;
d[j]++;
}
}
}
long long ans = sub(fast(2, n), 1);
for (int i = 2; i < MAXN; i++) {
if (d[i] == 0) continue;
long long x = sub(fast(2, d[i]), 1);
ans = add(ans, u[i] * x);
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i].first;
a[i].second = i;
}
sort(a.begin(), a.end());
if (k > n) {
cout << "NO\n";
return 0;
}
vector<int> ans(n);
int color = 0, cnt = 0;
for (int i = 0; i < n; i++) {
++cnt;
if (cnt > k) {
cout << "NO\n";
return 0;
}
ans[a[i].second] = color;
color = (color + 1) % k;
if (i + 1 < n && a[i].first != a[i + 1].first) {
cnt = 0;
}
}
cout << "YES\n";
for (int i = 0; i < n; ++i) {
cout << ans[i] + 1 << " ";
}
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int tot = 1, n, m;
int dfsclk, fst[200005], pnt[200005], bian, e[200005][2], blg[200005],
edg[200005], fa[200005], len[200005], gol, sum[200005], ss[200005],
c[200005], ans;
bool bo[200005];
int nxt[200005], d[200005], h[200005], cnt, vis[200005];
bool ok[200005];
void add(int x, int y, int z) {
pnt[++tot] = y;
nxt[tot] = fst[x];
len[tot] = z;
fst[x] = tot;
}
void dfs(int x, int last) {
vis[x] = ++dfsclk;
for (int i = fst[x]; i; i = nxt[i])
if (i != (last ^ 1)) {
int y = pnt[i];
if (!vis[y]) fa[y] = x, edg[y] = i, dfs(y, i);
}
for (int i = fst[x]; i; i = nxt[i])
if (i != (last ^ 1)) {
int y = pnt[i];
if (fa[y] != x && vis[x] < vis[y]) {
blg[i >> 1] = ++cnt;
for (; y != x; y = fa[y]) blg[edg[y] >> 1] = cnt;
}
}
}
bool bfs() {
int l = 0, r = 1;
h[1] = 0;
memset(d, -1, sizeof(d));
d[0] = 1;
while (l < r) {
int x = h[++l], p;
for (p = fst[x]; p; p = nxt[p])
if (len[p]) {
int y = pnt[p];
if (d[y] == -1) {
d[y] = d[x] + 1;
h[++r] = y;
}
}
}
return d[gol] != -1;
}
int dfs1(int x, int rst) {
if (x == gol || !rst) return rst;
int p, flow = 0;
for (p = fst[x]; p; p = nxt[p])
if (len[p]) {
int y = pnt[p];
if (d[x] + 1 != d[y]) continue;
int tmp = dfs1(y, min(rst, len[p]));
if (!tmp) continue;
flow += tmp;
len[p] -= tmp;
len[p ^ 1] += tmp;
rst -= tmp;
if (!rst) break;
}
if (!flow) d[x] = -1;
return flow;
}
void dinic(int x) {
while (bfs()) ans += dfs1(0, 1e9);
}
int main() {
n = read();
m = read();
int x, y, z;
for (int i = 1; i <= m; i++) {
x = read();
y = read();
z = read();
c[i] = z;
add(x, y, 0);
add(y, x, 0);
if (!vis[z]) {
vis[z] = 1;
ans++;
}
}
memset(vis, 0, sizeof(vis));
dfs(1, 0);
memset(fst, 0, sizeof(fst));
for (int i = 1; i <= m; i++)
if (!blg[i])
ok[c[i]] = 1;
else
nxt[i] = fst[blg[i]], fst[blg[i]] = i;
for (int i = 1; i <= cnt; i++) {
for (int j = fst[i]; j; j = nxt[j]) {
sum[c[j]]++;
if (sum[c[j]] == 2 || ok[c[j]]) {
bo[i] = 1;
break;
}
}
for (int j = fst[i]; j; j = nxt[j]) sum[c[j]] = 0;
if (!bo[i]) {
ans--;
for (int j = fst[i]; j; j = nxt[j]) {
ss[c[j]]++;
e[++bian][0] = i;
e[bian][1] = c[j] + cnt;
}
} else
for (int j = fst[i]; j; j = nxt[j])
if (ss[c[j]] < 1000000000) ss[c[j]] = 1000000000;
}
memset(fst, 0, sizeof(fst));
tot = 1;
for (int i = 1; i <= bian; i++)
add(e[i][0], e[i][1], 1), add(e[i][1], e[i][0], 0);
for (int i = 1; i <= cnt; i++)
if (!bo[i]) add(0, i, 1), add(i, 0, 0);
gol = cnt + m + 1;
for (int i = 1; i <= m; i++)
if (ss[i] > 1) add(i + cnt, gol, ss[i] - 1), add(gol, i + cnt, 0);
while (bfs()) ans += dfs1(0, 1000000000);
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
int n = a.size();
int m = b.size();
sort(a.begin(), a.end());
sort(b.begin(), b.end());
int i = 0;
int j = 0;
int s = 0;
int x = 1;
for (int q = 0; q <= m - 1; q++) {
if (x == 1) {
x = 0;
for (int w = 0; w <= n - 1; w++) {
if (a[w] == b[q]) {
x = 1;
}
}
}
}
if (x == 1) {
while ((i <= n - 1) && (j <= m - 1)) {
if (a[i] == b[j]) {
s++;
i++;
j++;
} else {
if (a[i] < b[j]) {
i++;
} else {
j++;
}
}
}
if (s == 0) {
cout << -1;
} else {
cout << s;
}
} else
cout << -1;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int b[6][6];
int main() {
int a[30];
char ch[10];
int sum = 0;
int max;
b[1][6] = 1;
b[2][5] = 1;
b[2][3] = 2;
b[2][4] = 2;
b[3][2] = 6;
b[3][3] = 3;
b[3][4] = 2;
b[4][3] = 5;
b[4][2] = 8;
b[5][2] = 15;
b[6][1] = 30;
memset(a, 0, sizeof(a));
scanf("%s", ch);
for (int i = 0; i < 6; i++) a[ch[i] - 'A']++;
max = 0;
for (int i = 0; i < 26; i++)
if (a[i] != 0) {
sum++;
if (a[i] > max) max = a[i];
}
printf("%d\n", b[sum][max]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d[200], s, t;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> d[i];
}
cin >> s >> t;
if (s == t) {
cout << 0 << endl;
return 0;
}
int i = s, sum1 = 0;
while (true) {
if (i == t) break;
sum1 += d[i];
if (i == n) i = 0;
i++;
}
int j = t, sum2 = 0;
while (true) {
if (j == s) break;
sum2 += d[j];
if (j == n) j = 0;
j++;
}
cout << min(sum1, sum2) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int maxn = 1e5 + 5;
const double EPS = 1e-6;
using namespace std;
map<long long, long long> mp;
long long a[maxn];
int mod(long long x, int p) { return x >= p ? x % p + p : x; }
long long kpow(long long a, long long b, long long p) {
long long ret = 1;
while (b) {
if (b & 1) ret = mod(ret * a, p);
b >>= 1;
a = mod(a * a, p);
}
return ret;
}
long long phi(long long k) {
long long s = k, kk = k;
if (mp.count(k)) return mp[k];
for (long long i = 2; i * i <= k; i++) {
if (k % i == 0) s = s / i * (i - 1);
while (k % i == 0) k /= i;
}
if (k > 1) s = s / k * (k - 1);
return mp[kk] = s;
}
long long solve(int l, int r, long long p) {
if (p == 1) return a[l] % p + p;
if (l == r) return mod(a[l], p);
return kpow(a[l], solve(l + 1, r, phi(p)), p);
}
int main() {
int n, q;
long long p;
scanf("%d%lld", &n, &p);
for (int i = 1; i < (n + 1); ++i) scanf("%lld", &a[i]);
scanf("%d", &q);
int l, r;
for (int i = 0; i < (q); ++i) {
scanf("%d%d", &l, &r);
printf("%lld\n", solve(l, r, p) % p);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool comp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first) return a.second < b.second;
return a.first < b.first;
}
bool comps(const pair<int, int> &a, const pair<int, int> &b) {
if (a.second == b.second) return a.first < b.first;
return a.second < b.second;
}
bool prime[1000005];
void primeseries(long long int n) {
memset(prime, true, sizeof(prime));
for (long long int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long int i = p * p; i <= n; i += p) prime[i] = false;
}
}
}
struct custom_hash {
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
x ^= FIXED_RANDOM;
return x ^ (x >> 16);
}
};
bool compmx(int a, int b) { return (a < b); }
void fastio() {
ios::sync_with_stdio(0);
cin.tie(0);
}
void inout() {}
long long int su(long long int n) {
long long int cnt = 0;
while (n) {
cnt += n % 10;
n /= 10;
}
return cnt;
}
long long int mod = 1E9 + 7;
long long int fin(long long int a[], long long int n) {
long long int sum = 0;
vector<long long int> odd;
for (long long int i = 0; i < n / 2; i++) {
odd.push_back(a[2 * i + 1] - a[2 * i]);
sum += a[2 * i];
}
if (n % 2) sum += a[n - 1];
long long int mx = 0, push_back = INT_MIN;
for (long long int i = 0; i < (odd).size(); i++) {
if (mx < 0) {
mx = 0;
}
mx += odd[i];
push_back = max(push_back, mx);
}
if (push_back > 0) {
sum += push_back;
}
return sum;
}
vector<pair<long long int, long long int>> ans;
void nest(long long int n, long long int x, long long int y) {
if (n == 0) {
ans.push_back({x, y + 1});
ans.push_back({x + 1, y});
ans.push_back({x + 1, y + 1});
} else {
ans.push_back({x, y + 1});
ans.push_back({x + 1, y});
ans.push_back({x + 1, y + 1});
nest(n - 1, x + 1, y + 1);
}
}
char a[55][55];
bool vis[55][55];
long long int n, m;
void dfs(long long int x, long long int y) {
if (x < 0 || x >= n || y < 0 || y >= m || vis[x][y]) return;
vis[x][y] = true;
if (a[x][y] == 'G' || a[x][y] == '.') {
dfs(x - 1, y);
dfs(x + 1, y);
dfs(x, y - 1);
dfs(x, y + 1);
}
}
bool chk(string a, string b, long long int m) {
long long int cnt = 0;
for (long long int i = 0; i < m; i++) {
if (a[i] != b[i]) cnt++;
}
if (cnt <= 1)
return true;
else
return false;
}
long double fi(long double a, long double b, long double x) {
return ((x + 1) * a + x * b) / (2 * x + 1);
}
int main() {
long long int t;
cin >> t;
while (t--) {
long double a, b, t;
cin >> a >> b >> t;
long double m = (1.0) * (a + b) / 2;
if (t <= m)
cout << 2;
else {
long long int x = (a - t + 2 * t - (a + b) - 1) / (2 * t - (a + b));
long long int ans;
if (abs(t - fi(a, b, x)) <= abs(t - fi(a, b, x + 1))) {
ans = 2 * x + 1;
if (abs(t - fi(a, b, x - 1)) <= abs(t - fi(a, b, x)))
ans = 2 * (x - 1) + 1;
} else {
ans = 2 * (x + 1) + 1;
if (abs(t - fi(a, b, x - 1)) <= abs(t - fi(a, b, x + 1)))
ans = 2 * (x - 1) + 1;
}
cout << ans;
}
cout << "\n";
;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int t;
std::cin >> t;
while (t--) {
int n;
std::cin >> n;
int counter = 0;
int suffix = 0;
bool start = false;
while (n--) {
int x;
std::cin >> x;
if (x) {
suffix = 0;
start = true;
} else if (start) {
++counter;
++suffix;
}
}
std::cout << (counter - suffix) << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000002;
vector<int> primeFact[N];
int calc(int y, int x, vector<int> &a) {
int ret = 0, n = (int)(a).size();
for (int(mask) = (0); (mask) <= (int)((1 << n) - 1); (mask)++) {
int p = 1, sign = 1;
for (int(i) = (0); (i) <= (int)(n - 1); (i)++)
if (mask & (1 << i)) p *= a[i], sign *= -1;
int frst = x + (p - x % p) % p;
ret += sign * max((y - frst + p) / p, 0);
}
return ret;
}
int main() {
int t;
for (int(i) = (2); (i) <= (int)(N - 1); (i)++)
if (primeFact[i].empty()) {
for (int j = i; j < N; j += i) primeFact[j].push_back(i);
}
scanf("%d", &t);
while (t--) {
int x, p, k;
scanf("%d%d%d", &x, &p, &k);
int l = x + 1, r = 20 * N;
while (l < r) {
int mid = (l + r) >> 1;
if (k <= calc(mid, x + 1, primeFact[p]))
r = mid;
else
l = mid + 1;
}
printf("%d\n", l);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(3e5) + 10;
const int K = int(2e6) + 10;
const int MOD = int(1e9) + 7;
const int INF = int(1e9) + 5;
const long long INF64 = 2e18;
long long BIT[N];
vector<int> adj[N];
vector<pair<int, int> > queries[N];
int depth[N], n;
long long ans[N];
void update(int x, int d) {
for (; x <= n; x += x & (-x)) {
BIT[x] += 1ll * d;
}
}
void add(int l, int r, int d) {
update(l, d);
update(r + 1, -d);
}
long long query(int x) {
long long ret = 0;
for (; x > 0; x -= x & (-x)) {
ret += BIT[x];
}
return ret;
}
void dfs(int s, int e) {
depth[s] = depth[e] + 1;
for (auto q : queries[s]) {
int d = q.first;
int x = q.second;
add(depth[s], depth[s] + d, x);
}
ans[s] = query(depth[s]);
for (auto x : adj[s]) {
if (x == e) continue;
dfs(x, s);
}
for (auto q : queries[s]) {
int d = q.first;
int x = q.second;
add(depth[s], depth[s] + d, -x);
}
}
void solve() {
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
int v, d, x;
cin >> v >> d >> x;
queries[v].push_back({d, x});
}
dfs(1, 0);
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void file() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
void zuka() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long s[200005];
int main() {
zuka();
long long n, m;
cin >> n >> m;
vector<long long> v;
for (int i = 1; i <= n; i++) {
long long in;
cin >> in;
v.push_back(in);
s[i] = s[i - 1] + in;
}
for (int i = 0; i < m; i++) {
long long in;
cin >> in;
long long start = 1, end = n, mid, res = 1e10;
while (start <= end) {
mid = (start + end) / 2;
if (s[mid] >= in) {
res = min(res, mid);
end = mid - 1;
} else
start = mid + 1;
}
cout << res << ' ' << in - s[res - 1] << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int max_int = (1LL << 31) - 1;
const int max_n = 3e3 + 100;
int d[max_n][2];
int a[max_n][3];
int n;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < 3; ++i)
for (int j = 1; j <= n; ++j) cin >> a[j][i];
d[0][1] = -1e6;
for (int i = 1; i <= n; ++i) {
d[i][0] = d[i - 1][0] + a[i][(i < n)];
d[i][0] = max(d[i][0], d[i - 1][1] + a[i][1 + (i < n)]);
d[i][1] = d[i - 1][0] + a[i][0];
d[i][1] = max(d[i][1], d[i - 1][1] + a[i][1]);
}
cout << max(d[n][0], d[n][1]) << endl;
return 0;
}
| 5 |
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
//---------------------------------//
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
void hat(){
//tcT> constexpr bool needs_output_v = !is_printable_v<T> && is_iterable_v<T>;
// ts: string representation to print
long long a[0];
long long sum[0];
long long dp[0];
long long q[0];
long long minn[0];
int n,c;
scanf("%d%d",&n,&c);
for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
for(int i=1;i<=c;i++) sum[i]=sum[i-1]+a[i];
for(int i=c+1;i<=n;i++) sum[i]=sum[i-1]+a[i]-a[i-c];
for(int i=1;i<c;i++) dp[i]=dp[i-1]+a[i];
q[1]=1;
int l=1,r=1;
for(int i=1;i<=n;i++){
while(l<=r&&q[l]<=i-c) l++;
while(l<=r&&a[q[r]]>a[i]) r--;
q[++r]=i,minn[i]=a[q[l]];
}
for(int i=c;i<=n;i++){
dp[i]=min(dp[i-1]+a[i],dp[i-c]+sum[i]-minn[i]);
}
printf("%lld",dp[n]);
}
int ye_nahai(int x, char ch)
{
int n;
cin>>n;
int arr[n];
int max_ending_here = 0, max_so_far = INT_MIN;
for (int i = 0; i < n; i++) {
// include current element to previous subarray only
// when it can add to a bigger number than itself.
if (arr[i] <= max_ending_here + arr[i]) {
max_ending_here += arr[i];
}
// Else start the max subarry from current element
else {
max_ending_here = arr[i];
}
if (max_ending_here > max_so_far)
max_so_far = max_ending_here;
}
n *= 2;
vector<int> a(n);
for (int i = 0; i < n; ++i)
{
cin>>a[i];
}
//sort(all(a));
for(int i = 0; i < n/2; i++){
cout<<a[i]<<" "<<a[i+n/2]<<" ";
}
cout<<endl;
cin>>n;
n *= 2;
// vector<int> a(n);
for (int i = 0; i < n; ++i)
{
cin>>a[i];
}
//sort(all(a));
for(int i = 0; i < n/2; i++){
cout<<a[i]<<" "<<a[i+n/2]<<" ";
}
cout<<endl;
cin>>n;
n *= 2;
// vector<int> a(n);
for (int i = 0; i < n; ++i)
{
cin>>a[i];
}
//sort(all(a));
for(int i = 0; i < n/2; i++){
cout<<a[i]<<" "<<a[i+n/2]<<" ";
}
cout<<endl;
cin>>n;
n *= 2;
//vector<int> a(n);
for (int i = 0; i < n; ++i)
{
cin>>a[i];
}
//sort(all(a));
for(int i = 0; i < n/2; i++){
cout<<a[i]<<" "<<a[i+n/2]<<" ";
}
cout<<endl;
cin>>n;
n *= 2;
//vector<int> a(n);
for (int i = 0; i < n; ++i)
{
cin>>a[i];
}
//sort(all(a));
for(int i = 0; i < n/2; i++){
cout<<a[i]<<" "<<a[i+n/2]<<" ";
}
cout<<endl;
cin>>n;
n *= 2;
//vector<int> a(n);
for (int i = 0; i < n; ++i)
{
cin>>a[i];
}
//sort(all(a));
for(int i = 0; i < n/2; i++){
cout<<a[i]<<" "<<a[i+n/2]<<" ";
}
cout<<endl;
cin>>n;
n *= 2;
//vector<int> a(n);
for (int i = 0; i < n; ++i)
{
cin>>a[i];
}
//sort(all(a));
for(int i = 0; i < n/2; i++){
cout<<a[i]<<" "<<a[i+n/2]<<" ";
}
cout<<endl;
cin>>n;
n *= 2;
//vector<int> a(n);
for (int i = 0; i < n; ++i)
{
cin>>a[i];
}
//sort(all(a));
for(int i = 0; i < n/2; i++){
cout<<a[i]<<" "<<a[i+n/2]<<" ";
}
cout<<endl;
}
#ifndef ONLINE_JUDGE
#define deb(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define deb(x...)
#endif
//------------------------------//
typedef long long int ll;
typedef pair<int,int> pi;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pi> vpi;
typedef vector<pll> vpll;
#define IOS ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define all(x) (x).begin(), (x).end()
#define ps(x,y) fixed<<setprecision(y)<<x
#define rep(i,a,b) for(ll i=a ; i<b ; ++i)
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
const ll maxn = 1e6 + 4;
void solve(){
int n;
cin>>n;
int arr[n];
for(int i=0; i<n; i++)
cin>>arr[i];
cout<<(n/2)*6<<endl;
for(int i=1; i<=n; i+=2)
{
cout<<1<<" "<<i<<" "<<i+1<<endl;
cout<<1<<" "<<i<<" "<<i+1<<endl;
cout<<2<<" "<<i<<" "<<i+1<<endl;
cout<<1<<" "<<i<<" "<<i+1<<endl;
cout<<1<<" "<<i<<" "<<i+1<<endl;
cout<<2<<" "<<i<<" "<<i+1<<endl;
}
}
int main(){
IOS
int test;
cin>>test;
while(test--)
solve();
}
// integer overflow
// var vs loop var
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, a[1010];
cin >> n;
int m = 1001, k;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] <= m) m = a[i], k = i;
}
if (k == 0 || k == n - 1)
cout << a[k] << endl;
else {
m = 1001;
for (i = 1; i < n - 1; i++)
if (a[i] <= a[i - 1] && a[i] <= a[i + 1]) {
if (min(a[i - 1], a[i + 1]) < m) m = min(a[i - 1], a[i + 1]);
}
cout << min(m, min(a[0], a[n - 1])) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int OO = 1e9;
const long long INF = 1e18;
const int irand(int lo, int hi) {
return ((double)rand() / (RAND_MAX + 1.0)) * (hi - lo + 1) + lo;
}
const long long lrand(long long lo, long long hi) {
return ((double)rand() / (RAND_MAX + 1.0)) * (hi - lo + 1) + lo;
}
template <typename T>
T getnum() {
int sign = 1;
T ret = 0;
char c;
do {
c = getchar();
} while (c == ' ' || c == '\n');
if (c == '-')
sign = -1;
else
ret = c - '0';
while (1) {
c = getchar();
if (c < '0' || c > '9') break;
ret = 10 * ret + c - '0';
}
return sign * ret;
}
inline void ini(int& x) { x = getnum<int>(); }
inline void scani(int& x) { scanf("%d", &x); }
const int N = 1e5 + 5;
int n;
int a[N], b[N];
long long ans = 0;
vector<pair<int, int> > ins;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(10);
cin >> n;
string str;
cin >> str;
for (int i = 0; i < n; i++) {
a[i + 1] = str[i] - '0';
}
cin >> str;
for (int i = 0; i < n; i++) {
b[i + 1] = str[i] - '0';
}
int difa = 0, difb = 0;
for (int i = 1; i <= n; i += 1) {
if (i & 1) {
difa += a[i];
difb += b[i];
} else {
difa -= a[i];
difb -= b[i];
}
}
if (difa != difb) {
cout << -1 << '\n';
return 0;
}
int f = 2;
for (int i = 1; i <= n - 1; i += 1) {
if (f == i) f++;
while (a[i] > b[i]) {
a[i]--;
while (1) {
assert(f <= n);
if ((f - i) & 1) {
if (a[f] == 0) {
f++;
} else {
a[f]--;
break;
}
} else {
if (a[f] == 9) {
f++;
} else {
a[f]++;
break;
}
}
}
ans += f - i;
if (ins.size() < 100000) {
for (int j = f - 1; j >= i; j -= 1) {
if ((j - i) & 1) {
ins.push_back({j, 1});
} else {
ins.push_back({j, -1});
}
}
}
}
while (a[i] < b[i]) {
a[i]++;
while (1) {
assert(f <= n);
if ((f - i) & 1) {
if (a[f] == 9) {
f++;
} else {
a[f]++;
break;
}
} else {
if (a[f] == 0) {
f++;
} else {
a[f]--;
break;
}
}
}
ans += f - i;
if (ins.size() < 100000) {
for (int j = f - 1; j >= i; j -= 1) {
if ((j - i) & 1) {
ins.push_back({j, -1});
} else {
ins.push_back({j, 1});
}
}
}
}
}
cout << ans << '\n';
for (int i = 0; i < min(100000, (int)ins.size()); i++) {
cout << ins[i].first << " " << ins[i].second << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long solve(int n, int k, string s, string c) {
unsigned long long result = 0;
for (int j = 0; j < s.length(); j++) {
bool found = false;
for (int i = 0; i < c.length(); i++) {
if (s[j] == c[i]) {
found = true;
}
}
if (!found) {
s[j] = ' ';
}
}
unsigned long long length = 0;
unsigned long long last = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == ' ') {
result += length * (length + 1) / 2;
length = 0;
last = i + 1;
} else {
length++;
}
}
unsigned long long remaining = s.length() - last;
result += remaining * (remaining + 1) / 2;
return result;
}
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
string c = "";
for (int i = 0; i < k; i++) {
char x;
cin >> x;
c += x;
}
cout << solve(n, k, s, c) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int compare(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int freqi[15], freq[15];
char s[100005], s1[100000];
int main(void) {
int i, n, ans, k, l, m, t;
scanf("%s", s1);
l = strlen(s1);
for (i = 0; i < l; i++) {
if (s1[i] == '9') s1[i] = '6';
if (s1[i] == '5') s1[i] = '2';
}
for (i = 0; i < l; i++) freqi[s1[i] - '0']++;
scanf("%s", s);
l = strlen(s);
for (i = 0; i < l; i++) {
if (s[i] == '9') s[i] = '6';
if (s[i] == '5') s[i] = '2';
}
for (i = 0; i < l; i++) freq[s[i] - '0']++;
int mini = 999999999;
for (i = 0; i < 10; i++) {
if (freqi[i]) {
ans = freq[i] / freqi[i];
if (ans) {
if (ans < mini) mini = ans;
}
}
}
if (mini == 999999999) mini = 0;
printf("%d ", mini);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
const int INF = 1e3 + 9;
int gcd(int a, int b) {
if (a == 0) return b;
if (b == 0) return a;
gcd(b, a % b);
}
bool a[1001][1001];
long long f(long long n) {
if (n <= 1) return 1;
return f(n - 1) * n;
}
int main() {
int n;
cin >> n;
int a = 0, b = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a = a | x;
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
b = b | x;
}
cout << a + b << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::max;
using std::min;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::sort;
using std::vector;
bool chmin(int &a, const int &b) { return a > b ? a = b, true : false; }
bool chmax(int &a, const int &b) { return a < b ? a = b, true : false; }
const int maxN = 100000 + 233;
int n;
struct Rectangle {
int x1, x2, y1, y2;
void read() {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
if (x1 > x2) std::swap(x1, x2);
if (y1 > y2) std::swap(y1, y2);
}
} a[maxN];
struct Event {
int t;
int y, id, l, r;
Event(int t, int y, int i, int l, int r) : t(t), y(y), id(i), l(l), r(r) {}
friend bool operator<(const Event &A, const Event &B) {
return A.y != B.y ? A.y < B.y
: A.t != B.t ? A.t > B.t
: A.t == -1 ? A.id < B.id
: A.id > B.id;
}
};
vector<Event> events;
void discretization() {
vector<int> v;
v.clear();
v.reserve(n * 2);
for (int i = 1; i <= n; ++i) v.push_back(a[i].x1), v.push_back(a[i].x2);
std::sort(v.begin(), v.end());
v.erase(std::unique(v.begin(), v.end()), v.end());
for (int i = 1; i <= n; ++i)
a[i].x1 = std::lower_bound(v.begin(), v.end(), a[i].x1) - v.begin() + 1,
a[i].x2 = std::lower_bound(v.begin(), v.end(), a[i].x2) - v.begin() + 1 - 1;
}
void initialize() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) a[i].read();
discretization();
events.clear();
events.reserve(n * 2);
for (int i = 1; i <= n; ++i) {
events.push_back(Event(1, a[i].y1, i, a[i].x1, a[i].x2));
events.push_back(Event(-1, a[i].y2, i, a[i].x1, a[i].x2));
}
std::sort(events.begin(), events.end());
}
bool appeared[maxN];
bool vis[maxN];
template <int NODE>
struct SegmentTree {
priority_queue<int> pq[NODE];
int min[NODE];
int max[NODE];
void init(int n) {
for (int o = 0; o <= 4 * n; ++o) {
while (!pq[o].empty()) pq[o].pop();
pq[o].push(0);
min[o] = 0;
max[o] = 0;
}
}
void maintain(int o, int L, int R) {
min[o] = pq[o].top();
while (vis[pq[o].top()]) pq[o].pop();
max[o] = appeared[pq[o].top()] ? 0 : pq[o].top();
if (L < R) {
chmax(min[o], std::min(min[(o << 1)], min[(o << 1 | 1)]));
if (pq[o].top() >= std::min(min[(o << 1)], min[(o << 1 | 1)])) {
chmax(
max[o],
std::max(max[(o << 1)] > pq[o].top() ? max[(o << 1)] : 0,
max[(o << 1 | 1)] > pq[o].top() ? max[(o << 1 | 1)] : 0));
} else {
max[o] = std::max(max[(o << 1)], max[(o << 1 | 1)]);
}
}
}
void print(int o, int L, int R) {
printf("#%d : [%d, %d] v = %d with {%d, %d}\n", o, L, R, pq[o].top(),
min[o], max[o]);
if (L < R) {
int M = (L + R) >> 1;
print((o << 1), L, M);
print((o << 1 | 1), M + 1, R);
}
}
int ql, qr, qv;
void seek(int o, int L, int R) {
if (pq[o].top() != qv) {
int M = (L + R) >> 1;
if (max[(o << 1)] == qv) seek((o << 1), L, M);
if (max[(o << 1 | 1)] == qv) seek((o << 1 | 1), M + 1, R);
}
maintain(o, L, R);
}
void solve(int o, int L, int R) {
while (max[o]) {
appeared[max[o]] = true;
qv = max[o];
seek(o, L, R);
}
}
void push(int o, int L, int R) {
if (ql <= L && R <= qr) {
pq[o].push(qv);
} else {
int M = (L + R) >> 1;
if (ql <= M) push((o << 1), L, M);
if (qr > M) push((o << 1 | 1), M + 1, R);
}
maintain(o, L, R);
}
void pop(int o, int L, int R) {
if (ql <= L && R <= qr) {
while (vis[pq[o].top()]) pq[o].pop();
} else {
int M = (L + R) >> 1;
if (ql <= M) pop((o << 1), L, M);
if (qr > M) pop((o << 1 | 1), M + 1, R);
}
maintain(o, L, R);
}
};
SegmentTree<maxN * 8> st;
int solve() {
st.init(n * 2);
int lasty = -maxN;
vis[0] = appeared[0] = false;
for (const Event &e : events) {
if (e.y != lasty) {
st.solve(1, 1, n * 2);
lasty = e.y;
}
if (e.t == -1) {
st.ql = e.l;
st.qr = e.r;
st.qv = e.id;
vis[e.id] = true;
st.pop(1, 1, n * 2);
} else if (e.t == 1) {
st.ql = e.l;
st.qr = e.r;
st.qv = e.id;
appeared[e.id] = vis[e.id] = false;
st.push(1, 1, n * 2);
} else {
assert(false);
}
}
int cnt = 0;
for (int i = 1; i <= n; ++i)
if (appeared[i]) ++cnt;
return cnt + 1;
}
int main() {
initialize();
printf("%d\n", solve());
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, res, ss;
string s;
map<char, int> f[1001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> s;
for (int i = 0; i < s.size(); i++) f[i + 1][s[i]]++;
}
for (int i = 1; i <= m; i++) {
cin >> x;
ss = 0;
ss = max(ss, f[i]['A']);
ss = max(ss, f[i]['B']);
ss = max(ss, f[i]['C']);
ss = max(ss, f[i]['D']);
ss = max(ss, f[i]['E']);
res += ss * x;
}
cout << res;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5, INF = 1e9 + 7;
char a[5][5];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
cin >> a[i][j];
}
}
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (a[i][j] != a[2 - i][2 - j]) return cout << "NO", 0;
}
}
cout << "YES";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(string a, string b) {
int lena = a.length(), lenb = b.length();
if (lena != lenb) {
return lena < lenb;
} else {
if (a == b)
return false;
else {
for (int i = 0; i < lena; i++) {
if (a[i] != b[i]) return a[i] < b[i];
}
}
}
}
int main() {
int n;
cin >> n;
string s[105];
for (int i = 0; i < n; i++) {
cin >> s[i];
}
sort(s, s + n, cmp);
bool flag = true;
for (int i = 0; i < n - 1; i++) {
if (s[i + 1].find(s[i]) == s[i + 1].npos) {
flag = false;
break;
}
}
if (flag) {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
cout << s[i] << endl;
}
} else {
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
long long t, n, a[MAX];
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
int main() {
long long i, j, f1, f2, g1, g2, gg;
scanf("%lld", &t);
while (t--) {
scanf("%lld", &n);
for (i = 1; i <= n; i++) scanf("%lld", a + i);
if (n % 2 == 0) {
for (i = 1; i <= n; i += 2) {
f1 = f2 = 0;
g1 = g2 = 1;
if (a[i] < 0) a[i] = -a[i], f1 = 1;
if (a[i + 1] < 0) a[i + 1] = -a[i + 1], f2 = 1;
gg = gcd(a[i], a[i + 1]);
if (f1 ^ f2)
printf("%lld %lld ", a[i + 1] / gg, a[i] / gg);
else
printf("%lld %lld ", -a[i + 1] / gg, a[i] / gg);
}
printf("\n");
} else {
for (i = 1; i <= n - 3; i += 2) {
f1 = f2 = 0;
g1 = g2 = 1;
if (a[i] < 0) a[i] = -a[i], f1 = 1;
if (a[i + 1] < 0) a[i + 1] = -a[i + 1], f2 = 1;
gg = gcd(a[i], a[i + 1]);
if (f1 ^ f2)
printf("%lld %lld ", a[i + 1] / gg, a[i] / gg);
else
printf("%lld %lld ", -a[i + 1] / gg, a[i] / gg);
}
if (a[i] == a[i + 1]) {
f1 = f2 = 0;
i++;
if (a[i] < 0) a[i] = -a[i], f1 = 1;
if (a[i + 1] < 0) a[i + 1] = -a[i + 1], f2 = 1;
gg = gcd(a[i], a[i + 1]);
if (f1 ^ f2)
printf("-1 %lld %lld ", a[i + 1] / gg + 1, a[i] / gg);
else
printf("1 %lld %lld ", -(a[i + 1] / gg + 1), a[i] / gg);
printf("\n");
continue;
}
if (a[i] == -a[i + 1]) {
f1 = f2 = 0;
i++;
if (a[i] < 0) a[i] = -a[i], f1 = 1;
if (a[i + 1] < 0) a[i + 1] = -a[i + 1], f2 = 1;
gg = gcd(a[i], a[i + 1]);
if (f1 ^ f2)
printf("1 %lld %lld ", a[i + 1] / gg + 1, a[i] / gg);
else
printf("-1 %lld %lld ", -(a[i + 1] / gg + 1), a[i] / gg);
printf("\n");
continue;
}
long long kk = 1;
if ((a[i + 1] < 0 && a[i] > 0) || (a[i + 1] > 0 && a[i] < 0)) {
a[i + 1] += a[i];
i++;
} else {
a[i + 1] -= a[i];
i++;
kk = -1;
}
f1 = f2 = 0;
if (a[i] < 0) a[i] = -a[i], f1 = 1;
if (a[i + 1] < 0) a[i + 1] = -a[i + 1], f2 = 1;
gg = gcd(a[i], a[i + 1]);
if (f1 ^ f2)
printf("%lld %lld %lld ", a[i + 1] * kk / gg, a[i + 1] / gg, a[i] / gg);
else
printf("%lld %lld %lld ", -a[i + 1] * kk / gg, -a[i + 1] / gg,
a[i] / gg);
printf("\n");
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long x, d;
cin >> x >> d;
int cnt = 0;
long long now = 1;
vector<long long> ans;
while (x > 0) {
if (x & 1) {
for (int i = 0; i < cnt; i++) ans.push_back(now);
now += (d + 1);
ans.push_back(now);
now += (d + 1);
}
cnt++;
x >>= 1;
}
cout << ans.size() << "\n";
for (auto i : ans) cout << i << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, p = 1, cnt;
cin >> n;
cnt = n;
cin >> s;
for (int i = 0; i < n - 2; i++) {
if (s[i] == 'x' && s[i + 1] == 'x' && s[i + 2] == 'x') {
for (int j = i; j <= n - 1; j++) s[j] = s[j + 1];
n--;
p = 0;
i--;
}
}
if (p == 1)
cout << "0";
else {
cout << cnt - n;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vii = vector<pii>;
using vvi = vector<vi>;
int N, a[55];
void solve() {
cin >> N;
for (int i = 0; i < N; i++) cin >> a[i];
int i = 0, j = N - 1;
while (a[i] == 0 && i < N) i++;
while (a[j] == 0 && j >= 0) j--;
i++;
int ans = 0;
while (i < j) ans += a[i] == 0, i++;
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while (T--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 10;
bool b(long long a, long long b, long long c) {
return c <= min(a, b) || c >= max(a, b);
}
int main() {
long long x1, y1, x2, y2, x3, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
if ((x1 == x2 && x2 == x3) || (y1 == y2 && y2 == y3))
printf("1");
else if ((x1 == x2 && b(y1, y2, y3)) || (x1 == x3 && b(y1, y3, y2)) ||
(x3 == x2 && b(y3, y2, y1)) || (y1 == y2 && b(x1, x2, x3)) ||
(y1 == y3 && b(x1, x3, x2)) || (y3 == y2 && b(x3, x2, x1)))
printf("2");
else
printf("3");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 10000007;
int n, tot_c, now[110000], ansx, ansy;
long long sum[110000], Ans;
pair<pair<int, long long>, vector<pair<int, int> > > sto[110000];
bool bn[110000];
map<int, int> color;
set<pair<long long, int> > gy;
int main() {
cin >> n;
for (int i = 1, c, h; i <= n; ++i) {
cin >> c >> h;
if (color.find(c) == color.end()) color[c] = ++tot_c;
sto[color[c]].first.first++;
sto[color[c]].second.push_back(make_pair(-h, i));
sum[color[c]] += h;
}
for (int i = 1; i <= tot_c; ++i) sto[i].first.second = sum[i];
for (int i = 1; i <= tot_c; ++i)
sort(sto[i].second.begin(), sto[i].second.end());
sort(sto + 1, sto + tot_c + 1);
for (int i = 2; i <= tot_c; ++i)
if (sto[i].first.first == sto[i - 1].first.first) {
bn[i - 1] = 1;
if (sto[i].first.second + sto[i - 1].first.second > Ans) {
Ans = sto[i].first.second + sto[i - 1].first.second;
ansx = i;
ansy = i - 1;
}
}
for (int i = 1; i <= tot_c; ++i) sum[i] = now[i] = 0;
for (int i = 1; i <= tot_c; ++i) gy.insert(make_pair(0, i));
for (int i = 1; i <= tot_c; ++i)
if (!bn[i]) {
gy.erase(make_pair(sum[i], i));
for (int j = i + 1; j <= tot_c; ++j) {
gy.erase(make_pair(sum[j], j));
for (; now[j] <= sto[i].first.first; now[j]++)
sum[j] += -sto[j].second[now[j]].first;
gy.insert(make_pair(sum[j], j));
}
if (gy.empty()) continue;
if (sto[i].first.second + gy.rbegin()->first > Ans) {
Ans = sto[i].first.second + gy.rbegin()->first;
ansx = i;
ansy = gy.rbegin()->second;
}
} else
gy.erase(make_pair(sum[i], i));
cout << Ans << endl;
cout << sto[ansx].first.first * 2 +
(sto[ansx].first.first != sto[ansy].first.first)
<< endl;
int ppp = 0;
for (int i = 0; i < sto[ansx].first.first; ++i) {
cout << sto[ansy].second[i].second << ' ' << sto[ansx].second[i].second
<< ' ';
}
if (sto[ansx].first.first != sto[ansy].first.first) {
cout << sto[ansy].second[sto[ansx].first.first].second << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const double PI = acos(-1.0);
const long long mod = 1e18;
const int N = 200000 + 10;
const int MAXN = 10000 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, a[N], num = 1, cnt = 0, vis[N], rcd[N];
memset(vis, 0, sizeof vis);
memset(rcd, 0, sizeof rcd);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
vis[a[i]]++;
}
for (int i = 0; i < n; i++) {
if (vis[a[i]] > 1) {
while (vis[num]) num++;
if (num >= a[i] && !rcd[a[i]]) {
rcd[a[i]]++;
continue;
}
cnt++;
vis[a[i]]--;
vis[num]++;
a[i] = num;
}
}
cout << cnt << endl << a[0];
for (int i = 1; i < n; i++) cout << " " << a[i];
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int a[N][N];
int u[N][N], dow[N][N], l[N][N], r[N][N];
int n, m, q;
int heigh[N];
void init() {
memset(u, 0, sizeof(u));
memset(dow, 0, sizeof(dow));
memset(l, 0, sizeof(l));
memset(r, 0, sizeof(r));
}
void update_raw(int x) {
for (int i = 1; i <= m; i++) {
if (a[x][i])
l[x][i] = l[x][i - 1] + 1;
else
l[x][i] = 0;
}
for (int i = m; i > 0; i--) {
if (a[x][i])
r[x][i] = r[x][i + 1] + 1;
else
r[x][i] = 0;
}
}
void update_col(int y) {
for (int i = 1; i <= n; i++) {
if (a[i][y])
u[i][y] = u[i - 1][y] + 1;
else
u[i][y] = 0;
}
for (int i = n; i > 0; i--) {
if (a[i][y])
dow[i][y] = dow[i + 1][y] + 1;
else
dow[i][y] = 0;
}
}
int getmax(int x, int h, int lim) {
int res = 0;
int lm = x;
int rm = x;
for (int i = h; i > 0; i--) {
while (lm > 0 && heigh[lm] >= i) lm--;
while (rm <= lim && heigh[rm] >= i) rm++;
res = max(res, i * (rm - lm - 1));
}
return res;
}
int main() {
while (cin >> n >> m >> q) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
init();
for (int i = 1; i <= n; i++) {
update_raw(i);
}
for (int i = 1; i <= m; i++) {
update_col(i);
}
int op, x, y;
while (q--) {
cin >> op >> x >> y;
if (op == 1) {
a[x][y] ^= 1;
update_raw(x);
update_col(y);
} else {
int ans = 0;
for (int i = 1; i <= n; i++) heigh[i] = l[i][y];
ans = max(ans, getmax(x, heigh[x], n));
for (int i = 1; i <= n; i++) heigh[i] = r[i][y];
ans = max(ans, getmax(x, heigh[x], n));
for (int i = 1; i <= m; i++) heigh[i] = u[x][i];
ans = max(ans, getmax(y, heigh[y], m));
for (int i = 1; i <= m; i++) heigh[i] = dow[x][i];
ans = max(ans, getmax(y, heigh[y], m));
cout << ans << endl;
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps(1e-8);
double dp[110][110][300];
int main() {
memset(dp, 0, sizeof(0));
int n, K;
cin >> n >> K;
int a[110];
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (a[i] > a[j]) dp[i][j][0] = 1;
double p = 2. / n / (n + 1);
for (int k = 0; k < K; k++)
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
for (int x = 1; x <= n; x++)
for (int y = x; y <= n; y++)
if (i < x && y < j) {
dp[i][j][k + 1] += dp[i][j][k] * p;
dp[j][i][k + 1] += (1 - dp[i][j][k]) * p;
} else if (x <= i && i <= y && y < j) {
dp[x + y - i][j][k + 1] += dp[i][j][k] * p;
dp[j][x + y - i][k + 1] += (1 - dp[i][j][k]) * p;
} else if (i < x && x <= j && j <= y) {
dp[i][x + y - j][k + 1] += dp[i][j][k] * p;
dp[x + y - j][i][k + 1] += (1 - dp[i][j][k]) * p;
} else if (x <= i && i <= j && j <= y) {
dp[x + y - i][x + y - j][k + 1] += dp[i][j][k] * p;
dp[x + y - j][x + y - i][k + 1] += (1 - dp[i][j][k]) * p;
} else {
dp[i][j][k + 1] += dp[i][j][k] * p;
dp[j][i][k + 1] += (1 - dp[i][j][k]) * p;
}
double ans = 0;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) ans += dp[i][j][K];
printf("%.9f\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
map<int, vector<int> > mapka;
void go(int v, int p = -1) {
ans.push_back(v);
vector<int>& vv = mapka[v];
if (mapka[v].size() == 1 && p != -1) return;
int to = vv[0] == p ? vv[1] : vv[0];
go(to, v);
}
int main() {
ios_base::sync_with_stdio(0);
srand(time(0));
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
mapka[a].push_back(b);
mapka[b].push_back(a);
}
int s = 0;
for (map<int, vector<int> >::iterator it = mapka.begin(); it != mapka.end();
++it)
if (it->second.size() == 1) s = it->first;
if (true)
;
go(s);
for (int i = 0; i < ans.size(); ++i) cout << ans[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
enum CTypeId { tpT, tpInt, tpStr, tpDouble };
struct CFunc {
std::string name_;
std::vector<CTypeId> params_;
};
std::vector<CFunc> fl;
std::string ParseName(char const* s, int& i) {
while (s[i] && !(((s[i]) >= '0' && (s[i]) <= '9') ||
(((s[i]) >= 'a' && (s[i]) <= 'z') ||
((s[i]) >= 'A' && (s[i]) <= 'Z')))) {
++i;
}
std::string res;
while (s[i] && (((s[i]) >= '0' && (s[i]) <= '9') ||
(((s[i]) >= 'a' && (s[i]) <= 'z') ||
((s[i]) >= 'A' && (s[i]) <= 'Z')))) {
res.push_back(s[i]);
++i;
}
return res;
}
CTypeId GetTypeId(std::string const& s) {
if (s == "T") return tpT;
if (s == "int") return tpInt;
if (s == "string") return tpStr;
if (s == "double") return tpDouble;
return tpT;
}
void ParseFunc(char const* s) {
int pos = 0;
std::string name;
name = ParseName(s, pos);
name = ParseName(s, pos);
CFunc f;
f.name_ = name;
name = ParseName(s, pos);
while (!name.empty()) {
f.params_.push_back(GetTypeId(name));
name = ParseName(s, pos);
}
fl.push_back(f);
}
std::map<std::string, CTypeId> vm;
void ParseVar(char const* s) {
int pos = 0;
std::string typeName = ParseName(s, pos);
std::string name = ParseName(s, pos);
vm[name] = GetTypeId(typeName);
}
CFunc ParseCall(char const* s) {
int pos = 0;
std::string name;
name = ParseName(s, pos);
CFunc f;
f.name_ = name;
name = ParseName(s, pos);
while (!name.empty()) {
std::map<std::string, CTypeId>::const_iterator it = vm.find(name);
f.params_.push_back(it->second);
name = ParseName(s, pos);
}
return f;
}
bool Suitable(CFunc const& tmp, CFunc const& f) {
if (tmp.name_ != f.name_) return false;
if (tmp.params_.size() != f.params_.size()) return false;
for (int i = 0; i < (int)f.params_.size(); ++i) {
if (tmp.params_[i] == tpT) continue;
if (tmp.params_[i] != f.params_[i]) return false;
}
return true;
}
int Solve(char const* s) {
int cnt = 0;
CFunc f = ParseCall(s);
for (std::vector<CFunc>::const_iterator i = fl.begin(); i != fl.end(); ++i) {
if (Suitable(*i, f)) ++cnt;
}
return cnt;
}
char buf[65000];
int main() {
{
gets(buf);
int n;
sscanf(buf, "%d", &n);
for (int i = 0; i < n; ++i) {
gets(buf);
ParseFunc(buf);
}
}
{
gets(buf);
int m;
sscanf(buf, "%d", &m);
for (int i = 0; i < m; ++i) {
gets(buf);
ParseVar(buf);
}
}
{
gets(buf);
int k;
sscanf(buf, "%d", &k);
for (int i = 0; i < k; ++i) {
gets(buf);
int ans = Solve(buf);
printf("%d\n", ans);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-11;
int n, k;
int a[100];
int main() {
cout << setiosflags(ios::fixed) << setprecision(10);
cin >> n >> k;
if (k > n) {
cout << -1;
return 0;
}
for (int i = 0; i < (n); i++) cin >> a[i];
sort(a, a + n);
reverse(a, a + n);
cout << a[k - 1] << ' ' << a[k - 1];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 15e4 + 5, MAX = 1e6 + 5;
int n, q, a[N], fa[N], upb, node[MAX];
set<pair<int, int> > s;
struct factorer {
int tot, p[9];
} fct[MAX];
int find(int u) { return fa[u] == u ? u : fa[u] = find(fa[u]); }
void merge(int u, int v) {
u = find(u), v = find(v);
if (u != v) fa[u] = v;
}
void read(int &x) {
int res = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) res = res * 10 + ch - '0', ch = getchar();
x = res;
}
void init() {
for (int i = 2; i <= upb; ++i)
if (!fct[i].tot)
for (int j = 1; j * i <= upb; ++j) fct[i * j].p[++fct[i * j].tot] = i;
for (int i = 1; i <= n; ++i)
for (int j = 1, num; j <= fct[a[i]].tot; ++j)
if (!node[num = fct[a[i]].p[j]])
node[num] = i;
else
merge(node[num], i);
for (int i = 1; i <= n; ++i) {
int newnum = a[i] + 1, cnt = 0, mem[9] = {find(i)};
for (int j = 1; j <= fct[newnum].tot; ++j) {
mem[++cnt] = find(node[fct[newnum].p[j]]);
}
for (int j = 1; j <= cnt; ++j)
for (int k = 0; k < j; ++k) {
s.insert({mem[j], mem[k]}), s.insert({mem[k], mem[j]});
}
}
}
int main() {
read(n), read(q);
for (int i = 1; i <= n; ++i) read(a[i]), fa[i] = i, upb = max(upb, a[i] + 1);
init();
for (int i = 1, u, v; i <= q; ++i) {
read(u), read(v);
u = find(u), v = find(v);
if (u == v)
puts("0");
else if (s.count({u, v}))
puts("1");
else
puts("2");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
map<int, int> s[1010011], vis;
int lowbit(int x) { return x & -x; }
void add(int k, int x, int v) {
while (k < 1e9 + 7) {
s[x][k] += v;
k += lowbit(k);
}
}
int ans(int k, int x) {
int res = 0;
while (k) {
res += s[x][k];
k -= lowbit(k);
}
return res;
}
int cnt = 0;
int main() {
int n = read();
for (int i = 1; i <= n; i++) {
int q = read(), t = read(), x = read();
if (vis[x] == 0) {
vis[x] = ++cnt;
}
if (q == 1) {
add(t, vis[x], 1);
}
if (q == 2) {
add(t, vis[x], -1);
}
if (q == 3) {
cout << ans(t, vis[x]) << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int mod = 1000000007;
long long f[1010000], n, m, x;
int main() {
scanf("%I64d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &x), m += (x == 1);
f[0] = f[1] = 1;
for (int i = 2; i <= m; i++) f[i] = (f[i - 1] + f[i - 2] * (i - 1)) % mod;
for (int i = m + 1; i <= n; i++) f[m] = f[m] * i % mod;
printf("%I64d\n", f[m]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, i;
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> t;
while (t--) {
string str;
cin >> str;
n = str.size();
for (auto &it : str) {
it -= '0';
}
string sol;
int l1 = 0, r1 = 0;
while (r1 < n && str[r1] % 2 == str[l1] % 2) {
r1++;
}
r1--;
int l2 = 0, r2 = -1;
while (1) {
if (l1 > r1) {
while (l1 < n && str[l1] % 2 == str[l2] % 2) {
l1++;
}
r1 = l1;
while (r1 < n && str[r1] % 2 == str[l1] % 2) {
r1++;
}
r1--;
}
if (l2 > r2) {
while (l2 < n && str[l2] % 2 == str[l1] % 2) {
l2++;
}
r2 = l2;
while (r2 < n && str[r2] % 2 == str[l2] % 2) {
r2++;
}
r2--;
}
if (l1 == n || l2 == n) {
break;
}
if (str[l1] <= str[l2]) {
sol.push_back(str[l1++] + '0');
} else {
sol.push_back(str[l2++] + '0');
}
}
for (i = l1; i < n; i++) {
if (str[l1] % 2 == str[i] % 2) sol.push_back(str[i] + '0');
}
for (i = l2; i < n; i++) {
if (str[l2] % 2 == str[i] % 2) sol.push_back(str[i] + '0');
}
cout << sol << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void dmin(T& x, T y) {
y < x ? x = y : 0;
}
template <class T>
inline void dmax(T& x, T y) {
y > x ? x = y : 0;
}
template <class T>
inline void dmin(T& x, vector<T> y) {
for (auto t : y) t < x ? x = t : 0;
}
template <class T>
inline void dmax(T& x, vector<T> y) {
for (auto t : y) t > x ? x = t : 0;
}
const int N = 5 + 1e6;
const long long INF = -2e18;
int n, k;
long long gk(int x, long long a[], int i, long long f) {
return a[x] + (i - x) / 3 * f;
}
bool cmp(int x, int y, long long a[], int i, long long f) {
return gk(x, a, i, f) > gk(y, a, i, f);
}
void opera(long long a[], int n, long long f, int k) {
static long long b[N];
static long long q[3][N], left[3], right[3];
for (int i = 0; i < 3; ++i) left[i] = 1, right[i] = 0;
for (int i = 0; i < n; ++i) b[i] = INF;
for (int i = 0; i < n; ++i) {
int t = i % 3;
while (left[t] <= right[t] && q[t][left[t]] < i - 3 * k) ++left[t];
while (left[t] <= right[t] && cmp(i, q[t][right[t]], a, i, f)) --right[t];
q[t][++right[t]] = i;
b[i] = gk(q[t][left[t]], a, i, f);
}
for (int i = 0; i < n; ++i) a[i] = b[i];
}
void opera2(long long a[], int n, long long f, int k) {
static long long f1[N], f2[N];
for (int i = 0; i < n; ++i) {
f1[i] = f2[i] = a[i];
for (int j = 1; j < 10 && i - j >= 0; ++j) f2[i] = max(f2[i], a[i - j]);
}
opera(f1, n, f, 3 * k);
opera(f2, n, f, 3 * (k - 1));
for (int i = 0; i < n; ++i) a[i] = max(f1[i], f2[i]);
}
long long a[N], b[N];
int main() {
int k;
scanf("%d", &k);
long long f[6];
for (int i = 0; i < 6; ++i) scanf("%lld", &f[i]);
a[0] = 0;
n = 1;
for (int i = 5; i >= 0; --i) {
for (int j = 0; j < 10 * n; ++j) b[j] = INF;
for (int j = 0; j < n; ++j) b[j * 10] = a[j];
n *= 10;
opera2(b, n, f[i], k);
for (int j = 0; j < n; ++j) a[j] = b[j];
}
int q;
scanf("%d", &q);
while (q--) {
int x;
scanf("%d", &x);
printf("%lld\n", a[x]);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long binpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a;
a = a * a;
b = b >> 1;
}
return res;
}
long long count(long long a, long long b, long long c, long long j) {
if (j + a < b + c) {
return 0;
}
long long cur = min(j, (j + a - b - c) / 2);
return (cur + 1) * (cur + 2) / 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long a[3];
long long l;
cin >> a[0] >> a[1] >> a[2] >> l;
long long ans = 0;
for (long long i = 0; i <= l; i += 1) {
ans += (l - i + 1) * (l - i + 2) / 2;
}
for (long long i = 0; i < 3; ++i) {
for (long long j = 0; j <= l; ++j) {
ans -= count(a[i], a[(i + 1) % 3], a[(i + 2) % 3], j);
}
}
cout << ans << "\n";
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
int x[233][233]={
{1,0,0,0,0,0},
{1,0,1,0,0,0},
{1,1,0,0,0,0},
{1,1,0,1,0,0},
{1,0,0,1,0,0},
{1,1,1,0,0,0},
{1,1,1,1,0,0},
{1,0,1,1,0,0},
{0,1,1,0,0,0},
{0,1,1,1,0,0},
{1,0,0,0,1,0},
{1,0,1,0,1,0},
{1,1,0,0,1,0},
{1,1,0,1,1,0},//n
{1,0,0,1,1,0},
{1,1,1,0,1,0},
{1,1,1,1,1,0},
{1,0,1,1,1,0},
{0,1,1,0,1,0},
{0,1,1,1,1,0},
{1,0,0,0,1,1},//u
{1,0,1,0,1,1},
{0,1,1,1,0,1},
{1,1,0,0,1,1},
{1,1,0,1,1,1},
{1,0,0,1,1,1}
};
int n,a,c,b,d,e;
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>a>>b>>c>>d>>e;
for(char ch='a';ch<='z';ch++)
{
auto z=x[ch-'a'];
int aa=z[0]+z[1];
int bb=z[2]+z[3];
int cc=z[4]+z[5];
int dd=z[0]+z[2]+z[4];
int ee=z[1]+z[3]+z[5];
if(aa==a&&bb==b&&cc==c&&dd==d&&ee==e)
{
cout<<ch;
break;
}
}
}
return 0;
} | 9 |
#include <bits/stdc++.h>
template <class T1, class T2, class T3>
T1 ksm(T1 a, T2 b, T3 mod) {
T1 ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
const double pi = acos(-1.);
const int def = 1000010;
const int mod = 1000000007;
using namespace std;
int n, a[def], b[def], c[def], v[def], sta[def];
int main() {
int _ = 1, __ = 1, m;
for (((0) ? scanf("%d", &_) : EOF); _; _--, __++) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] -= i;
v[i] = true;
}
a[++n] = INT_MAX;
a[0] = INT_MIN;
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
v[b[i]] = false;
}
b[++m] = n;
v[n] = false;
sort(b + 1, b + m + 1);
int ans = 0;
for (int i = 2; i <= m; i++)
if (a[b[i - 1]] > a[b[i]]) {
ans = -1;
break;
}
if (!ans) {
int cnt = 0, l = 1, num = 0, lim = 0, maxx;
for (int i = 1; i <= m; i++) {
maxx = 0;
cnt = 0;
for (int j = b[i - 1] + 1; j < b[i]; j++)
if (a[j] >= a[b[i - 1]] && a[j] <= a[b[i]]) {
if (!cnt || sta[cnt] <= a[j])
sta[++cnt] = a[j];
else
*upper_bound(sta + 1, sta + cnt + 1, a[j]) = a[j];
}
ans += b[i] - b[i - 1] - 1 - cnt;
}
}
printf("%d\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int Last_n, haha, K;
int Ws[200010], Wv[200010], sa[200010], height[200010], Rank[200010],
f[200010][30];
int Use_a[200010], Use_b[200010], r[200010], pos[200010], The_len[200010];
char S1[200010];
int flag[200010];
long long Ans[200010];
struct Node {
int flag, Max;
} t[200010 * 4];
bool Cmp(int *r, int a, int b, int len) {
return r[a] == r[b] && r[a + len] == r[b + len];
}
void Suf_work(int n, int m) {
int *x = Use_a, *y = Use_b, *t;
for (int i = 0; i < m; i++) Ws[i] = 0;
for (int i = 0; i < n; i++) Ws[x[i] = r[i]]++;
for (int i = 1; i < m; i++) Ws[i] += Ws[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--Ws[x[i]]] = i;
for (int j = 1, p = 1; p < n; j <<= 1, m = p) {
p = 0;
for (int i = n - j; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (int i = 0; i < n; i++) Wv[i] = x[y[i]];
for (int i = 0; i < m; i++) Ws[i] = 0;
for (int i = 0; i < n; i++) Ws[Wv[i]]++;
for (int i = 1; i < m; i++) Ws[i] += Ws[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--Ws[Wv[i]]] = y[i];
t = x;
x = y;
y = t;
p = 1;
x[sa[0]] = 0;
for (int i = 1; i < n; i++)
x[sa[i]] = Cmp(y, sa[i - 1], sa[i], j) ? p - 1 : p++;
}
}
void Calheight(int n) {
int k = 0, j;
for (int i = 1; i <= n; i++) Rank[sa[i]] = i;
for (int i = 0; i < n; height[Rank[i++]] = k)
for (k ? k-- : 0, j = sa[Rank[i] - 1]; r[i + k] == r[j + k]; k++)
;
}
void RMQ() {
for (int i = 1; i <= Last_n; i++) f[i][0] = height[i];
for (int j = 1; j <= 26; j++)
for (int i = 1; i <= Last_n; i++) {
if (i + (1 << j) - 1 <= Last_n)
f[i][j] = min(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);
}
}
int Get_min(int a, int b) {
int x1 = Rank[a], x2 = Rank[b];
int l = min(x1, x2), r = max(x1, x2);
l++;
if (l > r) return The_len[a];
int qwer = (int)(log(r - l + 1.0) / log(2.0));
return min(f[l][qwer], f[r - (1 << qwer) + 1][qwer]);
}
void Pushdown(int i) {
if (t[i].flag == 0) return;
t[i * 2].flag = max(t[i * 2].flag, t[i].flag);
t[i * 2 + 1].flag = max(t[i * 2 + 1].flag, t[i].flag);
t[i * 2].Max = max(t[i * 2].Max, t[i].flag);
t[i * 2 + 1].Max = max(t[i * 2 + 1].Max, t[i].flag);
t[i].flag = 0;
}
void Updata(int i, int l, int r, int left, int right, int c) {
if (l >= left && r <= right) {
t[i].flag = max(t[i].flag, c);
t[i].Max = max(t[i].Max, c);
return;
}
Pushdown(i);
int mid = (l + r) / 2;
if (right <= mid)
Updata(i * 2, l, mid, left, right, c);
else if (left > mid)
Updata(i * 2 + 1, mid + 1, r, left, right, c);
else {
Updata(i * 2, l, mid, left, mid, c);
Updata(i * 2 + 1, mid + 1, r, mid + 1, right, c);
}
t[i].Max = max(t[i * 2].Max, t[i * 2 + 1].Max);
}
int Query(int i, int l, int r, int k) {
if (l == r) {
return t[i].Max;
}
Pushdown(i);
int mid = (l + r) / 2;
if (k <= mid)
return Query(i * 2, l, mid, k);
else
return Query(i * 2 + 1, mid + 1, r, k);
}
int main() {
int t;
cin >> t >> K;
for (int i = 1; i <= t; i++) {
scanf("%s", S1);
int len = (int)strlen(S1);
for (int j = 0; j < len; j++) {
pos[Last_n] = i;
The_len[Last_n] = len - j;
r[Last_n++] = S1[j] - 'a' + 100000;
}
r[Last_n++] = haha++;
}
Last_n--;
Suf_work(Last_n + 1, 110000);
Calheight(Last_n);
RMQ();
memset(flag, 0, sizeof(flag));
int l1 = 1, r1 = 1, l2 = 0, r2 = 0, num = 0;
for (; l1 <= Last_n; l1++) {
if (r[sa[l1]] < 100000) continue;
if (!l2) {
flag[pos[sa[l1]]]++;
num = 1;
r1 = l1;
} else {
flag[pos[sa[l2]]]--;
if (!flag[pos[sa[l2]]]) num--;
}
while (num < K && r1 <= Last_n - 1) {
r1++;
if (!flag[pos[sa[r1]]]) {
flag[pos[sa[r1]]]++;
num++;
} else
flag[pos[sa[r1]]]++;
}
if (num < K) break;
if (l2 != 0) {
for (int i = r2 + 1; i < r1; i++)
Updata(1, 1, 200000, i, i, Get_min(sa[l2], sa[i]));
}
Updata(1, 1, 200000, l1, r1, Get_min(sa[l1], sa[r1]));
l2 = l1;
r2 = r1;
}
if (l2 != 0) {
for (int i = r2 + 1; i <= Last_n; i++)
Updata(1, 1, 200000, i, i, Get_min(sa[l2], sa[i]));
}
for (int i = 1; i <= Last_n; i++) {
Ans[pos[sa[i]]] += Query(1, 1, 200000, i);
}
for (int i = 1; i <= t; i++) {
printf("%I64d ", Ans[i]);
}
cout << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int exp(long long int a, long long int b, long long int m);
long long int tree[4000005][2], lazy[4000005] = {0};
void updateRange(int node, int start, int end, int l, int r, int val) {
if (lazy[node] != 0) {
tree[node][0] += lazy[node];
tree[node][1] += lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start > end or start > r or end < l) return;
if (start >= l and end <= r) {
tree[node][0] += val;
tree[node][1] += val;
if (start != end) {
lazy[node * 2] += val;
lazy[node * 2 + 1] += val;
}
return;
}
int mid = (start + end) / 2;
updateRange(node * 2, start, mid, l, r, val);
updateRange(node * 2 + 1, mid + 1, end, l, r, val);
tree[node][0] = max(tree[node * 2][0], tree[node * 2 + 1][0]);
tree[node][1] = min(tree[node * 2][1], tree[node * 2 + 1][1]);
}
pair<int, int> queryRange(int node, int start, int end, int l, int r) {
if (start > end or start > r or end < l) return {-1000000007, 1000000007};
if (lazy[node] != 0) {
tree[node][0] += lazy[node];
tree[node][1] += lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start >= l and end <= r) return {tree[node][0], tree[node][1]};
int mid = (start + end) / 2;
pair<int, int> p1 = queryRange(node * 2, start, mid, l, r);
pair<int, int> p2 = queryRange(node * 2 + 1, mid + 1, end, l, r);
return {max(p1.first, p2.first), min(p1.second, p2.second)};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
char sb[n + 2];
memset(sb, 'A', sizeof(sb));
long long int ind = 1;
long long int co = 0;
char tu;
for (long long int i = 0; i < n; i++) {
cin >> tu;
if (tu == 'R') {
ind++;
} else if (tu == 'L') {
if (ind > 1) ind--;
} else if (sb[ind] == tu) {
} else if (tu == ')') {
if (sb[ind] == '(') {
co -= 2;
updateRange(1, 1, n, ind, n, -2);
} else {
co--;
updateRange(1, 1, n, ind, n, -1);
}
sb[ind] = tu;
} else if (tu == '(') {
if (sb[ind] == ')') {
co += 2;
updateRange(1, 1, n, ind, n, 2);
} else {
co++;
updateRange(1, 1, n, ind, n, 1);
}
sb[ind] = tu;
} else {
if (sb[ind] == ')') {
co++;
updateRange(1, 1, n, ind, n, 1);
} else if (sb[ind] == '(') {
co--;
updateRange(1, 1, n, ind, n, -1);
}
sb[ind] = tu;
}
if (co == 0) {
pair<int, int> pk = queryRange(1, 1, n, 1, n);
if (pk.second < 0) {
cout << -1 << " ";
} else
cout << pk.first << " ";
} else
cout << -1 << " ";
}
cout << "\n";
return 0;
}
long long int exp(long long int a, long long int b, long long int m) {
if (b == 0) {
return 1;
}
long long int temp = exp(a, b / 2, m);
temp = (temp * temp) % m;
if (b & 1) {
return (temp * (a % m)) % m;
}
return temp;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x;
cin >> x;
switch (x) {
case 1:
cout << "Washington" << endl;
break;
case 2:
cout << "Adams" << endl;
break;
case 3:
cout << "Jefferson" << endl;
break;
case 4:
cout << "Madison" << endl;
break;
case 5:
cout << "Monroe" << endl;
break;
case 6:
cout << "Adams" << endl;
break;
case 7:
cout << "Jackson" << endl;
break;
case 8:
cout << "Van Buren" << endl;
break;
case 9:
cout << "Harrison" << endl;
break;
case 10:
cout << "Tyler" << endl;
break;
case 11:
cout << "Polk" << endl;
break;
case 12:
cout << "Taylor" << endl;
break;
case 13:
cout << "Fillmore" << endl;
break;
case 14:
cout << "Pierce" << endl;
break;
case 15:
cout << "Buchanan" << endl;
break;
case 16:
cout << "Lincoln" << endl;
break;
case 17:
cout << "Johnson" << endl;
break;
case 18:
cout << "Grant" << endl;
break;
case 19:
cout << "Hayes" << endl;
break;
case 20:
cout << "Garfield" << endl;
break;
case 21:
cout << "Arthur" << endl;
break;
case 22:
cout << "Cleveland" << endl;
break;
case 23:
cout << "Harrison" << endl;
break;
case 24:
cout << "Cleveland" << endl;
break;
case 25:
cout << "McKinley" << endl;
break;
case 26:
cout << "Roosevelt" << endl;
break;
case 27:
cout << "Taft" << endl;
break;
case 28:
cout << "Wilson" << endl;
break;
case 29:
cout << "Harding" << endl;
break;
case 30:
cout << "Coolidge" << endl;
break;
case 31:
cout << "Hoover" << endl;
break;
case 32:
cout << "Roosevelt" << endl;
break;
case 33:
cout << "Truman" << endl;
break;
case 34:
cout << "Eisenhower" << endl;
break;
case 35:
cout << "Kennedy" << endl;
break;
case 36:
cout << "Johnson" << endl;
break;
case 37:
cout << "Nixon" << endl;
break;
case 38:
cout << "Ford" << endl;
break;
case 39:
cout << "Carter" << endl;
break;
case 40:
cout << "Reagan" << endl;
break;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Result {
int tank, tap, diameter;
Result() : tank(0), tap(0), diameter(0) {}
Result(int a, int b, int c) : tank(a), tap(b), diameter(c) {}
bool operator<(const Result& a) const { return tank < a.tank; }
};
int n, p, es[1002][1002], a, b, res_size;
bool used[1002];
Result result[1002];
void dfs(int from, int cur, int meter) {
if (used[cur]) return;
used[cur] = true;
for (int i = 0; i < (int)n; i++)
if (es[cur][i] > 0) {
dfs(from, i, min(meter, es[cur][i]));
return;
}
if (from != cur) {
result[res_size] = Result(from + 1, cur + 1, meter);
res_size++;
}
}
int main(int argc, char* argv[]) {
memset(es, -1, sizeof es);
set<int> taps;
cin >> n >> p;
for (int i = 0; i < (int)p; i++) {
cin >> a >> b;
a--;
b--;
taps.insert(b);
cin >> es[a][b];
}
fill(used, used + n, false);
for (int i = 0; i < (int)n; i++) {
if (!used[i] && !taps.count(i)) dfs(i, i, 1 << 28);
}
if (res_size) {
sort(result, result + res_size);
printf("%d\n", res_size);
for (int i = 0; i < (int)res_size; i++)
printf("%d %d %d\n", result[i].tank, result[i].tap, result[i].diameter);
} else {
puts("0");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long inv(long long i) {
if (i == 1) return 1;
return (mod - ((mod / i) * inv(mod % i)) % mod) % mod;
}
long long mod_mul(long long a, long long b) {
a = a % mod;
b = b % mod;
return (((a * b) % mod) + mod) % mod;
}
long long mod_add(long long a, long long b) {
a = a % mod;
b = b % mod;
return (((a + b) % mod) + mod) % mod;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long ceil_div(long long a, long long b) {
return a % b == 0 ? a / b : a / b + 1;
}
long long pwr(long long a, long long b) {
a %= mod;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t, n, i, j, ans, temp, sum;
string sans;
t = 1;
cin >> t;
while (t--) {
sans = "NO";
ans = temp = sum = 0;
cin >> n;
if (n == 1) {
cout << "a\n";
continue;
}
sans = "";
long long k = n / 2;
for (i = 1; i <= k; i++) {
sans += 'a';
}
sans += 'b';
if (n & 1) sans += 'c';
for (i = 1; i <= k - 1; i++) sans += 'a';
cout << sans << "\n";
}
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.