solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int a[55][55];
int main() {
int m, n, i, j, k;
cin >> n >> m;
int ar[n][m];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> ar[i][j];
}
}
vector<int> v1, v2;
for (i = 0; i < n - 1; i++) {
for (j = 0; j < m - 1; j++) {
if (ar[i][j] == 1 && ar[i][j + 1] == 1 && ar[i + 1][j] == 1 &&
ar[i + 1][j + 1]) {
a[i][j] = 1;
a[i][j + 1] = 1;
a[i + 1][j] = 1;
a[i + 1][j + 1] = 1;
v1.push_back(i + 1);
v2.push_back(j + 1);
}
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (ar[i][j] != a[i][j]) {
cout << -1 << endl;
return 0;
}
}
}
cout << v1.size() << endl;
for (i = 0; i < v1.size(); i++) {
cout << v1[i] << " " << v2[i] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int fst[100020], nxt[200030], vv[200030], e;
int fa[22][100020], dep[100020], sz[100020];
long long dis[100020], disPar[100020];
int n, m;
void init() {
memset(fst, -1, sizeof fst);
e = 0;
}
void add(int u, int v) { vv[e] = v, nxt[e] = fst[u], fst[u] = e++; }
void dfs(int u, int p, int d) {
fa[0][u] = p;
sz[u] = 1;
dis[u] = 0;
dep[u] = d;
for (int i = fst[u]; ~i; i = nxt[i]) {
int v = vv[i];
if (v == p) continue;
dfs(v, u, d + 1);
sz[u] += sz[v];
dis[u] += dis[v] + sz[v];
}
}
void dfs1(int u, int p, long long d) {
disPar[u] = d;
for (int i = fst[u]; ~i; i = nxt[i]) {
int v = vv[i];
if (v == p) continue;
long long t = d + dis[u];
t -= dis[v] + sz[v];
t += n - sz[v];
dfs1(v, u, t);
}
}
void lcaInit() {
for (int k = 0; k < 20; ++k) {
for (int i = 1; i <= n; ++i) {
fa[k + 1][i] = fa[k][fa[k][i]];
}
}
}
int lca(int u, int v) {
if (dep[u] > dep[v]) swap(u, v);
for (int k = 0; k <= 20; ++k) {
if ((dep[v] - dep[u]) >> k & 1) v = fa[k][v];
}
if (u == v) return u;
for (int k = 20; k >= 0; --k) {
if (fa[k][u] != fa[k][v]) u = fa[k][u], v = fa[k][v];
}
return fa[0][u];
}
int kfa(int u, int k) {
for (int i = 0; i <= 20; ++i) {
if (k >> i & 1) u = fa[i][u];
}
return u;
}
int main() {
scanf("%d%d", &n, &m);
init();
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
dfs(1, 0, 0);
dfs1(1, 0, 0);
lcaInit();
while (m--) {
int u, v, p;
scanf("%d%d", &u, &v);
if (dep[u] > dep[v]) swap(u, v);
p = lca(u, v);
double ans = 0;
if (p != u) {
ans = dep[u] + dep[v] - 2 * dep[p] + 1;
ans += (dis[u] * sz[v] + dis[v] * sz[u]) * 1.0 / sz[u] / sz[v];
} else {
int w = kfa(v, dep[v] - dep[u] - 1);
long long tmp = disPar[u] + dis[u] - dis[w] - sz[w];
ans = dep[v] - dep[u] + 1;
ans += (dis[v] * (n - sz[w]) + tmp * sz[v]) * 1.0 / sz[v] / (n - sz[w]);
}
printf("%.8f\n", ans);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1E5 + 5;
int n;
vector<multiset<int> > graph;
vector<int> v;
vector<pair<int, int> > edge;
void dfs(int src) {
while (!graph[src].empty()) {
int edge_idx = *(graph[src].begin());
int u = edge[edge_idx].first;
int v1 = edge[edge_idx].second;
v1 = u + v1 - src;
graph[src].erase(graph[src].begin());
graph[v1].erase(graph[v1].find(edge_idx));
dfs(v1);
}
v.push_back(src);
}
void eular(int idx) {
vector<int> odd;
for (int i = 0; i < idx; i++)
if (graph[i].size() & 1) odd.push_back(i);
if (odd.size() > 2) return;
if (odd.size() == 0) {
odd.push_back(0);
odd.push_back(0);
}
dfs(odd[0]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
map<int, int> m;
int brr[n], crr[n];
for (int i = 0; i < n - 1; i++) cin >> brr[i];
for (int i = 0; i < n - 1; i++) {
cin >> crr[i];
if (brr[i] > crr[i]) {
cout << -1 << endl;
return 0;
}
m[brr[i]] = 1;
m[crr[i]] = 1;
}
int idx = 0;
int Actual_No[n];
for (auto k : m) {
m[k.first] = idx;
Actual_No[idx++] = k.first;
}
graph.assign(idx, multiset<int>());
for (int i = 0; i < n - 1; i++) {
brr[i] = m[brr[i]];
crr[i] = m[crr[i]];
graph[brr[i]].insert(i);
graph[crr[i]].insert(i);
edge.push_back({brr[i], crr[i]});
}
eular(idx);
if (v.size() < n) {
cout << -1 << endl;
return 0;
}
for (auto k : v) cout << Actual_No[k] << " ";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 2e6 + 100;
const int mod = 998244353;
int f[20][20][20];
char s[maxn];
void solve(int x, int y) {
bool vis[20];
memset(vis, 0, sizeof(vis));
queue<int> q;
q.push(0);
memset(f[x][y], 0, sizeof(f[x][y]));
while (!q.empty()) {
int top = q.front();
q.pop();
int z = (top + x) % 10;
int bef = f[x][y][top];
if (!vis[z]) {
q.push(z);
vis[z] = true;
f[x][y][z] = bef + 1;
}
z = (top + y) % 10;
if (!vis[z]) {
q.push(z);
vis[z] = true;
f[x][y][z] = bef + 1;
}
}
}
int n;
int cal(int x, int y) {
int cnt = 0;
int be = 2;
if (s[1] == '0') {
} else {
if (f[x][y][s[1] - '0'] == 0) return -1;
cnt += f[x][y][s[1] - '0'];
}
for (int i = be; i <= n; i++) {
if (f[x][y][(s[i] - s[i - 1] + 10) % 10] == 0) return -1;
cnt += (f[x][y][(s[i] - s[i - 1] + 10) % 10]);
}
return cnt;
}
int main() {
for (int i = 0; i <= 9; i++) {
for (int j = 0; j <= 9; j++) {
solve(i, j);
}
}
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 0; i <= 9; i++) {
for (int j = 0; j <= 9; j++) {
int tmp = cal(i, j);
if (tmp == -1)
printf("-1 ");
else
printf("%d ", cal(i, j) - n + (s[1] == '0'));
}
printf("\n");
}
}
| 4 |
#include <bits/stdc++.h>
const int maxn = 1e5 + 1, maxm = 1e2 + 1;
int n, q, u, v, k, sum[maxn], cur[maxn];
double f[maxn][maxm + 5], c[maxn * 5 + maxm][10], ans, tmp;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", sum + i), cur[i] = sum[i], f[i][sum[i]] = 1, ans += f[i][0];
for (int i = 0; i < maxn * 5 + maxm; i++) c[i][0] = 1;
for (int i = 1; i < maxn * 5 + maxm; i++)
for (int j = 1; j <= i && j <= 5; j++)
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
scanf("%d", &q);
while (q--) {
scanf("%d%d%d", &u, &v, &k), ans -= f[u][0];
for (int i = 0; i <= sum[u]; i++) {
for (int j = i; j <= i + k && j <= cur[u]; j++)
tmp += f[u][j] * c[j][j - i] * c[cur[u] - j][k - j + i];
f[u][i] = tmp / c[cur[u]][k], tmp = 0;
}
cur[u] -= k, cur[v] += k, printf("%.9lf\n", ans += f[u][0]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long T, m, n, q, w, mi, ma, cnt, s, fi, cc, e, r, z, x, next;
long long t[10], k[10];
bool finish;
queue<long long> qq[6];
int main() {
t[0] = 0;
scanf("%I64d%I64d%I64d", &k[1], &k[2], &k[3]);
scanf("%I64d%I64d%I64d", &t[1], &t[2], &t[3]);
scanf("%I64d", &m);
for (int i = 0; i < m; i++) {
scanf("%I64d", &s);
qq[0].push(s);
if (i == m - 1) e = s;
}
T = 0;
finish = false;
k[4] = 10000000;
while (!finish) {
n = ((long long)1 << (long long)40);
for (int i = 3; i >= 0; i--)
if (!qq[i].empty() && (long long)qq[i + 1].size() < k[i + 1])
n = min(n, qq[i].front() + t[i] - T);
n = max(1LL, n);
T += n;
for (int i = 3; i >= 0; i--) {
while ((!qq[i].empty()) && (qq[i].front() <= T) &&
(qq[i].front() + t[i] <= T) &&
(long long)qq[i + 1].size() < k[i + 1]) {
qq[i + 1].push(T);
qq[i].pop();
}
}
if ((long long)qq[4].size() == m) finish = true;
}
printf("%I64d\n", T - e);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const long long linf = 1ll << 60;
const double dinf = 1e10;
void scf(int &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
void scf(int &x, int &y) {
scf(x);
return scf(y);
}
void scf(int &x, int &y, int &z) {
scf(x);
scf(y);
return scf(z);
}
const int N = 10005;
short f[N][N];
int a[N], b[N];
int n, m, k1, k2;
int main() {
scf(n, m);
scf(k1);
for (int i = (1); i <= (k1); i++) scf(a[i]);
sort(a + 1, a + k1 + 1);
scf(k2);
for (int i = (1); i <= (k2); i++) scf(b[i]);
sort(b + 1, b + k2 + 1);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) {
int d1 = i + j, d2 = i + m + 1 - j;
f[d1][d2]++;
}
for (int i = (n + m); i >= (1); i--)
for (int j = (n + m); j >= (1); j--)
f[i][j] += f[i + 1][j] + f[i][j + 1] - f[i + 1][j + 1];
for (int i = (0); i <= (k1); i++)
for (int j = (0); j <= (k2); j++)
if (f[a[i] + 1][b[j] + 1] > n * m - i - j) {
puts("NO");
return 0;
}
puts("YES");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[5005];
int solve(int l, int r, int val, int sz) {
int i;
bool f = false;
if (val > a[l]) return 0;
for (i = l; i <= r; i++) {
if (a[i] - val + 1 <= sz) {
f = true;
break;
}
}
if (!f) return sz;
int ret = 1;
int s, e;
for (i = l; i <= r; i++) {
if (a[i] > val) {
s = i;
e = i - 1;
while (i <= r && a[i] > val) {
e++;
i++;
}
ret += solve(s, e, val + 1, (e - s + 1));
}
}
return min(ret, sz);
}
int main() {
int n, i;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
printf("%d\n", solve(0, n - 1, 1, n));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, t, p, i;
int main() {
cin >> n >> a >> b;
p = b * n;
while (n > 1) {
t += 2 * a + 1;
n--;
}
cout << t << " " << p;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
bool vis[2000];
struct st {
int v, l, r;
st() {}
st(int _v, int _l, int _r) {
v = _v;
l = _l;
r = _r;
}
};
int gl, gr;
vector<st> g[2000];
void dfs(int v) {
vis[v] = 1;
for (auto x : g[v]) {
if (!vis[x.v] and x.l <= gl and gr <= x.r) dfs(x.v);
}
}
bool func(int l, int r) {
for (int i = 0; i < n; i++) vis[i] = 0;
gl = l;
gr = r;
dfs(0);
return vis[n - 1];
}
int bs(int l) {
int hi = 1e6 + 5;
int lo = l + 1;
int mid;
while (hi - lo > 1) {
mid = (hi + lo) / 2;
if (func(l, mid))
lo = mid;
else
hi = mid;
}
return lo;
}
int main() {
cin >> n >> m;
long long int u, v, l, r;
vector<int> lk;
while (m--) {
cin >> u >> v >> l >> r;
u--;
v--;
g[u].push_back(st(v, l, r));
g[v].push_back(st(u, l, r));
lk.push_back(l);
}
sort(lk.begin(), lk.end());
long long int ans = 0;
for (auto x : lk) {
if (func(x, x + 1)) {
r = bs(x);
ans = max(ans, r - x + 1);
}
if (ans == 0 and func(x, x)) {
ans = 1;
}
}
if (ans == 0) {
cout << "Nice work, Dima!\n";
} else
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s, b;
int a[1111111], o[1111111], v[1111111];
int n, m, r = 0, x = 0, i, j = 0, mi = 0, ma = 0, ii = 88, iii = 88, iiii = 88,
h = 0, e;
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i] >> o[i];
x += a[i];
if (ma < o[i]) {
ma = o[i];
ii = i;
}
}
for (i = 0; i < n; i++) {
if (h < o[i] && i != ii) {
h = o[i];
}
}
for (i = 0; i < n; i++) {
e = (x - a[i]);
if (ii != i) {
v[mi] = (e * ma);
mi++;
} else if (ii == i) {
v[mi] = (e * h);
mi++;
}
}
for (i = 0; i < mi; i++) {
cout << v[i] << ' ';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n % 2 == 0) {
cout << "-1";
return 0;
}
for (int i = 0; i < 2; i++) {
for (int y = 0; y < n; y++) {
cout << y << " ";
}
cout << endl;
}
for (int i = 0; i < n; i++) {
cout << (2 * i) % n << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll q, n, ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> q;
for (int i = 0; i < q; i++) {
ans = 0;
cin >> n;
while (n != 1) {
if (n % 2 == 0) {
n /= 2;
ans++;
} else if (n % 3 == 0) {
n = (n / 3) * 2;
ans++;
} else if (n % 5 == 0) {
n = (n / 5) * 4;
ans++;
} else {
ans = -1;
break;
}
}
cout << ans << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int n = s.size();
int countf[n], count1 = 0, count0 = 0;
countf[0] = s[0] - '0';
if (s[0] == '1') {
count1++;
} else {
count0++;
}
for (int i = 1; i < n; ++i) {
if (s[i] == '1') {
count1++;
} else {
count0++;
}
countf[i] = count1 - count0;
if (countf[i] <= 0) {
count1 = 0;
count0 = 0;
if (s[i] == '1') {
count1++;
}
countf[i] = count1 - count0;
if (s[i] == '0') {
count0++;
}
}
}
for (int i = n - 1; i > 0; i--) {
countf[i - 1] = min(countf[i], countf[i - 1]);
}
int changed = 0;
for (int i = 0; i < n; i++) {
if ((countf[i] - changed) > 0) {
if (s[i] == '1') {
s[i] = '0';
changed++;
}
}
}
for (int i = 0; i < n; i++) {
cout << s[i];
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
int cnt = 0;
for (int i = 0; i < s.size(); i++) {
if (cnt == 26) break;
if (s[i] - 'a' <= cnt) {
s[i] = 'a' + cnt;
cnt++;
}
}
if (cnt < 26)
printf("-1\n");
else
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool check_prime(int n) {
for (int i = 2; i < min(n, 50000); i++) {
if (n % i == 0) return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n == 2) {
cout << "Ashishgup" << endl;
continue;
}
if (n == 1 || (n > 2 && (n & n - 1) == 0) ||
(n % 2 == 0 && check_prime(n / 2) == 1))
cout << "FastestFinger" << endl;
else
cout << "Ashishgup" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 10;
const int inf = 1e9 + 10;
const int N = 1e6 + 10;
struct segment_tree {
int n;
struct node {
long long sum_cookie = 0, sum_time;
};
vector<node> t;
void build(int sz) {
n = sz;
t.resize(n * 4 + n);
}
void modify(int v, int tl, int tr, int cost, int col_cookie) {
if (tl == tr) {
t[v].sum_cookie += col_cookie;
t[v].sum_time = t[v].sum_cookie * cost;
} else {
int tm = (tl + tr) / 2;
if (cost <= tm) {
modify(v * 2, tl, tm, cost, col_cookie);
} else {
modify(v * 2 + 1, tm + 1, tr, cost, col_cookie);
}
t[v].sum_cookie = t[v * 2].sum_cookie + t[v * 2 + 1].sum_cookie;
t[v].sum_time = t[v * 2].sum_time + t[v * 2 + 1].sum_time;
}
}
void modify(int cost, int col_cookie) { modify(1, 1, n, cost, col_cookie); }
long long get(int v, int tl, int tr, long long now) {
if (tl == tr) {
return min(now / tl, t[v].sum_cookie);
} else {
int tm = (tl + tr) / 2;
if (t[v * 2].sum_time <= now) {
return t[v * 2].sum_cookie +
get(v * 2 + 1, tm + 1, tr, now - t[v * 2].sum_time);
} else {
return get(v * 2, tl, tm, now);
}
}
}
long long get(long long now) {
if (now < 0) {
return 0;
}
return get(1, 1, n, now);
}
};
long long T;
segment_tree omegakek;
vector<long long> dp, a, b;
vector<vector<pair<int, int> > > g;
void dfs(int v, long long dist) {
omegakek.modify(b[v], a[v]);
multiset<long long> res;
for (auto to : g[v]) {
dfs(to.first, dist + to.second);
res.insert(-dp[to.first]);
if (res.size() > 2) {
res.erase(--res.end());
}
}
dp[v] = omegakek.get(T - dist * 2);
if (res.size() > 1 && v != 1) {
dp[v] = max(dp[v], -1 * *++res.begin());
}
if (res.size() && v == 1) {
dp[v] = max(dp[v], -1 * *res.begin());
}
omegakek.modify(b[v], -1 * a[v]);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int n;
cin >> n >> T;
a.resize(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
b.resize(n + 1);
for (int i = 1; i <= n; i++) {
cin >> b[i];
}
g.resize(n + 1);
for (int i = 2; i <= n; i++) {
int p, cost;
cin >> p >> cost;
g[p].push_back(make_pair(i, cost));
}
omegakek.build(N);
dp.resize(n + 1);
dfs(1, 0);
cout << dp[1] << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
int n, h, a, b, k;
cin >> n >> h >> a >> b >> k;
while (k--) {
int t1, f1, t2, f2;
cin >> t1 >> f1 >> t2 >> f2;
if (t2 == t1) {
cout << abs(f2 - f1) << "\n";
continue;
}
int total = abs(t2 - t1);
if (f1 < a && f2 < a) {
total += abs(f1 - a);
total += abs(f2 - a);
} else if (f1 > b && f2 > b) {
total += abs(f1 - b);
total += abs(f2 - b);
} else {
total += abs(f2 - f1);
}
cout << total << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 1000;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
long long pre[maxn];
long long a[20][maxn];
long long sum[maxn];
int main(void) {
long long n, m;
n = read();
m = read();
for (long long i = 1; i <= m; i++) {
for (long long j = 1; j <= n; j++) {
pre[j] = read();
a[i][pre[j]] = pre[j - 1];
}
}
long long ans = n;
for (long long i = 2; i <= n; i++) {
bool flag = 1;
for (long long j = 1; j < m; j++) {
if (a[j][pre[i]] != a[m][pre[i]]) {
flag = 0;
break;
}
}
if (flag == 1) {
sum[i] = sum[i - 1] + 1;
ans += sum[i];
}
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3006;
struct arr {
int x, y, i;
} a[maxn];
int r, c, n, K;
int pos[maxn], L[maxn], R[maxn];
long long ans;
bool cmpx(arr x, arr y) {
if (x.x == y.x) return x.y < y.y;
return x.x < y.x;
}
bool cmpy(arr x, arr y) {
if (x.y == y.y) return x.x < y.x;
return x.y < y.y;
}
int main() {
scanf("%d%d%d%d", &r, &c, &n, &K);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].x, &a[i].y);
sort(a + 1, a + n + 1, cmpy);
for (int i = 1; i <= n; i++) a[i].i = i;
sort(a + 1, a + n + 1, cmpx);
for (int i = 1; i <= n; i++) L[i] = i - 1;
for (int i = 1; i <= n; i++) R[i] = i + 1;
for (int i = 1; i <= n; i++) pos[a[i].i] = i;
R[0] = 1;
L[n + 1] = n;
pos[n + 1] = n + 1;
a[n + 1].x = r + 1;
a[n + 1].y = c + 1;
int nn = n;
for (int i = r; i >= 1; i--) {
int t = 0;
long long tmp = 0;
for (int j = 1; j <= n && a[j].x <= i; t = j++)
R[L[a[j].i]] = R[a[j].i], L[R[a[j].i]] = L[a[j].i];
for (int j = i, k = t; j >= 1; ans += tmp, j--) {
for (; a[k].x == j; k--) {
R[L[a[k].i]] = a[k].i;
L[R[a[k].i]] = a[k].i;
int val = 1, lp = a[k].i, rp = a[k].i;
for (; L[lp] && val < K; lp = L[lp], val++)
;
for (; lp <= a[k].i; lp = R[lp], val--) {
for (; R[rp] <= n && val < K; rp = R[rp], val++)
;
if (val < K) break;
long long tmp_1 = a[pos[lp]].y - a[pos[L[lp]]].y;
long long tmp_2 = a[pos[R[rp]]].y - a[pos[rp]].y;
tmp += tmp_1 * tmp_2;
}
}
}
while (a[nn].x == i) {
R[L[a[nn].i]] = R[a[nn].i];
L[R[a[nn].i]] = L[a[nn].i];
nn--;
}
}
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using namespace std;
void debugi(vector<int>& vec) {
int n = (int)vec.size();
for (int i = 0; i < n; i++) {
cout << vec[i] << " ";
}
cout << endl;
}
void debugd(vector<long double>& vec) {
int n = (int)vec.size();
for (int i = 0; i < n; i++) {
cout << vec[i] << " ";
}
cout << endl;
}
void debugl(vector<ll>& vec) {
int n = (int)vec.size();
for (int i = 0; i < n; i++) {
cout << vec[i] << " ";
}
cout << endl;
}
void debugmap(map<int, int>& mp) {
for (auto x : mp) {
cout << x.first << " " << x.second << " , ";
}
cout << endl;
}
void debugset(set<int>& st) {
for (auto x : st) {
cout << x << " ";
}
cout << endl;
}
void debugparri(vector<pair<int, int>>& arr) {
for (int i = 0; i < (int)arr.size(); i++) {
cout << "[" << arr[i].first << " : " << arr[i].second << "]"
<< " ";
}
cout << endl;
}
void debugpi(pair<int, int>& pi) {
cout << pi.first << " " << pi.second << endl;
}
void debugq(queue<int> q) {
while (!q.empty()) {
cout << q.front() << " ";
q.pop();
}
cout << endl;
}
bool check(int n, int i, int j) {
if ((0 <= i & i < n) && (0 <= j & j < n)) {
return true;
}
return false;
}
ll MOD = 1e9 + 7;
ll powab(ll a, ll b, ll mod) {
if (b == 0) {
return 1;
}
ll z = powab(a, b / 2, mod);
ll res = (z * z * 1LL) % mod;
if (b & 1) {
res = (res * 1LL * a) % mod;
}
return res;
}
ll gcd(ll a, ll b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
void upd(int k, int x, vector<int>& tree, int n) {
if (k == 0) {
return;
}
while (k <= n) {
tree[k] += x;
k += (k & -k);
}
}
int sum(int k, vector<int>& tree, int n) {
int s = 0;
while (k >= 1) {
s += tree[k];
k -= (k & -k);
}
return s;
}
ll mod = 998244353;
void solve() {
string s;
cin >> s;
int n = s.size();
vector<int> a(n);
vector<vector<int>> dp(3);
int sum = 0;
for (int i = 0; i < n; i++) {
a[i] = s[i] - '0';
int rem = a[i] % 3;
sum += a[i];
dp[rem].push_back(i);
}
if (sum % 3 == 0) {
cout << s << endl;
return;
}
if (sum % 3 == 1) {
vector<char> ans1, ans2;
int len1 = 0, len2 = 0, m1 = 0, m2 = 0;
if (dp[1].size() != 0) {
int last = dp[1].size();
int remove = dp[1][last - 1];
for (int i = 0; i < n; i++) {
if (i == remove) {
continue;
}
ans1.push_back(s[i]);
}
m1 = ans1.size();
int j = 0;
for (int i = 0; i < m1; i++) {
if (ans1[i] == '0') {
j += 1;
} else {
break;
}
}
len1 = m1 - j;
}
if (dp[2].size() < 2) {
len2 = 0;
} else {
int k = dp[2].size();
int rem1 = dp[2][k - 1], rem2 = dp[2][k - 2];
for (int i = 0; i < n; i++) {
if (i == rem1 || i == rem2) {
continue;
}
ans2.push_back(s[i]);
}
m2 = ans2.size();
int j = 0;
for (int i = 0; i < m2; i++) {
if (ans2[i] == '0') {
j += 1;
} else {
break;
}
}
len2 = m2 - j;
}
if (len1 > len2) {
int j = 0;
for (int i = 0; i < m1; i++) {
if (ans1[i] == '0') {
j += 1;
continue;
}
break;
}
for (int i = j; i < m1; i++) {
cout << ans1[i];
}
cout << endl;
return;
}
if (len2 == 0 && len1 == 0) {
if (m2 != 0) {
cout << '0' << endl;
return;
}
if (m1 != 0) {
cout << '0' << endl;
return;
}
cout << -1 << endl;
return;
}
int j = 0;
for (int i = 0; i < m2; i++) {
if (ans2[i] == '0') {
j += 1;
continue;
}
break;
}
for (int i = j; i < m2; i++) {
cout << ans2[i];
}
cout << endl;
return;
}
if (sum % 3 == 2) {
vector<char> ans1, ans2;
int len1 = 0, len2 = 0, m1 = 0, m2 = 0;
if (dp[2].size() != 0) {
int last = dp[2].size();
int remove = dp[2][last - 1];
for (int i = 0; i < n; i++) {
if (i == remove) {
continue;
}
ans1.push_back(s[i]);
}
m1 = ans1.size();
int j = 0;
for (int i = 0; i < m1; i++) {
if (ans1[i] == '0') {
j += 1;
} else {
break;
}
}
len1 = m1 - j;
}
if (dp[1].size() < 2) {
len2 = 0;
} else {
int k = dp[1].size();
int rem1 = dp[1][k - 1], rem2 = dp[1][k - 2];
for (int i = 0; i < n; i++) {
if (i == rem1 || i == rem2) {
continue;
}
ans2.push_back(s[i]);
}
m2 = ans2.size();
int j = 0;
for (int i = 0; i < m2; i++) {
if (ans2[i] == '0') {
j += 1;
} else {
break;
}
}
len2 = m2 - j;
}
if (len1 > len2) {
int j = 0;
for (int i = 0; i < m1; i++) {
if (ans1[i] == '0') {
j += 1;
continue;
}
break;
}
for (int i = j; i < m1; i++) {
cout << ans1[i];
}
cout << endl;
return;
}
if (len2 == 0 && len1 == 0) {
if (m2 != 0) {
cout << '0' << endl;
return;
}
if (m1 != 0) {
cout << '0' << endl;
return;
}
cout << -1 << endl;
return;
}
int j = 0;
for (int i = 0; i < m2; i++) {
if (ans2[i] == '0') {
j += 1;
continue;
}
break;
}
for (int i = j; i < m2; i++) {
cout << ans2[i];
}
cout << endl;
return;
}
cout << -1 << endl;
return;
}
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
for (int tt = 0; tt < t; tt++) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void reader() {}
void IOFast() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
void solve() {
string s;
long long n;
cin >> n;
cin >> s;
long long c = 0, d = 0;
for (auto i : s)
if (i == 'L')
c--;
else
d++;
cout << d - c + 1;
cout << "\n";
}
signed main() {
reader();
IOFast();
long long t = 1;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
const int mod = (int)1e9 + 7;
const int logN = 19;
const int inf = 1e9;
const int N = 6e5 + 55;
const int SQ = 200;
int S, q, sorted[N], start[N], finish[N], LOG[N];
int suff[N], h[N], ww[N], l, r, rmq[N][logN + 1], bel[N], belong[N], cnt[N], n,
m, x, y, z, asd[N], asdsad[N], wh[N], w[N];
pair<int, int> mx[N], ans[N];
vector<pair<pair<int, int>, pair<pair<int, int>, int> > > v[N];
pair<pair<int, int>, int> C[N], temp[N];
char s[N], s2[N];
int get(int x, int y) {
--y;
if (x > y) return inf;
int t = LOG[y - x + 1];
return min(rmq[x][t], rmq[y - (1 << t) + 1][t]);
}
pair<int, int> cmp(pair<int, int> x, pair<int, int> y) {
if (x.first != y.first) {
if (x > y) return x;
return y;
}
if (x < y) return x;
return y;
}
pair<int, int> tet(int x, int y) {
pair<int, int> ans = make_pair(0, x);
if (bel[x] == bel[y]) {
for (int i = x; i <= y; i++) ans = cmp(ans, make_pair(cnt[i], i));
return ans;
}
int t1 = bel[x] + 1, t2 = bel[y] - 1;
for (int i = t1; i <= t2; i++) ans = cmp(ans, mx[i]);
for (int i = finish[bel[x]]; i >= x; i--)
ans = cmp(ans, make_pair(cnt[i], i));
for (int i = start[bel[y]]; i <= y; i++) ans = cmp(ans, make_pair(cnt[i], i));
return ans;
}
void add(int x) {
int t = bel[x];
++cnt[x];
mx[t] = cmp(mx[t], make_pair(cnt[x], x));
}
void counting_sort() {
memset(h, 0, sizeof h);
for (int i = 1; i <= n; i++) h[C[i].first.second]++;
for (int i = 1; i <= N - 1; i++) h[i] += h[i - 1];
for (int i = 1; i <= n; i++) temp[h[C[i].first.second]--] = C[i];
memset(h, 0, sizeof h);
for (int i = 1; i <= n; i++) h[temp[i].first.first]++;
for (int i = 1; i <= N - 1; i++) h[i] += h[i - 1];
for (int i = n; i >= 1; i--) C[h[temp[i].first.first]--] = temp[i];
}
void suffix_array() {
for (int i = 1; i <= n; i++) suff[i] = s[i];
for (int i = 1; i <= logN; i++) {
for (int j = 1; j <= n; j++)
C[j] =
make_pair(make_pair(suff[j], suff[min(n + 1, j + (1 << i - 1))]), j);
counting_sort();
for (int j = 1; j <= n; j++)
suff[C[j].second] =
suff[C[j - 1].second] + (C[j - 1].first != C[j].first);
}
}
pair<int, int> get(int x, int y, int l, int r) {
for (int i = x; i <= y; i++) cnt[ww[i]]++;
pair<int, int> ans = make_pair(0, l);
for (int i = x; i <= y; i++)
if (l <= ww[i] && ww[i] <= r) ans = cmp(ans, make_pair(cnt[ww[i]], ww[i]));
for (int i = x; i <= y; i++) cnt[ww[i]]--;
return ans;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
s[++n] = '#';
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%s", s2 + 1);
int m = strlen(s2 + 1);
for (int j = n + 1; j <= n + m; j++) {
s[j] = s2[j - n];
belong[j] = i;
}
n += m;
s[++n] = '$';
}
suffix_array();
for (int i = 1; i <= n; i++) sorted[suff[i]] = i;
int j = 0;
for (int i = 1; i <= n; i++) {
if (j) j--;
if (suff[i] == 1) continue;
while (i + j <= n && sorted[suff[i] - 1] + j <= n &&
s[i + j] == s[sorted[suff[i] - 1] + j])
j++;
rmq[suff[i] - 1][0] = j;
}
for (int i = 1; i <= logN; i++)
for (int j = 1; j <= n - 1; j++)
rmq[j][i] = min(rmq[j][i - 1], rmq[min(n - 1, j + (1 << i - 1))][i - 1]);
for (int i = 1; i <= N - 1; i++) LOG[i] = log2(i);
scanf("%d", &q);
int t = 0, tt = 0;
for (int i = 1; i <= n; i++) {
if (belong[sorted[i]]) {
++t;
ww[t] = belong[sorted[i]];
wh[i] = t;
tt = i;
}
asdsad[i] = tt;
}
tt = inf;
for (int i = n; i >= 1; i--) {
if (belong[sorted[i]]) tt = i;
asd[i] = tt;
}
for (int i = 1; i <= q; i++) {
scanf("%d %d %d %d", &l, &r, &x, &y);
int f = suff[x], sz = y - x + 1;
int bas = 1, son = f;
while (bas < son) {
if (get((bas + son >> 1), f) >= sz)
son = (bas + son >> 1);
else
bas = (bas + son >> 1) + 1;
}
int lll = bas;
bas = f, son = n;
while (bas < son) {
int ort = bas + son + 1 >> 1;
if (get(f, ort) >= sz)
bas = ort;
else
son = ort - 1;
}
int rrr = bas;
lll = asd[lll];
rrr = asdsad[rrr];
if (lll > rrr) {
ans[i] = make_pair(0, l);
} else {
lll = wh[lll];
rrr = wh[rrr];
if (rrr - lll <= 2 * SQ)
ans[i] = get(lll, rrr, l, r);
else
v[lll / SQ].push_back(
make_pair(make_pair(rrr, lll), make_pair(make_pair(l, r), i)));
}
}
int last = 1;
for (int i = 1; i <= m; i++)
if (i == m || i % SQ == 0) {
start[++S] = last;
finish[S] = i;
for (int j = last; j <= i; j++) bel[j] = S;
last = i + 1;
}
for (int i = 0; i <= N - 1; i++) {
if (!v[i].size()) continue;
sort(v[i].begin(), v[i].end());
int j = (i + 1) * SQ - 1, g = j;
for (int j = N - 1; j >= 0; j--) {
cnt[j] = 0;
mx[bel[j]] = make_pair(0, j);
}
for (__typeof(v[i].begin()) it = v[i].begin(); it != v[i].end(); it++) {
while (j < it->first.first) add(ww[++j]);
pair<int, int> ans = make_pair(0, it->second.first.first);
ans = tet(it->second.first.first, it->second.first.second);
for (int jh = it->first.second; jh <= g; jh++)
if (it->second.first.first <= ww[jh] &&
ww[jh] <= it->second.first.second) {
ans = cmp(ans, make_pair(++cnt[ww[jh]], ww[jh]));
}
for (int jh = it->first.second; jh <= g; jh++)
if (it->second.first.first <= ww[jh] &&
ww[jh] <= it->second.first.second)
--cnt[ww[jh]];
::ans[it->second.second] = ans;
}
}
for (int i = 1; i <= q; i++) {
printf("%d %d\n", ans[i].second, ans[i].first);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 110;
int n, m;
long long k;
int p[maxN << 1];
const long long INF = 1.1e18;
int arr[maxN << 1];
const int O = 150;
bool vis[maxN << 1][maxN << 2];
long long memo[maxN << 1][maxN << 2];
long long dp(int pos, int sum) {
if (sum < 0) return 0;
if (pos == n + m - 1) return sum == 0;
if (vis[pos][sum]) return memo[pos][sum];
long long &ans = memo[pos][sum] = 0;
if (arr[pos])
ans = dp(pos + 1, sum + arr[pos]);
else {
ans += dp(pos + 1, sum + 1);
ans += dp(pos + 1, sum - 1);
ans = min(ans, INF);
}
vis[pos][sum] = 1;
return ans;
}
int main() {
cin >> n >> m >> k;
memset(p, 1, sizeof p);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int x;
cin >> x;
p[i + j] = min(p[i + j], x);
}
}
vector<pair<int, int>> o;
for (int i = 0; i < n + m - 1; ++i) {
o.push_back({p[i], i});
}
sort(begin(o), end(o));
for (auto e : o) {
arr[e.second] = 1;
memset(vis, 0, sizeof vis);
long long cnt = dp(0, 0);
if (cnt < k) arr[e.second] = -1, k -= cnt;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << (arr[i + j] == 1 ? '(' : ')');
}
cout << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
long long x[n];
for (int i = 0; i < n; i++) cin >> x[i];
long long s = 0;
for (int i = 0; i < n; i++) s += x[i];
if (s == m)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4000 + 10;
const int inf = 0x3f3f3f3f;
int minn = inf, flag = false;
int G[maxn][maxn];
int deg[maxn];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
memset(G, 0, sizeof(G));
memset(deg, 0, sizeof(deg));
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
deg[u]++;
deg[v]++;
G[u][v] = G[v][u] = 1;
}
flag = false;
minn = inf;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (G[i][j]) {
for (int k = 1; k <= n; k++) {
if (G[i][k] && G[j][k])
minn = min(minn, deg[i] + deg[j] + deg[k] - 6), flag = true;
}
}
}
}
if (!flag)
puts("-1");
else
printf("%d\n", minn);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long hell = round(1e18);
signed solve() {
long long n;
cin >> n;
long long m;
cin >> m;
vector<vector<long long>> a(n, vector<long long>(m));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> a[i][j];
a[i][j]--;
}
}
long long sm = 0;
for (long long mi = 0; mi < m; mi++) {
vector<long long> r(n, 0);
for (long long i = 0; i < n; i++) {
long long k = a[i][mi] - mi;
if (k % m == 0) {
long long idx = k / m;
long long ti = i - idx;
if (ti < 0 && idx < n) ti += n;
if (ti >= 0 && ti < n) r[ti]++;
}
}
long long cmin = hell;
for (long long i = 0; i < n; i++) {
long long c = (n - r[i]) + i;
cmin = min(c, cmin);
}
sm += cmin;
}
cout << sm;
return 0;
}
signed main() {
long long t = 1;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, ans;
int main() {
ios_base::sync_with_stdio(false);
cin >> a >> b;
if (a == b) {
cout << "infinity" << endl;
return 0;
}
for (long long i = 1; i <= (long long)sqrt(a - b); i++)
if ((a - b) % i == 0) {
if (i > b) ans++;
if ((a - b) / i > b and (a - b) / i != i) ans++;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int L = 29;
int pw[29];
void prec() {
pw[0] = 1;
for (int i = 1; i < L; ++i) pw[i] = pw[i - 1] * 2;
}
int get_log(int a) {
int t = log2(a);
while (pw[t] < a) t++;
return t;
}
map<int, int> ch;
void add(int v) { ch[v]++; }
void err(int v) {
ch[v]--;
if (ch[v] == 0) {
ch.erase(v);
}
}
void smart() {
int n, I;
cin >> n >> I;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
int l = 0, r = n + 1;
while (r - l > 1) {
int mid = (l + r) / 2;
if (get_log(mid) * n > I * 8) {
r = mid;
} else {
l = mid;
}
}
int can = l;
int res = 1e9;
for (int r = 0, l = 0; r < n; ++r) {
add(a[r]);
while (ch.size() > can) {
err(a[l++]);
}
res = min(res, l + n - r - 1);
}
cout << res << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
prec();
smart();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, m;
cin >> t;
for (int g = 0; g < t; g++) {
cin >> n >> m;
vector<vector<int> > a(n, vector<int>(m)), b(m, vector<int>(n));
vector<vector<int> > v(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> b[i][j];
}
}
int e = 0;
bool done = false;
int r = 0;
for (int i = 0; i < n; i++) {
for (int d = 0; d < m; d++) {
for (int j = 0; j < n; j++) {
if (a[i][d] == b[0][j]) {
for (int d = 0; d < m; d++) {
v[j][d] = a[i][d];
}
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << v[i][j] << " ";
}
cout << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000")
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
const int INF = (int)1E9 + 7;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int NMAX = 200 * 1000;
struct Edge {
int v, u, c, idx;
Edge() {}
Edge(int v, int u, int c) : v(v), u(u), c(c) {}
bool operator<(const Edge& e) const { return c < e.c; }
};
int n, m;
Edge E[NMAX];
vector<pair<int, int> > g[NMAX];
int cnt[NMAX], rt[NMAX], vs[NMAX], szvs;
int d[NMAX], used[NMAX], flag = 0, sum[NMAX], p[NMAX];
int root(int v) { return rt[v] == v ? v : rt[v] = root(rt[v]); }
bool merge(int a, int b) {
a = root(a), b = root(b);
if (a == b) return false;
if (rand() & 1) swap(a, b);
rt[a] = b;
cnt[b] += cnt[a];
return true;
}
int calc(int v, int par, int fl) {
if (d[v] == -1) {
sum[fl] += cnt[v];
d[v] = cnt[v];
p[v] = par;
used[v] = fl;
for (int i = 0; i < int(int((g[v]).size())); ++i) {
int u = g[v][i].first;
if (u == par) continue;
d[v] += calc(u, v, fl);
}
}
return d[v];
}
long long res[NMAX];
int main() {
cin >> n;
m = n - 1;
for (int i = 0; i < int(m); ++i) {
scanf("%d%d%d", &E[i].v, &E[i].u, &E[i].c);
E[i].v--, E[i].u--;
E[i].idx = i;
}
sort(E, E + m);
for (int i = 0; i < int(n); ++i) cnt[i] = 1, rt[i] = i;
memset(p, -1, sizeof p);
memset(d, -1, sizeof d);
for (int i = 0; i < int(m); ++i) {
int j = i;
szvs = 0;
while (j < m && E[i].c == E[j].c) {
E[j].v = root(E[j].v);
E[j].u = root(E[j].u);
vs[szvs++] = E[j].v;
vs[szvs++] = E[j].u;
g[E[j].v].push_back(make_pair(E[j].u, E[j].idx));
g[E[j].u].push_back(make_pair(E[j].v, E[j].idx));
j++;
}
sort(vs, vs + szvs);
szvs = unique(vs, vs + szvs) - vs;
for (int t = 0; t < int(szvs); ++t) {
flag++;
sum[flag] = 0;
calc(vs[t], -1, flag);
}
for (int t = 0; t < int(szvs); ++t) {
int v = vs[t];
for (int i = 0; i < int(int((g[v]).size())); ++i) {
int u = g[v][i].first, idx = g[v][i].second;
if (u == p[v]) swap(v, u);
res[idx] = calc(u, -1, -1) * 2LL * (sum[used[v]] - calc(u, -1, -1));
}
}
for (int t = 0; t < int(szvs); ++t) {
int v = vs[t];
g[v].clear();
d[v] = -1, p[v] = -1;
}
for (int t = int(i); t < int(j); ++t) merge(E[t].v, E[t].u);
i = j - 1;
}
long long mx = *max_element(res, res + m);
vector<int> tmp;
for (int i = 0; i < int(m); ++i)
if (res[i] == mx) tmp.push_back(i);
cout << mx << " " << int((tmp).size()) << endl;
for (int i = 0; i < int(int((tmp).size())); ++i) printf("%d ", tmp[i] + 1);
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, d, k;
long long s0(long long n, long long d, long long k) {
k -= d;
if (k < 0) return -1;
long long ret = -1;
for (long long l = n, r; l <= n * 2 && l <= k; l = r + 1) {
r = min(n * 2, k / (k / l));
long long c = k / l;
long long lb = (n + k + c) / (c + 1), rb = (n * 2 + k - d) / (c + 1);
if (k - d > 0) lb = max(lb, (k - d + c - 1) / c);
rb = min(rb, r);
lb = max(lb, l);
if (rb >= lb) ret = rb - n;
}
if (k <= d && min(n + k - d, n) >= k) ret = max(ret, min(n + k - d, n));
return ret;
}
long long s1(long long n, long long d, long long k) {
k -= d - 1;
if (k < 0) return -1;
long long ret = -1;
for (long long l = n, r; l <= n * 2 && l <= k; l = r + 1) {
r = min(n * 2, k / (k / l));
long long c = k / l;
long long lb = (n + k + c) / (c + 1), rb = (n * 2 + k - d) / (c + 1);
if (k - d > 0) lb = max(lb, (k - d + c - 1) / c);
rb = min(rb, min(r, (k - 1) / c));
lb = max(lb, l);
if (rb >= lb) ret = rb - n;
}
if (k <= d && min(n + k - d, n) >= k) ret = max(ret, min(n + k - d, n));
return ret;
}
int main() {
long long l, r;
scanf("%lld%lld%lld%lld", &n, &l, &r, &k);
d = r - l + 1;
if (d <= 0) d += n;
printf("%lld\n", max(s0(n, d, k), s1(n, d, k)));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T max3(T a, T b, T c) {
return max(a, max(b, c));
}
void solve() {
long long n, s;
cin >> n >> s;
vector<long long> v(n, 0);
for (auto &i : v) cin >> i;
long long ans = 0;
sort(v.begin(), v.end());
if (v[n / 2] == s) {
cout << "0" << '\n';
return;
}
if (v[n / 2] < s) {
for (long long i = n / 2; i < n; i++) {
if (v[i] >= s) {
cout << ans << '\n';
return;
}
ans += s - v[i];
}
} else {
for (long long i = n / 2; i >= 0; i--) {
if (v[i] <= s) {
cout << ans << '\n';
return;
}
ans += v[i] - s;
}
}
cout << ans << '\n';
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[10005];
int n, k, num[10] = {0}, a[10005], b[10005], w[10005], c, ans = 100000000, p, q,
y;
int ABS(int x) { return x >= 0 ? x : -x; }
struct node {
char str[10005];
int val;
} r[10];
bool cmp(node a, node b) {
return a.val == b.val ? strcmp(a.str, b.str) < 0 : a.val < b.val;
}
int main() {
cin >> n >> k;
scanf("%s", s);
for (int i = 0; i < n; i++) {
a[i] = s[i] - '0';
num[a[i]]++;
}
for (int i = 0; i <= 9; i++) {
if (num[i] >= k) {
puts("0");
puts(s);
return 0;
}
c = num[i];
p = 0;
memset(b, -1, sizeof(b));
for (int d = 1; d <= 9; d++) {
for (int j = 0; j < n; j++) {
if (a[j] - i == d) {
p += d;
c++;
b[j] = i;
if (c == k) break;
}
}
if (c == k) break;
for (int j = n - 1; j >= 0; j--) {
if (i - a[j] == d) {
p += d;
c++;
b[j] = i;
if (c == k) break;
}
}
if (c == k) break;
}
for (int j = 0; j < n; j++)
r[i].str[j] = b[j] != -1 ? b[j] + '0' : a[j] + '0';
r[i].val = p;
}
ans = r[0].val;
strcpy(s, r[0].str);
for (int i = 1; i <= 9; i++)
if (ans == r[i].val) {
if (strcmp(s, r[i].str) > 0) strcpy(s, r[i].str);
} else if (ans > r[i].val) {
ans = r[i].val;
strcpy(s, r[i].str);
}
printf("%d\n", ans);
puts(s);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long INF = 4e18;
const int inf = 2e9;
const int N = 1e5;
const int N5 = N + 5;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a * b / gcd(a, b); }
long long fact[2 * N5], ifact[2 * N5];
long long power(long long a, long long b) {
if (!b) return 1LL;
long long temp = power(a, b >> 1);
temp *= temp;
temp %= mod;
if (b & 1) {
temp *= a;
temp %= mod;
}
return temp;
}
long long inv(long long a) { return power(a, mod - 2); }
long long c(int n, int k) {
long long temp = fact[n];
temp *= ifact[k];
temp %= mod;
temp *= ifact[n - k];
temp %= mod;
return temp;
}
int main(void) {
int i, n;
fact[0] = 1;
ifact[0] = 1;
for (i = 1; i <= 2 * N; ++i) {
fact[i] = fact[i - 1] * i;
fact[i] %= mod;
ifact[i] = inv(fact[i]);
}
scanf("%d", &n);
long long ans = c(2 * n - 1, n - 1);
ans = (2 * ans - n) % mod;
if (ans < 0) ans += mod;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 85;
int n, l[N], r[N];
vector<int> v;
double dp[N][N], dp2[N][N], ans[N], pre[N][2 * N], in[N][2 * N], post[N][2 * N];
inline double prob(int x, int hl, int hr) {
hl = max(hl, l[x]);
hr = min(hr, r[x]);
return (hr < hl) ? 0 : ((double)(hr - hl)) / (r[x] - l[x]);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
v.push_back(l[i]);
v.push_back(r[i]);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
int max = v.back();
for (int i = 0; i < n; i++) {
for (int j = 0; j < v.size(); j++) {
pre[i][j] = prob(i, 0, v[j]);
in[i][j] = prob(i, v[j], v[j + 1]);
post[i][j] = prob(i, v[j + 1], max);
}
}
for (int i = 0; i < n; i++) {
memset(ans, 0, sizeof(ans));
memset(dp2, 0, sizeof(dp2));
for (int j = 0; j < v.size() - 1; j++)
if (l[i] <= v[j] && v[j + 1] <= r[i]) {
memset(dp, 0, sizeof(dp));
dp[0][0] = prob(i, v[j], v[j + 1]);
int c = 1;
for (int k = 0; k < n; k++)
if (k != i) {
for (int p = c; p >= 0; p--)
for (int q = c - p; q >= 0; q--) {
dp[p][q] = (p ? dp[p - 1][q] * pre[k][j] : 0) +
(q ? dp[p][q - 1] * in[k][j] : 0) +
dp[p][q] * post[k][j];
}
c++;
}
for (int p = 0; p < n; p++)
for (int q = 0; q < n; q++) dp2[p][q] += dp[p][q];
}
for (int p = 0; p < n; p++)
for (int q = 0; p + q < n; q++) {
for (int z = 0; z <= q; z++) ans[p + z] += dp2[p][q] / (q + 1);
}
for (int k = 0; k < n; k++) printf("%0.9lf ", ans[k]);
cout << endl;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 6;
long long n;
long long q[maxn];
long long ans[maxn];
void init() {
q[0] = 1;
for (long long i = 1; i <= n; i++) {
q[i] = q[i - 1] * i % 998244353;
}
}
int main() {
scanf("%lld", &n);
init();
ans[1] = 1;
for (long long i = 2; i <= n; i++) {
ans[i] = ((ans[i - 1] * i % 998244353 + q[i]) % 998244353 - i + 998244353) %
998244353;
}
printf("%lld\n", ans[n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[10005];
int main() {
int n;
for (int i = 1; i < 10005; i++) a[i] = i;
scanf("%d", &n);
int d = n / 2;
int k = 0, r = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < d; j++) {
printf("%d %d ", a[r], a[n * n - k]);
k++;
r++;
}
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
int n = s.length();
vector<int> idx[26];
for (int i = 0; i < n; i++) idx[s[i] - 'a'].push_back(i);
int ans = 0;
for (int i = 0; i < 26; i++) {
int maxi = 0;
for (int j = 0; j < n; j++) {
vector<int> cnt(26, 0);
for (auto x : idx[i]) cnt[s[(x + j) % n] - 'a']++;
int cur = 0;
for (auto x : cnt) cur += (x == 1);
maxi = max(maxi, cur);
}
ans += maxi;
}
cout << fixed << setprecision(15) << ans / (double)n;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> res;
int a[500001];
bool compare(int x, int y) { return a[x] < a[y]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m, x, y, i, j;
cin >> n >> m;
vector<pair<int, int> > v;
for (i = 0; i < m; i++) {
cin >> x >> y;
v.push_back({x, y});
}
int res[n + 1];
for (i = 1; i <= n; i++) {
cin >> a[i];
res[i] = i;
}
int flag = 0;
map<int, set<int> > l;
for (i = 0; i < m; i++) {
if (a[v[i].first] == a[v[i].second]) {
flag = 1;
break;
}
if (a[v[i].second] < a[v[i].first]) l[v[i].first].insert(a[v[i].second]);
if (a[v[i].first] < a[v[i].second]) l[v[i].second].insert(a[v[i].first]);
}
if (flag == 1) {
cout << -1;
return 0;
}
sort(res + 1, res + n + 1, compare);
for (i = 1; i <= n; i++) {
if (a[res[i]] == 1) {
continue;
}
if (l[res[i]].size() == a[res[i]] - 1) {
continue;
} else {
flag = 1;
break;
}
}
if (flag == 1) {
cout << -1;
return 0;
}
for (i = 1; i <= n; i++) {
cout << res[i] << " ";
}
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100010] = {0, 1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1,
14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1,
51, 1, 2, 1, 14, 1, 2, 2, 14, 1, 6, 1, 4, 2, 2, 1,
52, 2, 5, 1, 5, 1, 15, 2, 13, 2, 2, 1, 13, 1, 2, 4,
267, 1, 4, 1, 5, 1, 4, 1, 50, 1, 2, 3, 4, 1, 6, 1,
52, 15, 2, 1, 15, 1, 2, 1, 12, 1, 10, 1, 4, 2};
int main() {
int xtqak;
cin >> xtqak;
cout << a[xtqak] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
int arr[x];
int arr2[y];
for (int i = 0; i < x; i++) {
cin >> arr[i];
}
for (int j = 0; j < y; j++) {
cin >> arr2[j];
}
sort(arr, arr + x);
sort(arr2, arr2 + y);
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
if (arr[i] == arr2[j]) {
cout << arr[i] << endl;
return 0;
}
}
}
int koko1 = arr[0];
int koko2 = arr2[0];
int smallest;
if (koko1 < koko2)
cout << koko1 << koko2 << endl;
else
cout << koko2 << koko1 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e3 + 100;
int n, m, dp[4][nmax][nmax], a[nmax][nmax], marked[2][nmax][nmax];
int main() {
ios_base::sync_with_stdio(false);
cin >> m >> n;
char c;
for (int i = (int)1; i <= (int)m; i++)
for (int j = (int)1; j <= (int)n; j++) {
cin >> c;
a[i][j] = (c == '*');
}
for (int i = (int)1; i <= (int)m; i++)
for (int j = (int)1; j <= (int)n; j++)
if (a[i][j])
dp[0][i][j] = dp[0][i - 1][j] + a[i][j],
dp[1][i][j] = dp[1][i][j - 1] + a[i][j];
for (int i = (int)m; i >= (int)1; i--)
for (int j = (int)n; j >= (int)1; j--)
if (a[i][j])
dp[2][i][j] = dp[2][i + 1][j] + a[i][j],
dp[3][i][j] = dp[3][i][j + 1] + a[i][j];
vector<pair<int, pair<int, int> > > res(0);
for (int i = (int)1; i <= (int)m; i++)
for (int j = (int)1; j <= (int)n; j++)
if (a[i][j]) {
int k =
min(dp[0][i - 1][j],
min(dp[1][i][j - 1], min(dp[2][i + 1][j], dp[3][i][j + 1])));
if (!k) continue;
marked[0][i - k][j]++, marked[0][i + k + 1][j]--;
marked[1][i][j - k]++, marked[1][i][j + k + 1]--;
res.push_back(make_pair(i, make_pair(j, k)));
}
for (int i = (int)1; i <= (int)m; i++)
for (int j = (int)1; j <= (int)n; j++) {
marked[0][i][j] += marked[0][i - 1][j],
marked[1][i][j] += marked[1][i][j - 1];
if (a[i][j] && !marked[0][i][j] && !marked[1][i][j]) {
cout << -1;
return 0;
}
}
cout << res.size() << "\n";
for (int i = (int)0; i <= (int)res.size() - 1; i++)
cout << res[i].first << " " << res[i].second.first << " "
<< res[i].second.second << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
auto get = [&](int x1, int y1, int x2, int y2) {
cout << "? " << x1 + 1 << ' ' << y1 + 1 << ' ' << x2 + 1 << ' ' << y2 + 1
<< endl;
int res;
cin >> res;
return res;
};
vector<vector<long long> > fld(n, vector<long long>(n, -1));
fld[0][0] = 1;
fld[0][1] = 0;
fld[n - 1][n - 1] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (j == 0 && i % 2 == 1) continue;
if (i == 0 && j == 0) continue;
if (i == 0 && j == 1) continue;
if (i == n - 1 && j == n - 1) continue;
int t;
if (i >= 1 && j >= 1 && fld[i - 1][j - 1] != -1) {
t = get(i - 1, j - 1, i, j);
fld[i][j] = fld[i - 1][j - 1] ^ !t;
} else if (j >= 2 && fld[i][j - 2] != -1) {
t = get(i, j - 2, i, j);
fld[i][j] = fld[i][j - 2] ^ !t;
} else if (i >= 2 && fld[i - 2][j] != -1) {
t = get(i - 2, j, i, j);
fld[i][j] = fld[i - 2][j] ^ !t;
}
}
}
for (int j = n - 1; j > -1; j--) {
for (int i = n - 1; i > -1; i--) {
if (fld[i][j] != -1) continue;
int t = get(i, j, i + 1, j + 1);
fld[i][j] = fld[i + 1][j + 1] ^ !t;
}
}
int st = 0;
for (st = 0; st + 2 < n; st += 2) {
if (fld[st][st] == 1 && fld[st + 2][st + 2] == 0) break;
}
auto renumerate = [&](int k) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((i % 2) ^ (j % 2) == 1) fld[i][j] ^= k;
}
}
};
if (fld[st][st + 2] == 1) {
if (fld[st][st + 1] == fld[st + 1][st + 2]) {
int t = get(st, st, st + 1, st + 2);
if (t)
renumerate(fld[st + 1][st + 2] ^ fld[st][st]);
else
renumerate(fld[st + 1][st + 2] ^ fld[st][st] ^ 1);
} else {
int t = get(st, st + 1, st + 2, st + 2);
if (t)
renumerate(fld[st + 2][st + 2] ^ fld[st][st + 1]);
else
renumerate(fld[st + 2][st + 2] ^ fld[st][st + 1] ^ 1);
}
} else {
if (fld[st][st + 1] == fld[st + 1][st + 2]) {
int t = get(st, st + 1, st + 2, st + 2);
if (t)
renumerate(fld[st + 2][st + 2] ^ fld[st][st + 1]);
else
renumerate(fld[st + 2][st + 2] ^ fld[st][st + 1] ^ 1);
} else {
int t = get(st, st, st + 1, st + 2);
if (t)
renumerate(fld[st + 1][st + 2] ^ fld[st][st]);
else
renumerate(fld[st + 1][st + 2] ^ fld[st][st] ^ 1);
}
}
cout << "!" << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) cout << fld[i][j];
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
scanf("%d", &N);
map<int, int> front_values_of_deck;
map<int, int> available_colors;
for (int i = 0; i < N; i++) {
int front_value;
int back_value;
scanf("%d%d", &front_value, &back_value);
front_values_of_deck[front_value]++;
available_colors[front_value]++;
if (front_value != back_value) available_colors[back_value]++;
}
int need_amount = (N + 1) >> 1;
int answer = 2000000000;
for (map<int, int>::iterator i = available_colors.begin();
i != available_colors.end(); i++) {
if ((*i).second < need_amount) continue;
answer =
min(answer, ((need_amount - front_values_of_deck[(*i).first] < 0)
? 0
: need_amount - front_values_of_deck[(*i).first]));
}
if (answer != 2000000000)
printf("%d", answer);
else
printf("%d", -1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int MAXN = 2e5 + 5;
int a[MAXN], T, n, k;
inline void Solve() {
scanf("%d%d", &n, &k);
for (register int i = 1; i <= n; ++i) scanf("%d", a + i);
int ans = k + 1;
for (register int i = 1; i <= n; ++i) {
if (i > k && a[i] - a[i - k] < a[ans] - a[ans - k]) {
ans = i;
}
}
printf("%d\n", (a[ans] + a[ans - k]) / 2);
}
int main() {
scanf("%d", &T);
while (T--) Solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
int Sqrt(int n) {
int i;
for (i = 0; i * i <= n; ++i) 1;
return max(0, i - 1);
}
bool Fill(vector<vector<int> >& v, int x, int y, int l, int r, char Ch) {
for (int i = x; i < x + l; ++i)
for (int j = y; j < y + r; ++j) {
if (v[i][j] != 0) return 0;
v[i][j] = Ch;
}
return 1;
}
int dfs(vector<vector<int> >& v) {
int mx, my, Mx, My;
mx = my = MOD;
My = Mx = -1;
for (int i = 0; i < (v.size()); ++i)
for (int j = 0; j < (v.size()); ++j) {
if (v[i][j] == 0) {
mx = min(mx, i);
Mx = max(Mx, i);
my = min(my, j);
My = max(My, j);
}
}
return (Mx - mx + 1) * (My - my + 1);
}
int main() {
vector<std::pair<int, int> > inp(3);
int ar = 0;
for (int i = 0; i < (3); ++i) {
cin >> inp[i].first >> inp[i].second;
ar += inp[i].first * inp[i].second;
}
int n = Sqrt(ar);
if (n * n != ar) {
cout << -1 << endl;
return 0;
}
vector<vector<int> > v(n, vector<int>(n));
for (int i = 0; i < 3; ++i)
for (int j = i + 1; j < 3; ++j) {
for (int f1 = 0; f1 < 2; ++f1) {
for (int f2 = 0; f2 < 2; ++f2) {
for (int ii = 0; ii < (n); ++ii)
for (int jj = 0; jj < (n); ++jj) v[ii][jj] = 0;
bool f = true;
f &= Fill(v, 0, 0, f1 ? inp[i].second : inp[i].first,
f1 ? inp[i].first : inp[i].second, i + 'A');
int l = (f2 ? inp[j].second : inp[j].first);
int r = (f2 ? inp[j].first : inp[j].second);
f &= Fill(v, n - l, n - r, l, r, j + 'A');
f &= (dfs(v) == inp[3 - i - j].first * inp[3 - i - j].second);
if (f) {
for (int ii = 0; ii < (n); ++ii)
for (int jj = 0; jj < (n); ++jj)
if (v[ii][jj] == 0) v[ii][jj] = (3 - i - j + 'A');
cout << n << endl;
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (n); ++j) printf("%c", v[i][j]);
putchar(10);
}
return 0;
}
}
}
}
cout << -1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, a, b;
scanf("%d", &n);
while (n--) {
scanf("%d %d", &a, &b);
if (a % b == 0)
printf("0\n");
else if (a < b)
printf("%d\n", b - a);
else {
int k = ((a / b) + 1) * b - a;
printf("%d\n", k);
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 60;
const int mods = 1e9 + 7;
const int MAXN = 10000005;
const int INF = 0x3f3f3f3f;
inline int read() {
int f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
long long ans = 0;
bitset<505> f[65][2][505], g, Ans;
signed main() {
int n = read(), m = read();
for (int i = 1, u, v, c; i <= m; i++)
u = read(), v = read(), c = read(), f[0][c][u][v] = 1;
for (int i = 1; i <= 60; i++)
for (int j = 0; j < 2; j++)
for (int k = 1; k <= n; k++)
if (f[i - 1][j][k].count())
for (int p = 1; p <= n; p++)
if (f[i - 1][j][k][p]) f[i][j][k] |= f[i - 1][j ^ 1][p];
Ans[1] = 1;
for (int i = 60, nw = 0; i >= 0; i--) {
g = 0;
for (int k = 1; k <= n; k++)
if (Ans[k]) g |= f[i][nw][k];
if (g.count()) Ans = g, ans += (1ll << i), nw ^= 1;
}
if (ans > 1e18)
puts("-1");
else
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000 + 7;
const int MAX = 1 << 10;
int a[MAX];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = (0); i < (n); ++i) cin >> a[i];
vector<pair<int, int> > vec;
for (int i = (0); i < (n); ++i)
for (int j = (i + 1); j < (n); ++j)
if (a[i] > a[j]) vec.push_back({i, j});
sort(vec.begin(), vec.end(), [](pair<int, int> p1, pair<int, int> p2) {
if (p1.second != p2.second) return p1.second > p2.second;
if (a[p1.first] != a[p2.first]) return a[p1.first] < a[p2.first];
return p1.first < p2.first;
});
cout << (int)((vec).size()) << "\n";
for (auto p : vec) {
cout << p.first + 1 << " " << p.second + 1 << "\n";
swap(a[p.first], a[p.second]);
}
for (int i = (0); i < (n - 1); ++i) assert(a[i] <= a[i + 1]);
return 0;
}
| 8 |
#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...);
}
const long long MOD = 1e+9 + 7;
const long long INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
const long long MAXN = 4e+5 + 7;
int main() {
int T;
cin >> T;
long long n, a, b;
while (T--) {
cin >> n >> a >> b;
if (n == 1)
cout << a << "\n";
else
cout << min(a * n, (n / 2) * b + n % 2 * a) << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, mx;
map<long long, long long> mp;
string h;
int main() {
ios::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> x;
mp[x]++;
mx = max(mx, mp[x]);
}
cout << mx;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int j, k, m, i, n;
int main() {
cin >> n;
for (i = 1; i < n; ++i) cout << i + 1 << ' ';
cout << 1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[m];
for (int i = 0; i < m; i++) {
a[i] = 0;
}
for (int i = 0; i < n; i++) {
int c;
cin >> c;
a[c - 1]++;
}
int res = 0;
for (int i = 0; i < m - 1; i++) {
for (int j = i + 1; j < m; j++) {
res += a[i] * a[j];
}
}
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long a[n + 5];
for (int i = 0; i < n; i++) cin >> a[i];
int temp = a[0], j = 1;
int cnt = 1;
while (j < n) {
if (a[j] == temp) cnt++;
j++;
}
if (cnt == n) {
cout << "1";
cout << endl;
for (int i = 0; i < n; ++i) cout << "1 ";
} else if (n % 2 == 0) {
cout << "2" << endl;
for (int i = 0; i < n; i++) {
if (i & 1)
cout << "2 ";
else
cout << "1 ";
}
} else {
vector<long long> sol(n);
bool flag = false;
for (int i = 0; i < n; ++i) {
if (a[i] == a[(i + 1) % n]) {
flag = true;
int g = i + 1;
bool num = true;
while (g < n) {
if (num) {
sol[g] = 2;
} else
sol[g] = 1;
g++;
num = !num;
}
g = i;
num = true;
while (g >= 0) {
if (num) {
sol[g] = 2;
} else
sol[g] = 1;
g--;
num = !num;
}
}
}
if (flag) {
cout << "2" << endl;
for (int i = 0; i < n; i++) cout << sol[i] << " ";
cout << endl;
} else {
cout << endl << "3" << endl;
for (int i = 0; i < n - 1; i++) {
if (i & 1)
cout << "2"
<< " ";
else
cout << "1"
<< " ";
}
cout << "3" << endl;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
int N, M;
int A[MAXN];
int ans[MAXN][MAXN];
void gen(int x) {
if (x <= 2) {
for (int i = 0; i < x; i++) {
A[i] = 3 + i;
}
return;
} else if (x == 3) {
A[0] = 1;
A[1] = A[2] = 2;
return;
}
if (x % 2) {
A[0] = x - 2;
fill(A + 1, A + x, 2);
} else {
A[0] = x / 2 - 1;
fill(A + 1, A + x, 1);
}
}
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
ios::sync_with_stdio(false);
cin >> N >> M;
gen(M);
for (int i = 0; i < N; i++) {
copy_n(A, M, ans[i]);
}
gen(N);
for (int j = 0; j < M; j++) {
for (int i = 0; i < N; i++) {
ans[i][j] *= A[i];
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cout << ans[i][j] << ' ';
}
cout << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
bool OKP(int x) {
for (int i = 0; i < v.size(); i++) {
if (x % v[i] == 0) return false;
}
v.push_back(x);
return true;
}
bool OK(int x) {
int tmp = 0;
int xb = x;
while (xb) {
tmp *= 10;
tmp += xb % 10;
xb /= 10;
}
if (tmp == x) return true;
return false;
}
int main() {
bool p[2000000];
memset(p, false, sizeof p);
p[1] = true;
for (int i = 2; i * i < 2000000; i++) {
if (p[i]) continue;
for (int j = i + i; j < 2000000; j += i) p[j] = true;
}
int pp, q;
while (scanf("%d %d", &pp, &q) != EOF) {
long long ans = 1;
double ansd = 0;
long long cntp, cntq;
cntp = 0;
cntq = 1;
long long now = 2;
v.clear();
int f = -1;
while (1) {
if (!p[now]) cntp++;
if (OK(now)) cntq++;
if (cntp * q > cntq * pp) {
if (f < 0) {
ans = now - 1;
f = 10000;
} else
f--;
if (!f) {
printf("%I64d\n", ans);
break;
}
} else {
f = -1;
}
now++;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
int main() {
long long a, b, x, y;
scanf("%lld%lld%lld%lld", &a, &b, &x, &y);
long long t = gcd(x, y);
x /= t;
y /= t;
printf("%lld", min(a / x, b / y));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m, k;
cin >> n >> m >> k;
int temp = n / k;
if (m <= temp)
cout << m << "\n";
else {
int rest = m - temp;
int y = rest / (k - 1);
if (rest % (k - 1)) y++;
cout << temp - y << "\n";
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> myboys;
vector<int> mygirls;
int Nboys, Ngirls;
int q, w, e = 0, r = 0;
cin >> Nboys;
for (q = 0; q < Nboys; q++) {
cin >> w;
myboys.push_back(w);
}
cin >> Ngirls;
for (w = 0; w < Ngirls; w++) {
cin >> q;
mygirls.push_back(q);
}
int mymoves = 0;
sort(mygirls.begin(), mygirls.end());
sort(myboys.begin(), myboys.end());
r = 0;
e = 0;
while (e != mygirls.size() && r != myboys.size()) {
if (abs(myboys[r] - mygirls[e]) <= 1) {
mymoves++;
r++;
e++;
} else if (mygirls[e] > myboys[r]) {
r++;
} else if (myboys[r] > mygirls[e]) {
e++;
}
}
printf("%d\n", mymoves);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int primes[1100], sz;
int p[1100];
vector<int> S[1100];
priority_queue<pair<int, int> > pr, chr;
bool isPrime(int x) {
if (x == 2) return true;
for (int i = 2; i * i < x; i++)
if (x % i == 0) return false;
return true;
}
int FindParent(int x) {
if (x != p[x]) p[x] = FindParent(p[x]);
return p[x];
}
void Union(int x, int y) {
x = FindParent(x);
y = FindParent(y);
if (rand() & 1) swap(x, y);
if (x != y) p[x] = y;
}
int cnt[50];
bool used[1100];
int main() {
string s;
cin >> s;
n = s.length();
for (int i = 0; i < n; i++) cnt[(s[i] - 'a')]++;
for (int i = 2; i <= n; i++)
if (isPrime(i) && i + i <= n) primes[++sz] = i;
for (int i = 1; i <= sz; i++) p[i] = i;
for (int i = 1; i <= sz; i++)
for (int j = i + 1; j <= sz; j++)
if (primes[i] * primes[j] <= n) Union(i, j);
for (int i = 1; i <= sz; i++) {
S[FindParent(i)].push_back(primes[i]);
}
int m = 0, k = 0;
for (int i = 1; i <= sz; i++)
if (S[i].size()) pr.push(make_pair(S[i].size(), i));
for (int i = 0; i < 50; i++)
if (cnt[i]) chr.push(make_pair(cnt[i], i));
while (!pr.empty()) {
pair<int, int> topPr = pr.top();
pr.pop();
pair<int, int> topChr = chr.top();
chr.pop();
for (int i = 0; i < S[topPr.second].size(); i++) {
for (int j = S[topPr.second][i]; j <= n; j += S[topPr.second][i])
if (!used[j]) {
if (!topChr.first) {
printf("NO\n");
return 0;
}
s[j - 1] = char(topChr.second + 'a');
used[j] = true;
topChr.first--;
}
}
if (topChr.first > 0) chr.push(topChr);
}
while (!chr.empty()) {
pair<int, int> topChr = chr.top();
chr.pop();
for (int i = 1; i <= n; i++)
if (!used[i]) {
if (!topChr.first) break;
s[i - 1] = char(topChr.second + 'a');
used[i] = true;
topChr.first--;
}
}
cout << "YES"
<< "\n"
<< s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
const int INF = 0x7fffffff;
int n, k, d, a[N + 50], ans, L, R;
map<int, int> tax;
struct SetmentTree {
long long minn[(N << 2) + 50];
int tag[(N << 2) + 50];
void Add(int k, int l, int r, int v) {
tag[k] += v;
minn[k] += v;
return;
}
void Pushdown(int k, int l, int r, int mid) {
if (!tag[k]) return;
Add(k << 1, l, mid, tag[k]);
Add(k << 1 | 1, mid + 1, r, tag[k]);
tag[k] = 0;
return;
}
void Update(int k, int l, int r, int x, int y, int val) {
if (x <= l && r <= y) {
Add(k, l, r, val);
return;
}
int mid = (l + r) >> 1;
Pushdown(k, l, r, mid);
if (y <= mid)
Update(k << 1, l, mid, x, y, val);
else if (x > mid)
Update(k << 1 | 1, mid + 1, r, x, y, val);
else
Update(k << 1, l, mid, x, y, val),
Update(k << 1 | 1, mid + 1, r, x, y, val);
minn[k] = min(minn[k << 1], minn[k << 1 | 1]);
return;
}
int Work(int k, int l, int r, int val) {
if (l == r) return l;
int mid = (l + r) >> 1;
Pushdown(k, l, r, mid);
if (minn[k << 1] <= val)
return Work(k << 1, l, mid, val);
else
return Work(k << 1 | 1, mid + 1, r, val);
}
int Query(int k, int l, int r, int x, int y, int val) {
if (x <= l && r <= y) {
if (minn[k] > val) return INF;
return Work(k, l, r, val);
}
int mid = (l + r) >> 1;
Pushdown(k, l, r, mid);
if (y <= mid)
return Query(k << 1, l, mid, x, y, val);
else if (x > mid)
return Query(k << 1 | 1, mid + 1, r, x, y, val);
else
return min(Query(k << 1, l, mid, x, y, val),
Query(k << 1 | 1, mid + 1, r, x, y, val));
}
void Build(int k, int l, int r) {
if (l == r) {
minn[k] = l;
return;
}
int mid = (l + r) >> 1;
Build(k << 1, l, mid);
Build(k << 1 | 1, mid + 1, r);
minn[k] = min(minn[k << 1], minn[k << 1 | 1]);
return;
}
} tr;
struct Node {
int zhi, pos;
};
struct Stack {
Node st[N + 50];
int top = 0;
void Clear() {
top = 0;
return;
}
Node Top() { return st[top]; }
int Empty() { return top == 0; }
void Pop() {
top--;
return;
}
void Push(Node x) {
st[++top] = x;
return;
}
} stmax, stmin;
void Read(int &x) {
x = 0;
int p = 0;
char st = getchar();
while (st < '0' || st > '9') p = (st == '-'), st = getchar();
while (st >= '0' && st <= '9')
x = (x << 1) + (x << 3) + st - '0', st = getchar();
x = p ? -x : x;
return;
}
namespace Sub0 {
int L, R, ans = 0;
void Solve() {
int r;
for (int i = 1; i <= n; i++) {
r = i;
int tmp = a[i];
while (a[r + 1] == tmp && r + 1 <= n) r++;
if (r - i + 1 > ans) {
ans = r - i + 1;
L = i;
R = r;
}
}
printf("%d %d", L, R);
return;
}
} // namespace Sub0
int main() {
Read(n);
Read(k);
Read(d);
tr.Build(1, 1, n);
for (int i = 1; i <= n; i++) Read(a[i]), a[i] = a[i] + 0x3f3f3f3f;
if (!d) {
Sub0::Solve();
return 0;
}
int r;
for (int l = 1; l <= n; l = r + 1) {
stmax.Clear();
stmin.Clear();
tax.clear();
int zhi = a[l] % d;
r = l;
while (a[r + 1] % d == zhi && r + 1 <= n) r++;
int i = l;
for (int j = l; j <= r; j++) {
a[j] = (a[j] - zhi) / d;
tax[a[j]]++;
while (tax[a[j]] > 1) tax[a[i++]]--;
while (!stmax.Empty() && stmax.Top().zhi < a[j]) {
Node tmp = stmax.Top();
stmax.Pop();
if (stmax.Empty())
tr.Update(1, 1, n, l, tmp.pos, -tmp.zhi);
else
tr.Update(1, 1, n, stmax.Top().pos + 1, tmp.pos, -tmp.zhi);
}
if (stmax.Empty())
tr.Update(1, 1, n, l, j, a[j]);
else
tr.Update(1, 1, n, stmax.Top().pos + 1, j, a[j]);
stmax.Push((Node){a[j], j});
while (!stmin.Empty() && stmin.Top().zhi > a[j]) {
Node tmp = stmin.Top();
stmin.Pop();
if (stmin.Empty())
tr.Update(1, 1, n, l, tmp.pos, tmp.zhi);
else
tr.Update(1, 1, n, stmin.Top().pos + 1, tmp.pos, tmp.zhi);
}
if (stmin.Empty())
tr.Update(1, 1, n, l, j, -a[j]);
else
tr.Update(1, 1, n, stmin.Top().pos + 1, j, -a[j]);
stmin.Push((Node){a[j], j});
int Ans = tr.Query(1, 1, n, i, j, j + k);
if (Ans != INF && j - Ans + 1 > ans) {
ans = j - Ans + 1;
L = Ans;
R = j;
}
}
}
printf("%d %d", L, R);
return 0;
}
| 11 |
#include <bits/stdc++.h>
int main() {
int i, n, m, ary[5][2] = {{0, 100}, {0, 0}, {100, 0}, {1, 1}, {1, 2}};
scanf("%d%d", &n, &m);
if (m == 3) {
if (n >= 5) {
puts("-1");
} else {
for (m = 0; m < n; m++) printf("%d %d\n", ary[m][0], ary[m][1]);
}
return 0;
}
int X = 10000;
for (i = 0; i < m; i++) printf("%d %d\n", i, i * i + X);
for (i = 0; i < n - m; i++) printf("%d %d\n", i, -X - i * i);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, st = 0, sf = 0;
string s;
cin >> n;
cin >> s;
for (int i = 1; i < n; i++) {
if (s[i] == 'F' && s[i - 1] == 'S') {
sf++;
} else if (s[i] == 'S' && s[i - 1] == 'F') {
st++;
}
}
if (sf > st) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long rev(long long x) {
if (x < 0) return -1;
long long res = 0;
while (x) {
res = res * 2 + x % 2;
x /= 2;
}
return res;
}
map<long long, bool> vis1, vis2;
queue<long long> Q1, Q2;
const long long M = 1e18 + 10;
signed main() {
long long x, y;
long long h1, h2;
bool ans = 0;
cin >> x >> y;
Q1.push(x);
Q2.push(y);
while ((y % 2 || x == y) && ((!Q2.empty()) || (!Q1.empty()))) {
if (!Q1.empty()) h1 = Q1.front(), Q1.pop();
if (!Q2.empty()) h2 = Q2.front(), Q2.pop();
if (vis1[h2] || vis2[h1]) {
ans = 1;
break;
}
if (h1 <= M / 2 && !vis1[h1]) {
if (!vis1[rev(h1 * 2)] && rev(h1 * 2) != -1) Q1.push(rev(h1 * 2));
if (!vis1[rev(h1 * 2 + 1)] && rev(h1 * 2 + 1) != -1)
Q1.push(rev(h1 * 2 + 1));
}
if (!vis2[rev(h2)] && (h2 % 2)) Q2.push(rev(h2));
if (!vis2[rev(h2) / 2] && (h2 % 2)) Q2.push(rev(h2) / 2);
vis1[h1] = 1;
vis2[h2] = 1;
}
puts(ans ? "Yes" : "No");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, v[3001], w[3001], ans, dp[3001];
vector<long long> sum[3001];
inline long long read() {
long long x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return x;
}
void solve(long long l, long long r) {
if (l == r) {
for (register long long i = 0; i < (long long)sum[l].size(); ++i) {
if (i > m) break;
ans = max(ans, dp[m - i] + sum[l][i]);
}
return;
}
long long mid = (l + r) >> 1;
long long tmp[3001];
for (register long long i = 0; i <= m; ++i) tmp[i] = dp[i];
for (register long long i = mid + 1; i <= r; ++i)
for (register long long j = m; j >= v[i]; --j)
dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
solve(l, mid);
for (register long long i = 0; i <= m; ++i) dp[i] = tmp[i];
for (register long long i = l; i <= mid; ++i)
for (register long long j = m; j >= v[i]; --j)
dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
solve(mid + 1, r);
}
signed main() {
n = read(), m = read();
for (register long long i = 1; i <= n; ++i) {
long long p = read();
sum[i].push_back(0);
for (register long long j = 1; j <= p; ++j)
sum[i].push_back(sum[i].back() + read());
v[i] = p;
w[i] = sum[i].back();
}
solve(1, n);
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
template <class T>
void chmax(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void chmin(T& a, const T& b) {
a = min(a, b);
}
const int MOD = 1000000007;
bool isPowerOfTwo(long long int x) { return x && (!(x & (x - 1))); }
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int highestPowerof2(unsigned int n) {
if (n < 1) return 0;
int res = 1;
for (int i = 0; i < 8 * sizeof(unsigned int); i++) {
int curr = 1 << i;
if (curr > n) break;
res = curr;
}
return res;
}
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
int n, k;
cin >> n >> k;
int x = 1;
int i = 1;
int u = n;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j)
cout << k << " ";
else
cout << "0"
<< " ";
}
cout << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 6;
int p[MAXN], a[MAXN], b[MAXN], t, n, m, vec[MAXN];
void solve(int li, int ri, int lp, int rp) {
if (li >= ri) {
return;
}
int mid = (li + ri) >> 1;
long long res = 0;
for (int i = lp; i < rp; i++) {
if (a[i] < b[mid]) res++;
}
int pos = lp;
long long mn = res;
for (int i = lp + 1; i <= rp; i++) {
if (a[i - 1] < b[mid]) res--;
if (a[i - 1] > b[mid]) res++;
if (res < mn) {
mn = res;
pos = i;
}
}
p[mid] = pos;
solve(li, mid, lp, pos);
solve(mid + 1, ri, pos, rp);
}
pair<vector<int>, long long> invs(vector<int> vec) {
if (int(vec.size()) == 1) return {vec, 0};
int mid = int(vec.size()) >> 1;
vector<int> v1, v2;
for (int i = 0; i < mid; i++) {
v1.push_back(vec[i]);
}
for (int i = mid; i < int(vec.size()); i++) {
v2.push_back(vec[i]);
}
auto p1 = invs(v1);
auto p2 = invs(v2);
v1 = p1.first, v2 = p2.first;
vec.clear();
int j = 0;
long long res = p1.second + p2.second;
long long cnt = 0;
for (int i = 0; i < int(v1.size()); i++) {
while (j < int(v2.size()) && v2[j] < v1[i]) {
vec.push_back(v2[j]);
cnt++;
j++;
}
res += cnt;
vec.push_back(v1[i]);
}
while (j < int(v2.size())) {
vec.push_back(v2[j]);
j++;
}
return {vec, res};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> t;
while (t--) {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) cin >> b[i];
sort(b + 1, b + 1 + m);
solve(1, m + 1, 1, n + 1);
vector<int> vec;
int j = 1;
for (int i = 1; i <= n; i++) {
while (j <= m && p[j] == i) {
vec.push_back(b[j]);
j++;
}
vec.push_back(a[i]);
}
while (j <= m) {
vec.push_back(b[j]);
j++;
}
auto p = invs(vec);
cout << p.second << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 15;
long long m;
int dp[7], dp2[7];
int t, i, j, mask, k;
int val[(1 << N)][7][7];
char s[19];
void get(int m, int start) {
for (i = 0; i < 7; i++) dp[i] = 0;
dp[start] = 1;
for (k = 0; k < N; k++) {
for (i = 0; i < 7; i++) dp2[i] = 0;
if (m & 1) {
for (i = 0; i < 7; i++) {
for (j = ((i & 1) ^ 1); j < 8; j += 2) {
dp2[(i + j) >> 1] += dp[i];
if (dp2[(i + j) >> 1] >= 1000000007) dp2[(i + j) >> 1] -= 1000000007;
}
}
} else {
for (i = 0; i < 7; i++) {
for (j = (i & 1); j < 8; j += 2) {
dp2[(i + j) >> 1] += dp[i];
if (dp2[(i + j) >> 1] >= 1000000007) dp2[(i + j) >> 1] -= 1000000007;
}
}
}
for (i = 0; i < 7; i++) dp[i] = dp2[i];
m >>= 1;
}
}
int main() {
for (mask = 0; mask < (1 << N); mask++) {
for (int start = 0; start < 7; start++) {
get(mask, start);
for (int j = 0; j < 7; j++) {
val[mask][start][j] = dp[j];
}
}
}
scanf("%d", &t);
while (t--) {
scanf("%lld", &m);
for (j = 0; j < 7; j++) dp[j] = 0;
dp[0] = 1;
for (i = 0; i < 4; i++) {
mask = 0;
for (j = 0; j < N; j++) {
mask ^= ((m & 1) << j);
m >>= 1;
}
for (j = 0; j < (i == 3 ? 1 : 7); j++) {
dp2[j] = 0;
for (k = 0; k < (i == 0 ? 1 : 7); k++) {
dp2[j] += (long long)dp[k] * val[mask][k][j] % 1000000007;
if (dp2[j] >= 1000000007) dp2[j] -= 1000000007;
}
}
for (j = 0; j < 7; j++) dp[j] = dp2[j];
}
printf("%d\n", dp[0]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
cout << "YES" << endl;
if (k % 2) {
if (k > n - 2) {
int two = k - n + 2;
for (int i = 0; i < n; i++) printf(".");
printf("\n.");
for (int i = 0; i < n - 2; i++) printf("#");
printf(".\n.");
for (int i = 0; i < two / 2; i++) printf("#");
for (int i = 0; i < (n - 2) / 2 - (two / 2); i++) printf(".");
printf(".");
for (int i = 0; i < (n - 2) / 2 - (two / 2); i++) printf(".");
for (int i = 0; i < two / 2; i++) printf("#");
printf(".\n");
for (int i = 0; i < n; i++) printf(".");
printf("\n");
} else {
int tt = (n - 2) / 2 - (k / 2);
for (int i = 0; i < n; i++) printf(".");
printf("\n.");
for (int i = 0; i < k / 2; i++) printf("#");
for (int i = 0; i < tt; i++) printf(".");
printf("#");
for (int i = 0; i < tt; i++) printf(".");
for (int i = 0; i < k / 2; i++) printf("#");
printf(".\n");
for (int i = 0; i < n; i++) printf(".");
printf("\n");
for (int i = 0; i < n; i++) printf(".");
printf("\n");
}
} else {
for (int i = 0; i < n; i++) printf(".");
printf("\n.");
for (int i = 0; i < k / 2; i++) printf("#");
for (int i = 0; i < (n - k / 2 - 1); i++) printf(".");
printf("\n.");
for (int i = 0; i < k / 2; i++) printf("#");
for (int i = 0; i < (n - k / 2 - 1); i++) printf(".");
printf("\n");
for (int i = 0; i < n; i++) printf(".");
printf("\n");
}
}
| 4 |
#include <bits/stdc++.h>
int main(void) {
char vowels[20] = "AEIOUYaeiouy";
char last = 0, c;
while (scanf("%c", &c) != EOF) {
if (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z') last = c;
}
for (int i = 0; vowels[i]; i++)
if (vowels[i] == last) {
puts("YES");
return 0;
}
puts("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool lit[300000];
int ans = 0;
int read() {
int num = 0;
int flg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') {
flg = -1;
}
c = getchar();
}
while (isdigit(c)) {
num = (num << 1) + (num << 3) + (c ^ 48);
c = getchar();
}
return num * flg;
}
int main() {
int solid[2];
int solar[2];
int n = read();
solar[0] = solar[1] = read();
solid[0] = solid[1] = read();
for (int i = 1; i <= n; i++) {
lit[i] = read();
}
for (int i = 1; i <= n; i++) {
if (lit[i]) {
if (solid[1] < solid[0]) {
if (solar[1] != 0) {
solar[1]--;
solid[1]++;
} else if (solid[1] != 0) {
solid[1]--;
}
} else {
solid[1]--;
}
ans++;
if (solar[1] == 0 && solid[1] == 0) {
return 0 & printf("%d", ans);
}
} else {
if (solid[1] != 0) {
solid[1]--;
} else if (solar[1] != 0) {
solar[1]--;
}
ans++;
if (solar[1] == 0 && solid[1] == 0) {
return 0 & printf("%d", ans);
}
}
}
return 0 & printf("%d", n);
}
| 3 |
#include <bits/stdc++.h>
const int inf = (1ll << 30) - 1;
const int maxn = (int)1e5 + 10;
using namespace std;
struct node {
long long a1, a2, a3, a4, sum;
};
node t[400400];
long long d[400400];
long long a[400400];
int n;
node merge(node a, node b) {
node c;
c.a1 = max(a.a1, b.a1);
c.a2 = max(a.a2, b.a2);
c.a3 = max(a.a3, b.a3);
c.a4 = max(a.a4, b.a4);
c.sum = a.sum + b.sum;
return c;
}
void upd(int v, int tl, int tr, int pos) {
if (tl == tr) {
long long C = abs(d[tl]) + abs(d[tl - 1]);
t[v].a1 = d[tl] + d[tl - 1] - C;
t[v].a2 = d[tl] - d[tl - 1] - C;
t[v].a3 = -d[tl] + d[tl - 1] - C;
t[v].a4 = -d[tl] - d[tl - 1] - C;
t[v].sum = abs(d[tl]);
return;
}
int mid = (tl + tr) >> 1;
if (mid >= pos)
upd(v * 2, tl, mid, pos);
else
upd(v * 2 + 1, mid + 1, tr, pos);
t[v] = merge(t[v * 2], t[v * 2 + 1]);
}
node get(int v, int tl, int tr, int l, int r) {
if (l <= tl && tr <= r) return t[v];
int mid = (tl + tr) >> 1;
if (r <= mid) return get(v * 2, tl, mid, l, r);
if (mid < l) return get(v * 2 + 1, mid + 1, tr, l, r);
return merge(get(v * 2, tl, mid, l, r), get(v * 2 + 1, mid + 1, tr, l, r));
}
void build(int v, int tl, int tr) {
if (tl == tr) {
long long C = abs(d[tl]) + abs(d[tl - 1]);
t[v].a1 = d[tl] + d[tl - 1] - C;
t[v].a2 = d[tl] - d[tl - 1] - C;
t[v].a3 = -d[tl] + d[tl - 1] - C;
t[v].a4 = -d[tl] - d[tl - 1] - C;
t[v].sum = abs(d[tl]);
return;
}
int mid = (tl + tr) >> 1;
build(v * 2, tl, mid);
build(v * 2 + 1, mid + 1, tr);
t[v] = merge(t[v * 2], t[v * 2 + 1]);
}
void solve() {
scanf("%d", &n);
for (int i = 1, x; i <= n; i++) {
scanf("%d", &x);
a[i] = x;
}
long long sum = 0;
for (int i = 1; i < n; i++) {
d[i] = a[i] - a[i + 1];
}
build(1, 1, n - 1);
int q;
scanf("%d", &q);
for (int i = 0, ty, l, r, x; i < q; i++) {
scanf("%d%d%d%d", &ty, &l, &r, &x);
if (ty == 2) {
d[l - 1] -= x;
d[r] += x;
upd(1, 1, n - 1, l - 1);
upd(1, 1, n - 1, l);
upd(1, 1, n - 1, r);
if (r + 1 < n) upd(1, 1, n - 1, r + 1);
} else {
node G = get(1, 1, n - 1, l, r);
long long sum = t[1].sum;
long long ans =
max(G.a1, max(max(G.a2 + 2ll * x, G.a3 - 2ll * x), G.a4)) + sum;
printf("%lld\n", ans);
}
}
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int M = 100 * 1000;
int p[M];
int Max[M + 1];
int main() {
int n;
int ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i];
Max[p[i]] = Max[p[i] - 1] + 1;
ans = max(ans, Max[p[i]]);
}
cout << n - ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
unsigned long long n;
scanf("%llu", &n);
printf("%llu\n", n / 2520);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string airport[100][2];
string home;
string line[100];
int town[100];
int flag = 0;
int flag2 = 0;
int pair = 0;
cin >> n;
cin >> home;
for (int i = 0; i < n; i++) {
cin >> line[i];
town[i] = 0;
airport[i][0] = line[i].substr(0, 3);
airport[i][1] = line[i].substr(5, 3);
}
for (int i = 0; i < n; i++) {
if (town[i] == 0 && airport[i][0] == home) {
for (int j = 0; j < n; j++) {
if (town[j] == 0 && airport[j][0] == airport[i][1] &&
airport[j][1] == home) {
town[i] = 1;
town[j] = 1;
flag = 1;
pair++;
break;
}
}
if (flag == 0) {
town[i] = 1;
flag2 = 1;
}
flag = 0;
}
}
if (flag2 == 0) {
cout << "home" << endl;
} else {
cout << "contest" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n;
cin >> n;
string s;
cin >> s;
vector<int> Fa(10, 0);
for (long long int i = 0; i < n; i++) {
if (s[i] == '2') Fa[2]++;
if (s[i] == '3') Fa[3]++;
if (s[i] == '4') Fa[2] += 2, Fa[3]++;
if (s[i] == '5') Fa[5]++;
if (s[i] == '6') Fa[3]++, Fa[5]++;
if (s[i] == '7') Fa[7]++;
if (s[i] == '8') Fa[2] += 3, Fa[7]++;
if (s[i] == '9') Fa[3] += 2, Fa[2]++, Fa[7]++;
}
string ans = "";
for (int i = 9; i >= 2; i--) {
for (long long int j = 0; j < Fa[i]; j++) {
ans = ans + (char)('0' + i);
}
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3010, M = 3000 * 3000 + 10;
const int mod = 1000 * 1000 * 1000 + 7;
long long dp[N][N];
long long a[N];
bool mark[N];
int t[M][2];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
char c;
cin >> c;
a[i] = c - '0';
}
for (int i = 0; i <= n; i++) dp[i][i] = 1;
for (int l = 1; l < 4; l++)
for (int i = 0; i + l <= n; i++) dp[i][i + l] = (1 << (l - 1));
mark[3] = mark[5] = mark[14] = mark[15] = 1;
for (int l = 4; l <= n; l++)
for (int i = 0; i + l <= n; i++) {
int j = i + l;
dp[i][j] = dp[i + 1][j] + dp[i + 2][j] + dp[i + 3][j];
int x = a[i] * 8 + a[i + 1] * 4 + a[i + 2] * 2 + a[i + 3];
if (!mark[x]) dp[i][j] += dp[i + 4][j];
dp[i][j] %= mod;
}
long long ans = 0;
int id = 2;
for (int i = 0; i < n; i++) {
int cur = 1;
for (int j = i; j > -1; j--) {
if (!t[cur][a[j]]) {
ans += dp[j][i + 1], ans %= mod;
t[cur][a[j]] = id++;
}
cur = t[cur][a[j]];
}
cout << ans << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while (cin >> n >> m) {
int _0[n], _1[n], _2[n];
for (int x = 0; n > x; x++) {
_0[x] = _1[x] = _2[x] = 123456789;
string s;
cin >> s;
for (int y = 0; m > y; y++) {
if ('0' <= s[y] && s[y] <= '9') {
_0[x] = min(min(y, m - y), _0[x]);
} else if ('a' <= s[y] && s[y] <= 'z') {
_1[x] = min(min(y, m - y), _1[x]);
} else {
_2[x] = min(min(y, m - y), _2[x]);
}
}
}
int mn = 123456789;
for (int i = 0; n > i; i++) {
for (int j = 0; n > j; j++) {
for (int k = 0; n > k; k++) {
if (i == j || j == k || k == i) continue;
if (_0[i] + _1[j] + _2[k] < mn) mn = _0[i] + _1[j] + _2[k];
}
}
}
cout << mn << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1e5);
const long double INF = (1e16L);
const long double EPS = (1e-9);
struct Point {
long double x, y;
Point() {}
pair<long double, long double> getRadio(long double r) {
long double rest = abs((long double)y - r);
if (rest >= r + EPS) return make_pair(1.0L, 0.0L);
long double d = (long double)sqrt(r * r - rest * rest);
return make_pair((long double)x - d, (long double)x + d);
}
} P[N + 2];
int n;
bool f(long double x) {
long double left = -INF, right = INF;
for (int i = 0; i < n; i++) {
pair<long double, long double> cur = P[i].getRadio(x);
left = max(left, cur.first);
right = min(right, cur.second);
}
if (right + EPS <= left) return false;
return true;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> P[i].x >> P[i].y;
int ok = 0;
for (int i = 0; i < n; i++) ok |= (P[i].y < 0 ? 1 : 2);
if (ok == 3) {
cout << -1 << '\n';
return 0;
}
for (int i = 0; i < n; i++) P[i].y = abs(P[i].y);
long double lo = 0.0L, hi = INF;
for (int i = 0; i < 100; i++) {
long double mi = (hi + lo) / 2.0L;
if (f(mi))
hi = mi;
else
lo = mi;
}
printf("%.10f\n", (double)hi);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
cin >> x;
int sevens = 0, fours = 0;
int tmp = x;
if (tmp % 7 == 0) {
for (int j = 0; j < tmp / 7; j++) cout << 7;
return 0;
}
for (int i = 0; i < x / 4; i++) {
tmp -= 4;
if (tmp % 7 == 0) {
for (int j = 0; j <= i; j++) cout << 4;
for (int j = 0; j < tmp / 7; j++) cout << 7;
return 0;
}
}
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
const int inf = 1e9 + 7;
int read() {
int s = 0;
char c = getchar(), lc = '+';
while (c < '0' || '9' < c) lc = c, c = getchar();
while ('0' <= c && c <= '9') s = s * 10 + c - '0', c = getchar();
return lc == '-' ? -s : s;
}
void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + '0');
else
write(x / 10), putchar(x % 10 + '0');
}
void print(int x, char c = '\n') {
write(x);
putchar(c);
}
char a[N], b[N];
int kmp[N];
signed main() {
scanf("%s%s", a + 1, b + 1);
int n = strlen(a + 1), m = strlen(b + 1);
int x0 = 0, y0 = 0;
for (int i = 1; i <= n; i++)
if (a[i] == '0')
x0++;
else
y0++;
for (int i = 1; i <= m; i++)
if (b[i] == '0')
x0--;
else
y0--;
if (x0 < 0 || y0 < 0) {
for (int i = 1; i <= n; i++) putchar(a[i]);
return 0;
}
for (int i = 2, j = 0; i <= m; i++) {
while (j && b[j + 1] != b[i]) j = kmp[j];
if (b[j + 1] == b[i]) j++;
kmp[i] = j;
}
int x1 = 0, y1 = 0;
for (int i = kmp[m] + 1; i <= m; i++)
if (b[i] == '0')
x1++;
else
y1++;
reverse(b + 1, b + 1 + m);
for (int i = 2, j = 0; i <= m; i++) {
while (j && b[j + 1] != b[i]) j = kmp[j];
if (b[j + 1] == b[i]) j++;
kmp[i] = j;
}
int x2 = 0, y2 = 0;
for (int i = kmp[m] + 1; i <= m; i++)
if (b[i] == '0')
x2++;
else
y2++;
reverse(b + 1, b + 1 + m);
int x = 0, y = 0, ans = 0;
for (int i = 0; i <= n / (x1 + y1); i++)
if (i * x1 <= x0 && i * y1 <= y0) {
int tmpx = x0 - i * x1, tmpy = y0 - i * y1,
tmp = min(x2 ? tmpx / x2 : inf, y2 ? tmpy / y2 : inf);
if (i + tmp > ans) {
x = i;
y = tmp;
ans = i + tmp;
}
}
x0 -= x * x1 + y * x2;
y0 -= x * y1 + y * y2;
for (int i = 1; i <= y; i++)
for (int j = 1; j <= x2 + y2; j++) putchar(b[j]);
for (int i = 1; i <= m; i++) putchar(b[i]);
for (int i = 1; i <= x; i++)
for (int j = m - x1 - y1 + 1; j <= m; j++) putchar(b[j]);
for (int i = 1; i <= x0; i++) putchar('0');
for (int i = 1; i <= y0; i++) putchar('1');
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[500005], b[500005], c[500005];
int main() {
int n;
scanf("%d", &n);
int s = 0, tot = 0;
for (int i = 1; i <= n; i++) {
int t, x;
scanf("%d%d", &t, &x);
if (t == 0) a[++a[0]] = x;
if (t == 1) b[++b[0]] = x;
if (t == 10) c[++c[0]] = x;
if (t == 11) s += x, tot++;
}
if (b[0] < c[0]) swap(b, c);
sort(b + 1, b + b[0] + 1);
reverse(b + 1, b + b[0] + 1);
for (int i = 1; i <= c[0]; i++) s += c[i], s += b[i];
for (int i = c[0] + 1; i <= b[0]; i++) a[++a[0]] = b[i];
sort(a + 1, a + a[0] + 1);
reverse(a + 1, a + a[0] + 1);
for (int i = 1; i <= min(a[0], tot); i++) s += a[i];
printf("%d\n", s);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
inline int ksm(int x, long long y) {
int res = 1;
while (y > 0) {
if (y & 1) res = 1ll * res * x % MOD;
x = 1ll * x * x % MOD;
y >>= 1;
}
return res;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
long long gcd1 = exgcd(b, a % b, x, y);
long long t = x;
x = y, y = t - a / b * y;
return gcd1;
}
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
int n, a[105], b[105], pri[2005], m;
struct node {
long long a[2005], b[2005];
bool merge(node x) {
long long sum1 = 0, sum2 = 0;
for (int i = 1; i <= m; i++) sum1 += b[i], sum2 += x.b[i];
if (sum1 == 0 && sum2 == 0) {
for (int i = 1; i <= m; i++)
if (a[i] != x.a[i]) return 0;
return 1;
}
if (sum1 == 0 || sum2 == 0) {
if (sum2 == 0) {
swap(a, x.a);
swap(b, x.b);
swap(sum1, sum2);
}
long long res = 0;
for (int i = 1; i <= m; i++)
if (x.b[i] != 0) {
res = ((a[i] >= x.a[i]) && ((a[i] - x.a[i]) % x.b[i] == 0))
? (a[i] - x.a[i]) / x.b[i]
: -1;
break;
} else if (a[i] != x.a[i])
return 0;
if (res == -1) return 0;
for (int i = 1; i <= m; i++)
if ((x.a[i] + res * x.b[i]) != a[i]) return 0;
return 1;
}
long long sta = -1;
for (int i = 1; i <= m; i++)
if (b[i] * sum2 != x.b[i] * sum1) {
sta = i;
break;
}
if (sta == -1) {
long long b1 = 0, b2 = 0, gcd1;
for (int i = 1; i <= m; i++)
if (b[i] != 0) {
gcd1 = gcd(b[i], x.b[i]);
b1 = b[i] / gcd1;
b2 = x.b[i] / gcd1;
break;
}
long long res = 0;
for (int i = 1; i <= m; i++)
if (b[i] != 0) {
if ((a[i] - x.a[i]) % gcd1) return 0;
res = (a[i] - x.a[i]) / gcd1;
break;
}
for (int i = 1; i <= m; i++)
if ((x.a[i] + res * gcd1) != a[i]) return 0;
if (res < 0) {
swap(a, x.a);
swap(b, x.b);
swap(b1, b2);
res = -res;
}
long long xx, yy;
exgcd(b1, b2, xx, yy);
res = -res;
xx = (xx * res % b2 + b2) % b2;
for (int i = 1; i <= m; i++) a[i] += xx * b[i], b[i] *= b2;
} else {
long long p1 = sta, p2 = 0;
for (int i = 1; i <= m; i++)
if (b[p1] * x.b[i] != x.b[p1] * b[i]) {
p2 = i;
break;
}
long long xx = x.b[p2] * (x.a[p1] - a[p1]) - x.b[p1] * (x.a[p2] - a[p2]);
long long yy = b[p2] * (x.a[p1] - a[p1]) - b[p1] * (x.a[p2] - a[p2]);
long long fenm = x.b[p2] * b[p1] - b[p2] * x.b[p1];
if (fenm < 0) xx = -xx, yy = -yy, fenm = -fenm;
if (xx < 0 || yy < 0 || xx % fenm != 0 || yy % fenm != 0) return 0;
xx /= fenm, yy /= fenm;
for (int i = 1; i <= m; i++) {
if ((a[i] + xx * b[i]) != (x.a[i] + yy * x.b[i])) return 0;
a[i] += xx * b[i];
b[i] = 0;
}
}
return 1;
}
} s[105];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
int a1 = a[i], b1 = b[i];
for (int j = 2; j * j <= a[i]; j++)
if (a1 % j == 0) {
pri[++m] = j;
while (a1 % j == 0) a1 /= j;
}
if (a1 != 1) pri[++m] = a1;
for (int j = 2; j * j <= b[i]; j++)
if (b1 % j == 0) {
pri[++m] = j;
while (b1 % j == 0) b1 /= j;
}
if (b1 != 1) pri[++m] = b1;
}
sort(pri + 1, pri + m + 1);
m = unique(pri + 1, pri + m + 1) - pri - 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
while (a[i] % pri[j] == 0) a[i] /= pri[j], s[i].a[j]++;
for (int j = 1; j <= m; j++)
while (b[i] % pri[j] == 0) b[i] /= pri[j], s[i].b[j]++;
}
for (int i = 2; i <= n; i++)
if (!s[i].merge(s[i - 1])) return printf("-1"), 0;
int ans = 1;
for (int i = 1; i <= m; i++) ans = 1ll * ans * ksm(pri[i], s[n].a[i]) % MOD;
printf("%d", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, hr, hb, wr, wb;
while (scanf("%d%d%d%d%d", &c, &hr, &hb, &wr, &wb) != EOF) {
long long ans = 0;
for (long long i = 0; i <= 1000000; i++)
if (i * wr <= c) {
long long rem = (c - (i * wr)) / wb;
long long x = rem * hb;
long long y = i * hr;
ans = max(ans, x + y);
}
for (long long i = 0; i <= 1000000; i++)
if (i * wb <= c) {
long long rem = (c - (i * wb)) / wr;
long long x = rem * hr;
long long y = i * hb;
ans = max(ans, x + y);
}
printf("%I64d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vi;
int main() {
int n, m, k;
cin >> n >> m >> k;
vi.resize(n);
for (int i = 0; i < n; ++i) {
cin >> vi[i];
}
int one = 99999999, two = 99999999;
for (int i = m; i < n; ++i) {
if (vi[i] <= k && vi[i] != 0) {
one = i;
break;
}
}
for (int i = m - 2; i >= 0; --i) {
if (vi[i] <= k && vi[i] != 0) {
two = i;
break;
}
}
int dist1, dist2;
m--;
dist2 = abs(two - m);
dist1 = abs(one - m);
cout << min(dist1, dist2) * 10 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n >> x >> y;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (x > y) {
cout << n << endl;
return 0;
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] <= x) {
cnt++;
}
}
cout << (cnt + 1) / 2 << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long h[100100], w[100100];
bool C(long long x) {
int p = 0;
for (int i = 0; i < n; i++) {
if (w[p] < h[i]) {
if (abs(w[p] - h[i]) > x) return false;
long long k = max(h[i] + (x - (abs(h[i] - w[p]) * 2)),
h[i] + (x - abs(h[i] - w[p])) / 2ll);
while (w[p] <= k) {
p++;
if (p == m) return true;
}
} else {
while (w[p] <= h[i] + x) {
p++;
if (p == m) return true;
}
}
}
return false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) cin >> h[i];
for (int i = 0; i < m; i++) cin >> w[i];
long long l = -1, r = 1000000000000000ll;
while (r - l > 1) {
long long mid = (l + r) / 2ll;
if (C(mid))
r = mid;
else
l = mid;
}
cout << r << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, t, c, ans, x, mx;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &t, &c);
x -= t - ans;
x = max(0, x);
x += c;
mx = max(mx, x);
ans = t;
}
printf("%d %d", ans + x, mx);
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int a, sum = 0, p = 1;
char b[20];
scanf("%d%s", &a, b);
for (int w = 0; w < strlen(b); w++) {
sum += (b[w] - '0') * p;
p *= 10;
}
printf("%d\n", a + sum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long Bpow(long long a, long long s) {
if (s == 0) {
return 1;
}
long long u = Bpow(a, s / 2);
if (s & 1)
return u * u % mod * a % mod;
else
return u * u % mod;
}
int32_t main() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long ans = 0;
for (long long i = 0; i < n - 2; i++) {
long long now = a[i + 1];
for (long long j = i + 2; j < n; j++) {
if (now > a[i] * 2) break;
if ((a[i] ^ a[j]) == now && a[i] > a[j]) ++ans;
now += a[j];
}
}
for (long long i = n - 1; i > 1; i--) {
long long now = a[i - 1];
for (long long j = i - 2; j >= 0; j--) {
if (now > a[i] * 2) break;
if ((a[i] ^ a[j]) == now && a[i] > a[j]) ++ans;
now += a[j];
}
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string one, two;
int i, j = 0, k;
cin >> one;
cin >> two;
for (i = 0; i < two.length(); i++) {
if (one[j] == two[i]) j++;
}
cout << j + 1;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
vector<pair<int, int> > edges;
vector<int> adj[310000];
unsigned long long t[310000];
int size[310000];
char color[310000];
int order[310000];
int deg[310000];
int dfs(int v, int p, int e) {
if (size[e] != -1) return size[e];
size[e] = 1;
for (int i = 0; i < adj[v].size(); i++) {
int dest;
if (adj[v][i] >= n - 1) {
dest = edges[adj[v][i] - (n - 1)].first;
} else {
dest = edges[adj[v][i]].second;
}
if (dest != p) size[e] += dfs(dest, v, adj[v][i]);
}
return size[e];
}
unsigned long long newr() {
unsigned long long a = rand();
unsigned long long b = rand();
unsigned long long c = rand();
unsigned long long d = rand();
unsigned long long e = rand();
return (a << 48) + (b << 32) + (c << 16) + d + (e & 1);
}
pair<int, unsigned long long> get_seq(int e) {
int v, p;
if (e >= (n - 1)) {
v = edges[e - (n - 1)].first;
p = edges[e - (n - 1)].second;
} else {
v = edges[e].second;
p = edges[e].first;
}
pair<int, unsigned long long> ans;
ans.first = color[v];
ans.second = 0;
for (int i = 0; i < adj[v].size(); i++) {
int dest;
if (adj[v][i] >= n - 1) {
dest = edges[adj[v][i] - (n - 1)].first;
} else {
dest = edges[adj[v][i]].second;
}
if (dest != p) {
unsigned long long th = t[adj[v][i]];
ans.second += th;
}
}
return ans;
}
bool comps(int a, int b) { return size[a] < size[b]; }
int verif(int v, int p) {
set<unsigned long long> seen;
int ans = 0;
if (adj[v].size() < 4) ans++;
for (int e : adj[v]) {
int ot;
if (e >= n - 1)
ot = edges[e - (n - 1)].first;
else
ot = edges[e].second;
if (ot == p) continue;
unsigned long long th = t[e];
if (seen.find(th) == seen.end()) {
ans += verif(ot, v);
seen.insert(th);
}
}
return ans;
}
void solve() {
srand(5886);
scanf("%d", &n);
memset(size, -1, sizeof(size));
edges.clear();
for (int i = 0; i < n; i++) adj[i].clear();
for (int i = 0; i < n - 1; i++) {
scanf("%d %d", &a, &b);
a--;
b--;
edges.push_back(make_pair(a, b));
adj[a].push_back(i);
adj[b].push_back((n - 1) + i);
deg[a]++;
deg[b]++;
}
for (int i = 0; i < n - 1; i++) {
if (size[i] == -1) dfs(edges[i].second, edges[i].first, i);
if (size[(n - 1) + i] == -1)
dfs(edges[i].first, edges[i].second, i + (n - 1));
}
for (int i = 0; i < 2 * (n - 1); i++) {
order[i] = i;
}
sort(order, order + 2 * (n - 1), comps);
int cur = 0;
while (cur < 2 * (n - 1)) {
int st = cur;
int th = size[order[cur]];
while (cur < 2 * (n - 1) && size[order[cur]] == th) cur++;
vector<pair<pair<int, long long>, int> > seqs;
for (int k = st; k < cur; k++) {
seqs.push_back(make_pair(get_seq(order[k]), order[k]));
}
sort(seqs.begin(), seqs.end());
unsigned long long cur_t = 0;
for (int k = 0; k < seqs.size(); k++) {
if (k == 0 || seqs[k].first != seqs[k - 1].first) {
cur_t = newr();
}
t[seqs[k].second] = cur_t;
}
}
vector<int> leaf, nxt_leaf;
for (int(i) = 0; (i) < (int)(n); (i)++)
if (deg[i] <= 1) nxt_leaf.push_back(i);
int rem = n;
while (rem > 2) {
swap(leaf, nxt_leaf);
nxt_leaf.clear();
for (int x : leaf) {
rem--;
for (int e : adj[x]) {
int ot;
if (e >= n - 1)
ot = edges[e - (n - 1)].first;
else
ot = edges[e].second;
if (deg[ot]) {
if (--deg[ot] == 1) nxt_leaf.push_back(ot);
}
}
}
}
int ans;
if (nxt_leaf.size() == 1) {
ans = verif(nxt_leaf[0], -1);
} else {
int v1 = nxt_leaf[0], v2 = nxt_leaf[1];
ans = verif(v1, v2);
for (int e : adj[v1]) {
int ot;
if (e >= n - 1)
ot = edges[e - (n - 1)].first;
else
ot = edges[e].second;
if (ot == v2) {
if (e >= n - 1) e -= n - 1;
if (t[e] != t[e + (n - 1)]) ans += verif(v2, v1);
}
}
}
printf("%d\n", ans);
}
int main() { solve(); }
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool s[50][50];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char in;
cin >> in;
s[i][j] = (in == '#');
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int p = 0; p < n - i; p++) {
for (int q = 0; q < m - j; q++) {
int cnt = 0;
cnt += s[i][j] ? 1 : 0;
cnt += s[i + p][j] ? 1 : 0;
cnt += s[i][j + q] ? 1 : 0;
cnt += s[i + p][j + q] ? 1 : 0;
if (cnt != 3) {
continue;
} else {
cout << "NO";
return 0;
}
}
}
}
}
cout << "YES";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &num) {
T x = 0, f = 1;
char ch = getchar();
for (; ch > '9' || ch < '0'; ch = getchar())
if (ch == '-') f = -1;
for (; ch <= '9' && ch >= '0'; ch = getchar())
x = (x << 3) + (x << 1) + (ch ^ '0');
num = x * f;
}
int ttt, n, m, a[2105], a1[2105], a2[2105], b[2105], b1[2105], b2[2105],
t1[2105], t2[2105], suma, sumb, X, Y;
int ans[2105 << 1][2], cnt;
bitset<1000005> dp[1005];
bool chk(int *c, int *c1, int *c2, int sumc) {
for (int i = 1; i <= n; i++) dp[i].reset();
dp[0][0] = 1;
for (int i = 1; i <= n; i++) dp[i] = (dp[i - 1] << c[i]) | dp[i - 1];
if (!dp[n][sumc]) return 1;
c1[0] = c2[0] = 0;
for (int i = n; i; i--) {
if (sumc >= c[i] && dp[i - 1][sumc - c[i]])
c1[++c1[0]] = c[i], sumc -= c[i];
else
c2[++c2[0]] = c[i];
}
return 0;
}
void solve(int *c1, int *c2, int d1, int d2) {
int l = c1[0];
if (!l) return;
sort(c1 + 1, c1 + l + 1, greater<int>());
sort(c2 + 1, c2 + l + 1);
for (int i = 1; i <= l; i++) {
X += c1[i] * d1;
ans[++cnt][0] = X;
ans[cnt][1] = Y;
Y += c2[i] * d2;
ans[++cnt][0] = X;
ans[cnt][1] = Y;
}
}
int main() {
read(ttt);
while (ttt--) {
suma = sumb = 0;
read(n);
for (int i = 1; i <= n; i++) read(a[i]), suma += a[i];
read(m);
for (int i = 1; i <= m; i++) read(b[i]), sumb += b[i];
if (n != m || (suma & 1) || (sumb & 1)) {
puts("NO");
continue;
}
if (chk(a, a1, a2, suma >> 1) || chk(b, b1, b2, sumb >> 1)) {
puts("NO");
continue;
}
puts("YES");
if (a1[0] > a2[0]) swap(a1, a2);
if (b1[0] < b2[0]) swap(b1, b2);
X = Y = cnt = 0;
t1[0] = t2[0] = 0;
for (int i = 1; i <= a1[0]; i++) {
t1[++t1[0]] = a1[i];
t2[++t2[0]] = b1[i];
}
solve(t1, t2, 1, 1);
t1[0] = t2[0] = 0;
for (int i = 1; i <= b1[0] - a1[0]; i++) {
t1[++t1[0]] = a2[i];
t2[++t2[0]] = b1[i + a1[0]];
}
solve(t1, t2, -1, 1);
t1[0] = t2[0] = 0;
for (int i = 1; i <= b2[0]; i++) {
t1[++t1[0]] = a2[i + b1[0] - a1[0]];
t2[++t2[0]] = b2[i];
}
solve(t1, t2, -1, -1);
for (int i = 1; i <= cnt; i++) {
printf("%d %d\n", ans[i][0], ans[i][1]);
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
inline char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
const int N = 200010;
int n, m, i, j, p, ki;
bool fir;
long long o[N], x[N], X[N], a[N][3];
struct node {
long long sx, g, res;
} T[N * 4], ans;
node merge(node a, node b) {
node c;
c.g = a.g + b.g;
c.sx = a.sx + b.sx;
c.res = a.res + b.res;
c.res += b.sx * a.g - a.sx * b.g;
return c;
}
void find(int i, int x, int y, int l, int r) {
if (l > r) return;
if (y < l || x > r) return;
if (x >= l && y <= r) {
if (ki == 0)
T[i] = (node){0, 0, 0};
else if (ki == 1)
T[i] = (node){o[x], 1, 0};
else if (ki == 2) {
if (fir)
fir = 0, ans = T[i];
else
ans = merge(ans, T[i]);
}
return;
}
find(i * 2, x, (x + y) / 2, l, r);
find(i * 2 + 1, (x + y) / 2 + 1, y, l, r);
T[i] = merge(T[i * 2], T[i * 2 + 1]);
}
int F(long long x) { return lower_bound(o + 1, o + 1 + o[0], x) - o; }
int get(int i, int x, int y, int K) {
if (x == y) return x;
if (K <= T[i * 2].g)
return get(i * 2, x, (x + y) / 2, K);
else
return get(i * 2 + 1, (x + y) / 2 + 1, y, K - T[i * 2].g);
}
int main() {
read(n);
for (i = 1; i <= n; i++) read(x[i]), o[++o[0]] = x[i];
memcpy(X, x, sizeof(x));
read(m);
for (i = 1; i <= m; i++) read(a[i][0]), read(a[i][1]), read(a[i][2]);
for (i = 1; i <= m; i++)
if (a[i][0] == 1) {
x[a[i][1]] += a[i][2];
o[++o[0]] = x[a[i][1]];
}
sort(o + 1, o + 1 + o[0]);
j = 1;
for (i = 2; i <= o[0]; i++)
if (o[i] != o[i - 1]) o[++j] = o[i];
o[0] = j;
memcpy(x, X, sizeof(X));
for (i = 1; i <= n; i++) {
ki = 1;
find(1, 1, o[0], F(x[i]), F(x[i]));
}
for (i = 1; i <= m; i++) {
if (a[i][0] == 1) {
int u = a[i][1], v = a[i][2];
ki = 0;
find(1, 1, o[0], F(x[u]), F(x[u]));
x[u] += v;
ki = 1;
find(1, 1, o[0], F(x[u]), F(x[u]));
} else {
int x, y;
x = a[i][1];
y = a[i][2];
x = lower_bound(o + 1, o + 1 + o[0], x) - o;
y = upper_bound(o + 1, o + 1 + o[0], y) - o - 1;
fir = 1;
ki = 2;
find(1, 1, o[0], x, y);
if (fir)
printf("0\n");
else
printf("%I64d\n", ans.res);
}
}
scanf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101;
long long temp[N][N], ans[N][N], mat[N][N], arr[N];
int main() {
ios::sync_with_stdio(false);
long long n, cnt = 0, k, x;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) {
mat[i][j] = 1;
continue;
}
x = arr[i] ^ arr[j];
cnt = 0;
while (x > 0) {
if (x & 1) cnt++;
x = x >> 1;
}
if (!(cnt % 3)) mat[i][j] = 1;
}
}
for (int i = 0; i < n; i++) ans[i][i] = 1;
x = k - 1;
while (x) {
if (x & 1) {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) temp[i][j] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
temp[i][j] =
(temp[i][j] + (ans[i][k] * mat[k][j]) % 1000000007ULL) %
1000000007ULL;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) ans[i][j] = temp[i][j];
}
x = x >> 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) temp[i][j] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
temp[i][j] = (temp[i][j] + (mat[i][k] * mat[k][j]) % 1000000007ULL) %
1000000007ULL;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) mat[i][j] = temp[i][j];
}
cnt = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cnt = (cnt + ans[i][j]) % 1000000007ULL;
cout << cnt;
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int count = 0, temp = 0, check[26] = {0};
char str[100];
scanf("%s", &str);
for (int i = 0; i < strlen(str); i++) {
temp = str[i] - 97;
check[temp]++;
}
for (int i = 0; i < 26; i++) {
if (check[i] >= 1) count++;
}
if (count % 2 == 0)
printf("CHAT WITH HER!\n");
else
printf("IGNORE HIM!\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M, a[10005], b[10005], c[10005], d[105][105];
double f[105][105], x[105];
void init() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= M; i++)
scanf("%d%d%d", &a[i], &b[i], &c[i]), d[a[i]][b[i]]++, d[b[i]][a[i]]++;
}
void Gauss() {
for (int i = 1; i <= N; i++) {
for (int j = i; j <= N; j++)
if (abs(f[j][i]) > 1e-9) {
for (int k = 0; k <= N; k++) swap(f[i][k], f[j][k]);
break;
}
for (int j = i + 1; j <= N; j++)
if (abs(f[j][i]) > 1e-9) {
double x = f[j][i] / f[i][i];
for (int k = 0; k <= N; k++) f[j][k] -= f[i][k] * x;
}
}
for (int i = N; i; i--)
if (abs(f[i][i]) > 1e-9) {
x[i] = f[i][0];
for (int j = i + 1; j <= N; j++) x[i] -= f[i][j] * x[j];
x[i] /= f[i][i];
}
}
void doit() {
f[1][1] = f[N][N] = f[N][0] = 1;
for (int i = 2; i < N; i++)
for (int j = 1; j <= N; j++) f[i][j] += d[i][j], f[i][i] -= d[i][j];
Gauss();
double mi = 1e9, s = 0;
for (int i = 1; i <= M; i++) mi = min(mi, c[i] / abs(x[b[i]] - x[a[i]]));
for (int i = 1; i <= N; i++) s += d[i][N] * (x[N] - x[i]);
printf("%.9lf\n", s * mi);
for (int i = 1; i <= M; i++) printf("%.9lf\n", (x[b[i]] - x[a[i]]) * mi);
}
int main() {
init();
doit();
return 0;
}
| 9 |
#include<bits/stdc++.h>
#define int long long
#define fi first
#define se second
using namespace std;
const int MAXN = 500005;
//const int MOD = 1e9 + 7;
signed main() {
cin.tie(0);
cout.tie(0);
ios_base :: sync_with_stdio(0);
int n;
cin >> n;
int a[n];
unordered_map<int, int> pos_last;
int cnt[MAXN] = {}, pos_first[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
pos_last[a[i]] = i;
}
multiset<int> st;
int most_color[n];
for (int i = n - 1; i >= 0; i--) {
if (cnt[a[i]]) {
st.erase(st.find(cnt[a[i]]));
}
cnt[a[i]]++;
st.insert(cnt[a[i]]);
most_color[i] = *st.rbegin();
}
for (int i = n - 1; i >= 0; i--) {
pos_first[a[i]] = i;
}
vector<pair<int, int>> v;
for (pair<int, int> p : pos_last) {
v.push_back({p.se, p.fi});
}
sort(v.begin(), v.end());
int k = (int)v.size();
int dp[k];
int max_dp[k];
for (int i = 0; i < k; i++) {
auto [pos, col] = v[i];
int j = lower_bound(v.begin(), v.end(), pair<int, int>({pos_first[col], -1})) - v.begin() - 1;
dp[i] = (j == -1 ? 0 : max_dp[j]) + cnt[col];
max_dp[i] = max(dp[i], i ? max_dp[i - 1] : -1);
}
int mx = 0;
for (int i = 0; i < k; i++) {
int pos = v[i].fi;
mx = max(mx, dp[i] + (pos == n - 1 ? 0 : most_color[pos + 1]));
}
cout << n - mx;
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.