solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
struct pt {
lint x, y;
bool isbase;
int idx;
bool operator<(const pt &ref) const {
if (x == ref.x)
return y < ref.y;
else
return x < ref.x;
}
};
lint ccw(const pt &a, const pt &b, const pt &c) {
return a.x * b.y + b.x * c.y + c.x * a.y - a.y * b.x - b.y * c.x - c.y * a.x;
}
const int MAX_N = 1e4;
pt arr[MAX_N * 2];
pt tmp[MAX_N * 2];
int res[MAX_N * 2];
void solve(int i, int j) {
if (i + 1 == j) {
res[arr[i].idx] = arr[j].idx;
res[arr[j].idx] = arr[i].idx;
return;
} else if (i > j)
return;
swap(arr[i], *min_element(arr + i, arr + j + 1));
sort(arr + i + 1, arr + j + 1, [&](const pt &a, const pt &b) {
lint ccw_val = ccw(arr[i], a, b);
return (ccw_val > 0);
});
int cnt = 0;
int want = (arr[i].isbase ? 1 : -1);
int t = MAX_N * 300;
for (int k = i + 1; k <= j; k++) {
cnt += (arr[k].isbase ? -1 : 1);
if (cnt == want) {
if (t > abs((i + j) / 2 - k)) t = k;
break;
}
}
res[arr[i].idx] = arr[t].idx;
res[arr[t].idx] = arr[i].idx;
solve(i + 1, t - 1);
solve(t + 1, j);
}
int main(void) {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> arr[i].x >> arr[i].y;
arr[i].isbase = false;
arr[i].idx = i;
}
for (int i = N; i < N + N; i++) {
cin >> arr[i].x >> arr[i].y;
arr[i].isbase = true;
arr[i].idx = i;
}
solve(0, 2 * N - 1);
for (int i = 0; i < N; i++) {
cout << res[i] - N + 1 << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long base[18];
long long lim, cost, st;
void predo() {
base[0] = 1;
for (int i = 1; i < 18; i++) base[i] = base[i - 1] * 10;
}
int main() {
cin >> lim >> st >> cost;
lim /= cost;
predo();
int len = 0;
long long f = st;
while (f) {
++len;
f /= 10;
}
long long ans = 0;
while (lim && len * (base[len] - st) <= lim) {
ans += base[len] - st;
lim -= len * (base[len] - st);
st = base[len];
++len;
}
ans += lim / len;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int zz = pow(2, 34);
struct node {
node *a[2];
long long int cnt[2];
};
node *newNode() {
node *temp = new node;
for (long long int i = 0; i < 2; i++) {
temp->cnt[i] = 0;
temp->a[i] = NULL;
}
return temp;
}
struct trie {
node *root;
} tr;
void add(long long int x) {
node *rt = tr.root;
assert(rt != NULL);
for (long long int i = zz; i >= 1; i >>= 1) {
assert(rt != NULL);
long long int k = x / i;
rt->cnt[k & 1]++;
if (rt->a[k & 1] == NULL) rt->a[k & 1] = newNode();
rt = rt->a[k & 1];
}
}
void subtract(long long int x) {
node *rt = tr.root;
for (long long int i = zz; i >= 1; i >>= 1) {
long long int k = x / i;
rt->cnt[k & 1]--;
rt = rt->a[k & 1];
}
}
long long int min_xor(long long int x) {
long long int ans = 0;
node *rt = tr.root;
for (long long int i = zz; i >= 1; i >>= 1) {
long long int k = x / i;
k &= 1;
if (k == 0) {
if (rt->cnt[0] == 0) {
ans += i;
rt = rt->a[1];
} else {
rt = rt->a[0];
}
} else {
if (rt->cnt[1] == 0) {
ans += i;
rt = rt->a[0];
} else {
rt = rt->a[1];
}
}
if (i == 1) break;
}
return ans;
}
const long long int N = 300005;
long long int a[N], b[N];
signed main() {
tr.root = newNode();
long long int n;
scanf("%lld", &n);
for (long long int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (long long int i = 1; i <= n; i++) {
scanf("%lld", &b[i]);
add(b[i]);
}
for (long long int i = 1; i <= n; i++) {
long long int val = min_xor(a[i]);
printf("%lld ", val);
subtract((val ^ a[i]));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
const double PI = acos(-1), EPS = 1e-7;
const int OO = 0x3f3f3f3f, N = 1e7 + 5, mod = 1e9 + 7;
using namespace std;
long long gcd(long long x, long long y) { return (!y) ? x : gcd(y, x % y); }
long long lcm(long long x, long long y) { return ((x / gcd(x, y)) * y); }
void file() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int n;
bool ok(int x) {
map<int, int> mp;
while (x) {
mp[x % 10]++;
x /= 10;
}
return ((int)mp.size() <= 2);
}
int cnt;
void DFS(int x) {
if (x > 0 && x <= n) cnt++;
if (x > 1e8) return;
if (x > n) return;
for (int i = 0; i <= 9; i++) {
if (x * 10 + i > 0 && ok(x * 10 + i)) DFS(x * 10 + i);
}
}
int main() {
file();
cin >> n;
DFS(0);
cout << cnt;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 10, mod = 1000000007;
char s[N];
struct node {
int fa, len, v[26];
} tr[N];
int n, mx, len, last = 1, tot = 1, b[N], c[N], now, f[N][3];
void add(int c) {
int p = last;
if (tr[p].v[c]) {
int q = tr[p].v[c], y;
if (tr[p].len + 1 == tr[q].len)
last = q;
else {
tr[last = y = ++tot] = tr[q];
tr[y].len = tr[p].len + 1;
tr[q].fa = y;
for (; p && tr[p].v[c] == q; p = tr[p].fa) tr[p].v[c] = y;
}
} else {
int x = last = ++tot;
tr[x].len = tr[p].len + 1;
for (; p && !tr[p].v[c]; p = tr[p].fa) tr[p].v[c] = x;
if (!p)
tr[x].fa = 1;
else {
int q = tr[p].v[c], y;
if (tr[p].len + 1 == tr[q].len)
tr[x].fa = q;
else {
tr[y = ++tot] = tr[q];
tr[y].len = tr[p].len + 1;
tr[q].fa = tr[x].fa = y;
for (; p && tr[p].v[c] == q; p = tr[p].fa) tr[p].v[c] = y;
}
}
}
f[last][now]++;
}
void Sort() {
for (int i = 0; i <= mx; i++) c[i] = 0;
for (int i = 1; i <= tot; i++) c[tr[i].len]++;
for (int i = 1; i <= mx; i++) c[i] += c[i - 1];
for (int i = tot; i; i--) b[c[tr[i].len]--] = i;
}
void upd(int &x) { x += x >> 31 & mod; }
int d[N];
int main() {
n = N;
for (now = 0; now < 3; now++) {
scanf("%s", s + 1);
last = 1;
len = 0;
for (int i = 1; s[i]; i++) add(s[i] - 'a'), len++;
n = min(n, len);
mx = max(mx, len);
}
Sort();
for (int i = tot; i > 1; i--) {
int j = b[i], fa = tr[j].fa;
for (int k = 0; k < 3; k++) f[fa][k] += f[j][k];
int *F = f[j];
long long t = (long long)F[0] * F[1] * F[2] % mod;
upd(d[tr[fa].len + 1] += t - mod);
upd(d[tr[j].len + 1] -= t);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
upd(ans += d[i] - mod);
printf("%d ", ans);
}
puts("");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int color[111];
bool vis[111];
int sm = 0;
set<pair<int, int> > st;
vector<vector<int> > v;
void dfs(int u, int p, int pc) {
if (vis[u]) {
if (color[u] == pc) {
int mn = min(u, p);
int mx = max(u, p);
st.insert(make_pair(mn, mx));
}
return;
}
vis[u] = 1;
if (pc)
color[u] = 0;
else
color[u] = 1;
for (int i = 0; i < v[u].size(); i++) {
int vv = v[u][i];
if (vv != p) dfs(vv, u, color[u]);
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
v.resize(n);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--, y--;
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 0; i < n; i++) {
if (!vis[i]) {
dfs(i, 0, -1);
}
}
if (((n - st.size()) & 1))
printf("%d", st.size() + 1);
else
printf("%d", st.size());
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 7;
const int M = 59;
const int mid = M / 2;
const int mod = 1e9 + 9;
const int inf = 1e9 + 7;
const long long linf = 1ll * inf * inf;
const double pi = acos(-1);
const double eps = 1e-7;
const double ep = 1e-5;
const int maxn = 1e5 + 7;
const double PI = acos(-1);
int n, m;
vector<int> adj[N];
int d[N];
void DFS(int u, int r) {
for (int j = (0); j < (adj[u].size()); j++) {
int v = adj[u][j];
if (v != r) {
d[v] = d[u] + 1;
DFS(v, u);
}
}
}
void solve() {
cin >> n >> m;
for (int t = (0); t < (m); t++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
DFS(1, -1);
int mx = 1;
for (int u = (1); u < (n + 1); u++)
if (d[mx] < d[u]) mx = u;
d[mx] = 0;
DFS(mx, -1);
for (int u = (1); u < (n + 1); u++)
if (d[mx] < d[u]) mx = u;
cout << d[mx];
}
int main() {
int T = 1;
for (int i = (1); i < (T + 1); i++) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1e6 + 5;
long long x[maxn];
long long y[maxn];
int main() {
long long x0, y0, ax, ay, bx, by;
cin >> x[0] >> y[0] >> ax >> ay >> bx >> by;
long long xs, ys, t;
cin >> xs >> ys >> t;
long long pos = 1;
long long pre = abs(xs - x[0]) + abs(ys - y[0]);
long long tmpx = 0;
long long tmp3;
long long ans = 0;
while (1) {
x[pos] = ax * x[pos - 1] + bx;
y[pos] = ay * y[pos - 1] + by;
long long tmp = abs(x[pos] - xs) + abs(y[pos] - ys);
if (tmp > pre) {
tmp3 = tmp;
break;
} else {
pre = tmp;
tmpx = pos;
}
pos++;
}
if (t >= pre) {
t -= pre;
ans++;
} else {
cout << 0 << endl;
return 0;
}
long long sum = 0;
for (int i = tmpx; i > 0; i--) {
long long tmp = abs(x[i - 1] - x[i]) + abs(y[i - 1] - y[i]);
sum += tmp;
if (t >= tmp) {
t -= tmp;
ans++;
} else {
break;
}
}
long long tmp4 = abs(x[tmpx + 1] - x[tmpx]) + abs(y[tmpx + 1] - y[tmpx]);
if (t - 2 * sum - tmp4 < 0 && pre + sum > tmp3 &&
tmp3 + sum + tmp4 - pre - sum <= t) {
ans++;
}
if (t - sum >= 0) {
t -= sum;
long long pos1 = tmpx;
while (1) {
x[pos1 + 1] = ax * x[pos1] + bx;
y[pos1 + 1] = ay * y[pos1] + by;
long long tmp2 = abs(x[pos1 + 1] - x[pos1]) + abs(y[pos1 + 1] - y[pos1]);
if (t - tmp2 >= 0) {
t -= tmp2;
ans++;
} else {
break;
}
pos1++;
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
;
long long n, p, w, d;
cin >> n >> p >> w >> d;
long long x = -1, y = -1, z = -1;
const int ITER = 1e7;
for (y = 0; y < ITER; ++y) {
if ((p - (y * d)) % w == 0) {
x = (p - (y * d)) / w;
z = n - x - y;
break;
}
}
if (x < 0 or y < 0 or z < 0)
cout << "-1\n";
else
cout << x << " " << y << " " << z << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<string, string>> v;
v.push_back(make_pair("Time", "green"));
v.push_back(make_pair("Mind", "yellow"));
v.push_back(make_pair("Soul", "orange"));
v.push_back(make_pair("Power", "purple"));
v.push_back(make_pair("Reality", "red"));
v.push_back(make_pair("Space", "blue"));
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int i = 0; i < 6; i++) {
if (v[i].second == s) {
v[i].first = "taken";
}
}
}
cout << (6 - n) << endl;
for (int i = 0; i < 6; i++) {
if (v[i].first != "taken") {
cout << v[i].first << endl;
} else {
continue;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int fun(int n, int* input, int m) {
queue<pair<int, int>> curr;
for (int i = 0; i < n; i++) {
pair<int, int> temp;
temp.first = input[i];
temp.second = i + 1;
curr.push(temp);
}
while (curr.size() > 0) {
if (curr.size() == 1) return curr.front().second;
pair<int, int> temp = curr.front();
curr.pop();
temp.first -= m;
if (temp.first > 0) curr.push(temp);
}
}
int main() {
int n, m;
cin >> n >> m;
int* input = new int[n];
for (int i = 0; i < n; i++) cin >> input[i];
cout << fun(n, input, m);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int f;
cin >> f;
string s;
cin >> s;
if (f == 12) {
if (s[3] > '5') s[3] = '0';
if (s[0] > '1') {
if (s[1] == '0')
s[0] = '1';
else
s[0] = '0';
}
if (s[0] == '1') {
if (s[1] > '2') s[0] = '0';
}
if (s[0] == '0' and s[1] == '0') s[1] = '1';
}
if (f == 24) {
if (s[3] > '5') s[3] = '0';
if (s[0] > '2') {
s[0] = '0';
}
if (s[0] == '2') {
if (s[1] >= '4') s[0] = '0';
}
}
cout << s;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pi = pair<ll, ll>;
const int N = 5e5 + 5, inf = 1e9 + 7;
ll dp[N][2];
pi a[N];
int main() {
ios ::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i].first >> a[i].second;
auto cmp = [&](pi a, pi b) {
if (max(a.first, a.second) == max(b.first, b.second)) return a < b;
return max(a.first, a.second) < max(b.first, b.second);
};
sort(a + 1, a + 1 + n, cmp);
pi la = {0, 0}, lb = {0, 0};
for (int i = 1; i <= n; ++i) {
int j = i, level = max(a[i].first, a[i].second);
while (max(a[j].first, a[j].second) == level) ++j;
--j;
pi b = a[j];
int k = j;
while (k >= i && a[k].first == level) b = a[k], k--;
if (a[i].second != level) {
b = a[j];
swap(a[i], b);
}
ll dist = abs(a[i].first - b.first) + abs(a[i].second - b.second);
dp[j][0] = dp[i - 1][1] + abs(lb.first - b.first) +
abs(lb.second - b.second) + dist;
dp[j][0] = min(dp[j][0], dp[i - 1][0] + abs(la.first - b.first) +
abs(la.second - b.second) + dist);
dp[j][1] = dp[i - 1][0] + abs(la.first - a[i].first) +
abs(la.second - a[i].second) + dist;
dp[j][1] = min(dp[j][1], dp[i - 1][1] + abs(lb.first - a[i].first) +
abs(lb.second - a[i].second) + dist);
la = a[i], lb = b;
i = j;
}
cout << min(dp[n][0], dp[n][1]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
vector<int> b;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 0) b.push_back(i);
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 0) {
cout << 0 << " ";
cnt++;
} else {
if (b[0] > i)
cout << b[0] - i << " ";
else if (b[b.size() - 1] < i)
cout << i - b[b.size() - 1] << " ";
else
cout << min(abs(b[cnt] - i), abs(b[cnt - 1] - i)) << " ";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int b, g;
void start() {
cin >> b >> g;
cout << b + g - 1 << '\n';
int i = 1, j = 1, times = 0;
bool flag = false;
while (i <= b && j <= g) {
if (g >= b) {
cout << i << " " << j << '\n';
i += (times == 0 || i == b) ? 0 : ((times % 2 == 1) ? 1 : 0);
j += (times == 0 || (i == b && flag)) ? 1 : ((times % 2 == 0) ? 1 : 0);
flag = (i == b) ? true : false;
times++;
} else {
cout << i << " " << j << '\n';
j += (times == 0 || j == g) ? 0 : ((times % 2 == 1) ? 1 : 0);
i += (times == 0 || (j == g && flag)) ? 1 : ((times % 2 == 0) ? 1 : 0);
flag = (j == g) ? true : false;
times++;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
start();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 18;
const int M = (1 << 17) + 10;
int dp[N][M][2][2], is[M]{0};
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
is[x - 1] = 1;
}
memset(dp, 0xcf, sizeof(dp));
int m = (1 << n);
for (int j = 0; j < m; j += 2) {
for (int x = 0; x < 2; x++) {
for (int y = 0; y < 2; y++) {
if (x + y != is[j] + is[j + 1]) continue;
dp[1][j][x][y] = (x + y) > 0;
}
}
}
for (int i = 2; i <= N; i++) {
for (int j = 0; j < m; j += (1 << i)) {
for (int x1 = 0; x1 < 2; x1++)
for (int y1 = 0; y1 < 2; y1++)
for (int x2 = 0; x2 < 2; x2++)
for (int y2 = 0; y2 < 2; y2++) {
int res =
dp[i - 1][j][x1][y1] + dp[i - 1][j + (1 << (i - 1))][x2][y2];
if (x1 + x2 > 0) res++;
if (y1 + y2 > 0) res++;
dp[i][j][x1][x2] = max(dp[i][j][x1][x2], res + (x2 + y1 > 0));
dp[i][j][x1][x2] = max(dp[i][j][x1][x2], res + (x2 + y2 > 0));
dp[i][j][x1][y1] = max(dp[i][j][x1][y1], res + (x2 + y1 > 0));
dp[i][j][x1][y2] = max(dp[i][j][x1][y2], res + (x2 + y2 > 0));
swap(x1, x2);
dp[i][j][x1][x2] = max(dp[i][j][x1][x2], res + (x2 + y1 > 0));
dp[i][j][x1][x2] = max(dp[i][j][x1][x2], res + (x2 + y2 > 0));
dp[i][j][x1][y1] = max(dp[i][j][x1][y1], res + (x2 + y1 > 0));
dp[i][j][x1][y2] = max(dp[i][j][x1][y2], res + (x2 + y2 > 0));
}
}
}
int ans = 0;
for (int x = 0; x < 2; x++) {
for (int y = 0; y < 2; y++) {
ans = max(ans, dp[n][0][x][y] + (x + y > 0));
}
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int INF = 999999999;
double EPSILON = 0.00000001;
int check(int r, int dif, int req) {
int n = 0;
int changes = 0;
while (r > 1) {
changes++;
int k = (r - dif) / dif;
n += k;
r -= k * dif;
if (r != 1 and r == dif) return -1;
dif = r - dif;
}
if (n + 1 != req) return -1;
return changes;
}
int main() {
int n, r;
cin >> n >> r;
if (n == 1) {
if (r == 1)
cout << "0\nT\n";
else
cout << "IMPOSSIBLE\n";
return 0;
}
if (n == 2) {
if (r == 2)
cout << "0\nTB\n";
else
cout << "IMPOSSIBLE\n";
return 0;
}
int dif;
int best = 0, ans = -1;
for (dif = 1; 2 * dif < r; dif++) {
int x = check(r, dif, n);
if (x != -1) {
if (x > best) {
best = x;
ans = dif;
}
}
}
if (ans == -1) {
cout << "IMPOSSIBLE\n";
return 0;
}
vector<int> difa;
dif = ans;
while (r > 1) {
int k = (r - dif) / dif;
for (int _ = 0; _ < k; _++) difa.push_back(dif);
r -= k * dif;
dif = r - dif;
}
string res = "T";
string a = "B", b = "T";
for (int i = difa.size() - 1; i >= 1; i--) {
if (difa[i - 1] != difa[i]) swap(a, b);
res += a;
}
if (res[res.size() - 1] == 'T')
res += 'B';
else
res += 'T';
ans = 0;
for (int i = 0; i < res.size() - 1; i++)
if (res[i] == res[i + 1]) ans++;
cout << ans << endl;
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dp[101000][2][3], vis[101000][2][3], n, T, val[101000], sz[101000],
lc[101000], rc[101000];
void pdfs(int u) {
sz[u] = 0;
if (val[u] != -1) return;
pdfs(lc[u]), pdfs(rc[u]);
sz[u] = sz[lc[u]] + sz[rc[u]] + 1;
if (sz[rc[u]] & 1) swap(lc[u], rc[u]);
}
int mer(int a, int b, int p) {
if (p == 0)
return max(a, b);
else
return min(a, b);
}
int dfs(int u, int nw, int step) {
if (vis[u][nw][step]) return dp[u][nw][step];
if (sz[u] == 0) return val[u];
if (sz[u] == 1) return mer(val[lc[u]], val[rc[u]], nw ^ (step == 2));
vis[u][nw][step] = 1;
int v0, v1, va;
int& ans = dp[u][nw][step];
if (step == 0) {
if ((sz[lc[u]] & 1) == 0) {
ans = mer(dfs(lc[u], nw, 0), dfs(rc[u], nw, 0), nw);
} else if (sz[rc[u]] & 1) {
ans = mer(dfs(lc[u], nw, 1), dfs(rc[u], nw, 1), nw);
} else {
v0 = mer(dfs(lc[u], nw, 0), dfs(rc[u], nw ^ 1, 0), nw ^ 1);
v1 = mer(dfs(rc[u], nw, 1), dfs(lc[u], nw ^ 1, 1), nw ^ 1);
ans = mer(v0, v1, nw);
}
} else {
ans = dfs(u, nw ^ 1, 0);
if ((sz[lc[u]] & 1) == 0) {
if (sz[lc[u]]) {
v0 = dfs(lc[u], nw, 1 + (sz[rc[u]] == 0 && step == 1));
v1 = dfs(rc[u], nw ^ 1, 0);
ans = mer(ans, mer(v0, v1, nw ^ 1), nw);
}
if (sz[rc[u]]) {
v0 = dfs(rc[u], nw, 1 + (sz[lc[u]] == 0 && step == 1));
v1 = dfs(lc[u], nw ^ 1, 0);
ans = mer(ans, mer(v0, v1, nw ^ 1), nw);
}
} else if (sz[rc[u]] & 1) {
v0 = dfs(lc[u], nw ^ 1, 1 + (sz[rc[u]] == 1 && step == 1));
v1 = dfs(rc[u], nw, 0);
ans = mer(ans, mer(v0, v1, nw ^ 1), nw);
v0 = dfs(rc[u], nw ^ 1, 1 + (sz[lc[u]] == 1 && step == 1));
v1 = dfs(lc[u], nw, 0);
ans = mer(ans, mer(v0, v1, nw ^ 1), nw);
} else {
v0 = dfs(lc[u], nw, 1 + (sz[rc[u]] == 0 && step == 1));
v1 = dfs(rc[u], nw, 0);
ans = mer(ans, mer(v0, v1, nw), nw);
}
}
return ans;
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (int i = 0; i <= n; ++i) lc[i] = sz[i] = rc[i] = 0;
for (int i = 0; i <= n; ++i)
for (int j = 0; j < 2; ++j)
for (int k = 0; k < 3; ++k) vis[i][j][k] = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &val[i]);
if (val[i] == -1) scanf("%d%d", &lc[i], &rc[i]);
}
pdfs(0);
printf("%d\n", dfs(0, 0, 0));
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(12);
for (int i = 0; i < 12; i++) {
cin >> a[i];
}
sort(a.begin(), a.end(), greater<int>());
int s = 0;
if (n != 0) {
for (int i = 0; i < 12; i++) {
s = s + a[i];
if (s >= n) {
cout << i + 1;
break;
}
}
if (s < n) {
cout << "-1";
}
} else
cout << "0";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 8e8;
int n, a, ans;
;
int arr[110];
vector<int> ve;
int sum(int x) {
int ret = 0;
while (x) {
ret += (x % 10);
x /= 10;
}
return ret;
}
int main() {
scanf("%d", &n);
while (n--) {
scanf("%d", &a);
int x = sum(a);
++arr[x];
ve.push_back(x);
}
for (int i = 1; i <= 100; ++i) {
if (arr[i] == 0) continue;
for (int j = 1; j <= 100; ++j) {
if (arr[j] == 0) continue;
if ((i + j) % 3 == 0) {
if (i == j) {
if (arr[i] == 1) continue;
if (arr[i] % 2 == 0) {
ans += arr[i] / 2;
arr[i] = 0;
} else {
ans += arr[i] / 2;
arr[i] = 1;
}
} else {
if (arr[i] >= arr[j]) {
ans += arr[j];
arr[i] -= arr[j];
arr[j] = 0;
} else {
ans += arr[i];
arr[j] -= arr[i];
arr[i] = 0;
}
}
}
}
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N];
int main() {
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
int cnt = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] & 1) cnt++;
}
if (cnt == 0)
printf("NO\n");
else if (cnt == n && (n % 2 == 0))
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long gcd(long long a, long long b) {
if (b > a) {
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long expo(long long a, long long b, long long mod) {
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b >> 1;
}
return res;
}
void extendgcd(long long a, long long b, long long *v) {
if (b == 0) {
v[0] = 1;
v[1] = 0;
v[2] = a;
return;
}
extendgcd(b, a % b, v);
long long x = v[1];
v[1] = v[0] - v[1] * (a / b);
v[0] = x;
return;
}
long long mminv(long long a, long long b) {
long long arr[3];
extendgcd(a, b, arr);
return arr[0];
}
long long mminvprime(long long a, long long b) { return expo(a, b - 2, b); }
bool revsort(long long a, long long b) { return a > b; }
void swap(int &x, int &y) {
int temp = x;
x = y;
y = temp;
}
long long combination(long long n, long long r, long long m, long long *fact,
long long *ifact) {
long long val1 = fact[n];
long long val2 = ifact[n - r];
long long val3 = ifact[r];
return (((val1 * val2) % m) * val3) % m;
}
void google(int t) { cout << "Case #" << t << ": "; }
vector<long long> sieve(int n) {
int *arr = new int[n + 1]();
vector<long long> vect;
for (int i = 2; i <= n; i++)
if (arr[i] == 0) {
vect.push_back(i);
for (int j = 2 * i; j <= n; j += i) arr[j] = 1;
}
return vect;
}
long long mod_add(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
long long mod_mul(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
long long mod_sub(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
long long mod_div(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (mod_mul(a, mminvprime(b, m), m) + m) % m;
}
long long phin(long long n) {
long long number = n;
if (n % 2 == 0) {
number /= 2;
while (n % 2 == 0) n /= 2;
}
for (long long i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
while (n % i == 0) n /= i;
number = (number / i * (i - 1));
}
}
if (n > 1) number = (number / n * (n - 1));
return number;
}
long long power(long long a, long long b) {
long long result = 1;
while (b) {
if (b & 1) result = (result * a);
b >>= 1;
a = (a * a);
}
return result;
}
long long noofdigits(long long n) {
set<long long> set;
while (n) {
long long x = n % 10;
set.insert(x);
n = n / 10;
}
return set.size();
}
double average(int *a, int n) {
if (n == 1) {
return a[0];
}
double ans = average(a + 1, n - 1);
double av = (ans * (n - 1) + a[0]) / n;
return av;
}
void matrixsum(int a[][100], int b[][100], int r, int c) {
if (r == 0) {
return;
}
for (int j = 0; j < c; j++) {
a[0][j] = a[0][j] + b[0][j];
}
matrixsum(a + 1, b + 1, r - 1, c);
}
void solve() {
int t;
cin >> t;
while (t--) {
int n, q;
cin >> n >> q;
string s;
cin >> s;
vector<int> v(n + 1);
for (int i = 0; i < n; i++) {
if (s[i] == '+') {
v[i + 1] = +1;
} else {
v[i + 1] = -1;
}
if ((i + 1) & 1) {
v[i + 1] = v[i] + v[i + 1];
} else {
v[i + 1] = v[i] - v[i + 1];
}
}
while (q--) {
int l, r;
cin >> l >> r;
if ((v[r] - v[l - 1]) == 0) {
cout << 0 << endl;
} else if ((r - l + 1) & 1) {
cout << 1 << endl;
} else {
cout << 2 << endl;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
auto start1 = high_resolution_clock::now();
solve();
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 2e5 + 5, mod = 1e9 + 7, inf = mod;
long long n;
set<long long> s[3];
long long q;
struct {
vector<long long> sum = vector<long long>(maxn, 0);
void add(long long i, long long v) {
for (; i < maxn; i += i & -i) {
sum[i] += v;
}
}
long long get(long long i) {
long long r = 0;
for (; i > 0; i -= i & -i) {
r += sum[i];
}
return r;
}
long long getran(long long l, long long r) { return get(r) - get(l - 1); }
} bit[3];
long long arr[maxn];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
map<long long, long long> m;
m['R'] = 0;
m['P'] = 1, m['S'] = 2;
for (long long i = (long long)1; i <= (long long)n; i++) {
char c;
cin >> c;
arr[i] = m[c];
s[arr[i]].insert(i);
bit[arr[i]].add(i, 1);
}
for (long long i = (long long)0; i <= (long long)q; i++) {
if (i) {
char c;
long long p;
cin >> p >> c;
s[arr[p]].erase(p);
bit[arr[p]].add(p, -1);
arr[p] = m[c];
s[arr[p]].insert(p);
bit[arr[p]].add(p, 1);
}
long long ans = 0;
for (long long t = (long long)0; t <= (long long)2; t++) {
long long nxt = (t + 1) % 3, prv = (t + 2) % 3;
if (s[nxt].empty())
ans += s[t].size();
else {
long long l1 = (s[prv].empty() ? 1 : *s[prv].rbegin() + 1);
long long r1 = *s[nxt].rbegin();
long long r2 = (s[prv].empty() ? n : *s[prv].begin() - 1);
long long l2 = *s[nxt].begin();
if (l1 > r1) l1 = r1 = 0;
if (l2 > r2) l2 = r2 = 0;
if (max(l1, l2) <= min(r1, r2)) {
l1 = min(l1, l2);
r1 = max(r1, r2);
l2 = r2 = 0;
}
ans +=
bit[t].getran(1, n) - bit[t].getran(l1, r1) - bit[t].getran(l2, r2);
}
}
cout << ans << '\n';
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)209;
long long power(long long x, long long y) {
long long ans = 1;
while (y > 0) {
if (y % 2 == 1) ans = ans * x;
x = x * x;
y = y >> 1;
}
return ans;
}
int n, k, a[N], sz = 0;
map<int, int> m;
set<int> s;
queue<int> q;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
if (s.find(a[i]) == s.end()) {
if (sz != k) {
s.insert(a[i]);
q.push(a[i]);
sz++;
} else {
int last = q.front();
q.pop();
s.erase(last);
q.push(a[i]);
s.insert(a[i]);
}
}
}
cout << sz << "\n";
string ans = "";
while (!q.empty()) {
ans = to_string(q.front()) + " " + ans;
q.pop();
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
const long long MOD = 1e9 + 7;
const long long MAXN = 1e5 + 7;
const long long INF = 2e9;
const long long BIG_INF = 2e18;
const long long LOG = 20;
const double eps = 1e-7;
mt19937 engine(chrono::system_clock::now().time_since_epoch().count());
long long mpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = (res * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return res;
}
void solve() {
long long k;
cin >> k;
long long ans = 6, kol = 1;
for (long long i = 0; i < k; ++i) {
kol = kol * 2;
}
kol -= 2;
cout << (ans * mpow(4, kol)) % MOD << '\n';
;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long test = 1;
while (test--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s1[600][600], s[600][600];
int sum[600][600];
long long ans1, ans2;
bool c1[510][510][13];
bool c0[510][510][13];
bool c2[510][510][13];
bool c3[510][510][13];
bool c4[510][510][13];
bool c5[510][510][13];
bool allblack(int x, int y, int k, int l) {
return (sum[x][y] - sum[x - k][y] - sum[x][y - l] + sum[x - k][y - l]) ==
k * l;
}
void doit(int op) {
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++)
sum[i][j] =
sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + (s[i][j] == '*');
memset(c1, 0, sizeof(c1));
memset(c0, 0, sizeof(c0));
memset(c2, 0, sizeof(c2));
memset(c3, 0, sizeof(c3));
memset(c4, 0, sizeof(c4));
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) {
c0[i][j][0] = s[i][j] == '.';
c1[i][j][0] = s[i][j] == '.';
c2[i][j][0] = s[i][j] == '.';
c3[i][j][0] = s[i][j] == '.';
c4[i][j][0] = s[i][j] == '.';
for (int l = 1, k = 2; k <= min(i, j); k *= 2, l++) {
if (allblack(i, j, k, k) && k >= 4 && op == 1) ans1++;
c0[i][j][l] =
(c0[i][j][l - 1] && c0[i - k / 2][j][l - 1] &&
c0[i][j - k / 2][l - 1] && c0[i - k / 2][j - k / 2][l - 1]);
if (c0[i][j][l] && k >= 4 && op == 1) ans1++;
c1[i][j][l] = (c1[i][j][l - 1] && c1[i - k / 2][j][l - 1] &&
c1[i][j - k / 2][l - 1] &&
allblack(i - k / 2, j - k / 2, k / 2, k / 2));
if (c1[i][j][l] && k >= 4) ans1++;
c2[i][j][l] = (c2[i][j][l - 1] && c2[i][j - k / 2][l - 1] &&
allblack(i - k / 2, j, k / 2, k));
if (c2[i][j][l] && k >= 4) ans1++;
c3[i][j][l] = (c3[i][j][l - 1] && allblack(i - k / 2, j, k / 2, k) &&
allblack(i, j - k / 2, k / 2, k / 2));
if (c3[i][j][l] && k >= 4) ans1++;
c4[i][j][l] = (c4[i][j][l - 1] && c4[i - k / 2][j - k / 2][l - 1] &&
allblack(i - k / 2, j, k / 2, k / 2) &&
allblack(i, j - k / 2, k / 2, k / 2));
if (c4[i][j][l] && k >= 4) ans2++;
}
}
}
int main() {
cin >> n >> m;
for (int i = (1); i <= (n); i++) scanf("%s", s1[i] + 1);
for (int op = (1); op <= (4); op++) {
for (int i = (1); i <= (m); i++)
for (int j = (1); j <= (n); j++) s[i][j] = s1[n - j + 1][i];
swap(n, m);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) s1[i][j] = s[i][j];
doit(op);
}
cout << ans1 + ans2 / 2 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, mod = 998244353;
const int INF = 1e8;
int n, m;
char a[N];
int b[N];
int c[N];
int d[N];
bool check(int x) {
int mx = x;
for (int i = 1; i <= n; i++) {
b[i] = a[i] - '0';
d[i] = 0;
}
for (int i = n; i >= 1; i--) {
if (b[i] <= mx) {
d[i] = 1;
mx = b[i];
}
}
mx = x;
for (int i = 1; i <= n; i++) {
if (d[i]) continue;
if (b[i] < mx) {
return 0;
}
mx = b[i];
}
return 1;
}
int main() {
int t;
cin >> t;
while (t--) {
scanf("%d", &n);
scanf("%s", a + 1);
for (int i = 1; i <= n; i++) c[i] = 2;
int flag = -1;
for (int i = 0; i <= 9; i++) {
if (check(i)) {
flag = i;
break;
}
}
if (flag == -1) {
printf("-\n");
continue;
}
int mx = flag;
for (int i = n; i >= 1; i--) {
if (a[i] - '0' <= mx) {
mx = a[i] - '0';
c[i] = 1;
}
}
for (int i = 1; i <= n; i++) {
printf("%d", c[i]);
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
unsigned long long n;
cin >> n;
string s = bitset<64>(n).to_string();
int count = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1') {
count++;
}
}
cout << (2 * n - count) << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, k;
vector<int> p;
scanf("%d %d %d", &n, &h, &k);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
p.push_back(x);
}
long long g = 0, c = 0;
long long resp = 0;
while (1) {
while (g + p[c] <= h && c < p.size()) {
g += p[c++];
}
if (c < p.size()) {
long long x = p[c] - (h - g);
long long y = x / k + (x % k > 0);
resp += y;
g = max(g - y * k, 0LL);
} else
break;
}
resp += g / k + (g % k > 0);
printf("%lld\n", resp);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
string s;
cin >> s;
n = s.size();
int row = ceil((float)s.size() / 20);
int val = n / row, flag = 0;
if (n % row != 0) {
flag = (row - (n % row));
val++;
}
vector<string> ans;
int i = 0, count = 1;
while (count <= row) {
if (flag == 0) {
ans.push_back(s.substr(i, val));
i += (val);
} else {
ans.push_back(s.substr(i, val - 1) + '*');
i += (val - 1);
flag--;
}
count++;
}
cout << row << " " << val << "\n";
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
const int inf = 1e9 + 143;
const long long longinf = 1e18 + 143;
inline int read() {
int x;
scanf(" %d", &x);
return x;
}
const int MAX = 2000 * 366;
string days[7] = {"monday", "tuesday", "wednesday", "thursday",
"friday", "saturday", "sunday"};
int months[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool nonleap(int x) {
if (x % 4) {
return true;
} else if (x % 100) {
return false;
} else if (x % 400) {
return true;
} else {
return false;
}
}
int main() {
string sa, sb;
cin >> sa >> sb;
int a, b;
for (int i = 0; i < 7; i++) {
if (sa == days[i]) {
a = i;
}
if (sb == days[i]) {
b = i;
}
}
int cday = 6;
int cyear = 2015;
int cmonth = 1;
for (int it = 0; it < MAX; it++) {
int nday = (cday + months[cmonth]) % 7;
if (nonleap(cyear) && cday == a && nday == b) {
puts("YES");
return 0;
}
cday = nday;
cmonth++;
if (cmonth == 12) {
cmonth = 0;
cyear++;
}
}
puts("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100, S = 100, M = N * S, INF = 1e9;
int c[N][S], s[N], n;
int main() {
cin >> n;
int ciel = 0, jiro = 0;
vector<int> remain;
for (int i = 0; i < n; ++i) {
cin >> s[i];
for (int j = 0; j < s[i]; ++j) cin >> c[i][j];
for (int x = 0, y = s[i] - 1; x <= y; ++x, --y) {
if (x == y)
remain.push_back(c[i][x]);
else
ciel += c[i][x], jiro += c[i][y];
}
}
sort(remain.rbegin(), remain.rend());
for (unsigned i = 0; i < remain.size(); ++i) {
if ((i & 1) == 0)
ciel += remain[i];
else
jiro += remain[i];
}
cout << ciel << ' ' << jiro;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
int n, m, a[maxn], mm, ans, res[maxn];
map<int, int> mp;
int x, tot = 1, l, r;
inline void write() {
cout << ans << endl;
for (int i = 1; i < tot; i++) cout << res[i] << (i == tot - 1 ? '\n' : ' ');
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> mm;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) cin >> x, mp[x]++;
ans = 0;
for (int i = 1; i <= mm; i++) {
map<int, int> mp2;
l = r = i;
for (int j = i; j <= n; j += mm) {
int id = i + (l - i) * mm;
if (r - l < m) r++, mp2[a[j]]++;
if (r - l == m) {
if (mp2 == mp) res[tot++] = id, ans++;
if (--mp2[a[id]] == 0) mp2.erase(a[id]);
l++;
}
}
}
sort(res + 1, res + tot);
write();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const int MOD = 1e9 + 7;
int dx[8] = {0, 0, 1, -1, -1, 1, -1, 1}, dy[8] = {1, -1, 0, 0, -1, -1, 1, 1};
void INPUT() {}
void OUTPUT() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
INPUT();
OUTPUT();
string s;
cin >> s;
string ans = "", s1 = "", s0 = "";
for (int i = ((int)((s).size())) - 1; i >= 0; i--) {
if (s[i] == '0') {
ans += '0';
s0 += '0';
} else if (s[i] == '2') {
ans += '2';
s0 = "";
} else {
s1 += '1';
}
}
cout << s0 + s1;
int i = ((int)((ans).size())) - 1;
while (ans[i] == '0') {
i--;
}
while (i > -1) {
cout << ans[i];
i--;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long prime_const = 1e9 + 7;
bool sort_function(long long a, long long b) { return a < b; }
long long minim(long long x, long long y) {
if (x < y)
return x;
else
return y;
}
long long maxim(long long x, long long y) {
if (x > y)
return x;
else
return y;
}
int main() {
string s;
long long d, v1, v2, mod, b, c, l, r, ans = 0, p, x, y, sum, o = 0, t, m, mz,
f1, f2, time, st, f, len, n, k, mid,
min, max, z = 0;
cin >> n >> m;
vector<vector<long long> > vert(n + 1), dop(n + 1);
vector<int> a(n + 1, -1);
for (int i = 0; i < m; i++) {
cin >> l >> r;
vert[l].push_back(r);
vert[r].push_back(l);
}
for (int i = 1; i <= n; i++) {
sort(vert[i].begin(), vert[i].end(), sort_function);
}
for (int i = 1; i < n + 1; i++) {
if (vert[i].size() == 0) {
for (int j = 1; j <= n; j++) {
if (i != j) {
dop[i].push_back(j);
}
}
continue;
}
for (int j = 1; j < vert[i][0]; j++) {
if (i != j) {
dop[i].push_back(j);
}
}
for (int qq = 0; qq < vert[i].size() - 1; qq++) {
for (int j = vert[i][qq] + 1; j < vert[i][qq + 1]; j++) {
if (i != j) {
dop[i].push_back(j);
}
}
}
for (int j = vert[i][vert[i].size() - 1] + 1; j <= n; j++) {
if (i != j) {
dop[i].push_back(j);
}
}
}
for (int i = 1; i <= n; i++) {
if (vert[i].size() == n - 1) {
a[i] = 2;
}
}
z = 0;
for (int i = 1; i < n + 1; i++)
if (a[i] != 2) {
a[i] = 1;
z = i;
break;
}
if (z == 0) {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
cout << "b";
}
return 0;
}
a[z] = 1;
for (int i = 0; i < vert[z].size(); i++) {
if (a[vert[z][i]] != 2) {
a[vert[z][i]] = 1;
}
}
for (int i = 0; i < dop[z].size(); i++) {
if (a[dop[z][i]] == 2) {
cout << "NO";
return 0;
}
a[dop[z][i]] = 3;
}
for (int i = 1; i <= n; i++)
if (a[i] != 2) {
k = a[i];
for (int j = 0; j < vert[i].size(); j++) {
if ((a[vert[i][j]] != 2) && (a[vert[i][j]] != k)) {
cout << "NO";
return 0;
}
}
for (int j = 0; j < dop[i].size(); j++) {
if ((a[dop[i][j]] == 2) || (a[dop[i][j]] == k)) {
cout << "NO";
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
if (a[i] == 1) {
cout << 'a';
}
if (a[i] == 2) {
cout << 'b';
}
if (a[i] == 3) {
cout << 'c';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const long long mod = 1e9 + 7;
const int inf = INT_MAX;
long long cnt[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, j, k, m, n;
cin >> n;
while (n--) {
cin >> m;
long long root = sqrt(m);
for (i = 2; i <= root; i++) {
if (m % i == 0) cnt[i]++;
while (m % i == 0) m /= i;
}
if (m > 1) cnt[m]++;
}
long long ans = 1;
ans = max(ans, *max_element(cnt, cnt + maxn));
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10, pi = 3.1415926535898;
const int mod = 998244353, maxn = 2e5 + 10, maxm = 18;
int T, n, m, k, x, y, z;
long long dp[maxn][20][2], v, dd[maxn][2];
long long qpow(long long x, int k) {
long long cnt = 1;
while (k) {
if (k & 1) cnt = cnt * x % mod;
x = x * x % mod;
k >>= 1;
}
return cnt;
}
vector<int> v1[maxn], v2[maxn];
struct P {
int x, y, z;
bool operator<(const P& a) const {
if (x == a.x) return y < a.y;
return x < a.x;
}
};
queue<P> q;
int main(int argc, char const* argv[]) {
T = 1;
for (int _ = 1; _ <= T; ++_) {
long long ans = 1LL * mod * mod;
scanf("%d %d", &n, &m);
for (int i = 1; i < maxn; ++i) {
for (int j = 0; j < maxm; ++j)
dp[i][j][0] = dp[i][j][1] = 1LL * mod * mod;
}
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &x, &y);
v1[x].push_back(y);
v2[y].push_back(x);
}
dp[1][0][0] = 0;
q.push({1, 0, 0});
while (!q.empty()) {
x = q.front().x;
y = q.front().y;
z = q.front().z;
q.pop();
if (!z) {
for (auto i : v1[x]) {
if (dp[x][y][z] + 1 < dp[i][y][z] and
(y == 0 or dp[x][y][z] + 1 < dp[i][y - 1][z])) {
dp[i][y][z] = dp[x][y][z] + 1;
q.push({i, y, z});
}
}
for (auto i : v2[x]) {
if (y >= maxm) break;
if (dp[x][y][z] + (1 << y) + 1 < dp[i][y + 1][z ^ 1] and
(y == 0 or dp[x][y][z] + (1 << y) + 1 < dp[i][y + 1][z ^ 1])) {
dp[i][y + 1][z ^ 1] = dp[x][y][z] + (1 << y) + 1;
q.push({i, y + 1, z ^ 1});
}
}
} else {
for (auto i : v2[x]) {
if (dp[x][y][z] + 1 < dp[i][y][z] and
(y == 0 or dp[x][y][z] + 1 < dp[i][y - 1][z])) {
dp[i][y][z] = dp[x][y][z] + 1;
q.push({i, y, z});
}
}
for (auto i : v1[x]) {
if (y >= maxm) break;
if (dp[x][y][z] + (1 << y) + 1 < dp[i][y + 1][z ^ 1] and
(y == 0 or dp[x][y][z] + (1 << y) + 1 < dp[i][y + 1][z ^ 1])) {
dp[i][y + 1][z ^ 1] = dp[x][y][z] + (1 << y) + 1;
q.push({i, y + 1, z ^ 1});
}
}
}
}
for (int i = 0; i < maxm; ++i) {
if (dp[n][i][0] < mod) {
ans = min(ans, dp[n][i][0]);
}
if (dp[n][i][1] < mod) {
ans = min(ans, dp[n][i][1]);
}
}
if (ans < mod) {
printf("%lld\n", ans % mod);
return 0;
}
for (int i = 1; i < maxn; ++i) {
for (int j = 0; j < 2; ++j) {
dd[i][j] = 1LL * mod * mod;
}
}
dd[1][0] = 0;
q.push({1, 0, 0});
while (!q.empty()) {
x = q.front().x;
y = q.front().y;
z = q.front().z;
q.pop();
if (!y) {
for (auto i : v1[x]) {
if (dd[x][y] + 1 < dd[i][y]) {
dd[i][y] = dd[x][y] + 1;
q.push({i, y, 0});
}
}
for (auto i : v2[x]) {
if (dd[x][y] + mod + 1 < dd[i][y ^ 1]) {
dd[i][y ^ 1] = dd[x][y] + mod + 1;
q.push({i, y ^ 1, 0});
}
}
} else {
for (auto i : v2[x]) {
if (dd[x][y] + 1 < dd[i][y]) {
dd[i][y] = dd[x][y] + 1;
q.push({i, y, 0});
}
}
for (auto i : v1[x]) {
if (dd[x][y] + mod + 1 < dd[i][y ^ 1]) {
dd[i][y ^ 1] = dd[x][y] + mod + 1;
q.push({i, y ^ 1, 0});
}
}
}
}
if (dd[n][0] > dd[n][1]) {
ans = qpow(2, dd[n][1] / mod) + dd[n][1] % mod - 1;
} else {
ans = qpow(2, dd[n][0] / mod) + dd[n][0] % mod - 1;
}
printf("%lld\n", ans % mod);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
vector<int> edge[500005], ans[500005];
int pA;
struct UFS {
int fa[500005];
void init(int n) {
int i;
for (i = 0; i < n; i++) fa[i] = i;
}
int find(int x) { return x == fa[x] ? x : (fa[x] = find(fa[x])); }
void uni(int x, int y) { fa[find(x)] = find(y); }
} ufs;
void dfs(int x) {
int i;
ufs.uni(x, x + 1);
ans[pA].push_back(x);
for (i = ufs.find(1); i <= N; i = ufs.find(i + 1)) {
vector<int>::iterator it = lower_bound(edge[x].begin(), edge[x].end(), i);
if (it == edge[x].end() || *it != i) dfs(i);
}
}
int main() {
int i, j;
scanf("%d%d", &N, &M);
for (i = 0; i < M; i++) {
int s, f;
scanf("%d%d", &s, &f);
edge[s].push_back(f);
edge[f].push_back(s);
}
for (i = 1; i <= N; i++) sort(edge[i].begin(), edge[i].end());
ufs.init(N + 2);
for (i = ufs.find(1), pA = 0; i <= N; i = ufs.find(i + 1)) dfs(i), pA++;
printf("%d\n", pA);
for (i = 0; i < pA; i++) {
printf("%d ", ((int)(ans[i]).size()));
for (j = 0; j < ((int)(ans[i]).size()) - 1; j++) printf("%d ", ans[i][j]);
printf("%d\n", ans[i][j]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<vector<int> > s;
int kol;
int del[1005];
int main() {
int n;
cin >> n;
vector<int> v;
v.clear();
for (int i = 0; i < n; ++i) v.push_back(0);
s.insert(v);
for (int i = 2; i <= n; ++i) {
v.clear();
for (int j = 0; j < n; ++j) v.push_back(0);
for (int j = 0; j < kol; ++j)
if (!(i % del[j])) v[j] = 1;
if (s.find(v) != s.end()) {
del[kol++] = i;
v[kol - 1] = 1;
s.insert(v);
} else {
s.insert(v);
}
}
cout << kol << endl;
for (int i = 0; i < kol; ++i) cout << del[i] << ' ';
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long res = 1ll;
while (b > 0) {
if (b % 2 != 0) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b /= 2;
}
return res;
}
long long ncr(long long n, long long k) {
if (k > n - k) k = n - k;
long long pro = 1;
for (long long i = 0; i < k; i++) {
pro = (pro * (n - i)) % 1000000007;
pro /= (i + 1);
}
return (pro % 1000000007);
}
vector<long long> prime;
void seive() {
vector<bool> isprime(2000001, true);
for (int i = 2; i * i <= 2000000; i++) {
if (isprime[i]) {
for (int j = i * i; j <= 2000000; j += i) {
isprime[j] = false;
}
}
}
for (int i = 2; i <= 1000000; i++) {
if (isprime[i]) prime.push_back(i);
}
}
vector<vector<pair<long long, long long>>> dp;
vector<pair<long long, long long>> arr;
pair<long long, long long> paired(int i, int j) {
pair<long long, long long> a = {arr[i].first + j, 1e18};
if (arr[i].first + j != dp[i - 1][0].first) a.second = dp[i - 1][0].second;
if (arr[i].first + j != dp[i - 1][1].first) {
if (a.second > dp[i - 1][1].second) a.second = dp[i - 1][1].second;
}
if (arr[i].first + j != dp[i - 1][2].first) {
if (a.second > dp[i - 1][2].second) a.second = dp[i - 1][2].second;
}
a.second += j * arr[i].second;
return a;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t, n, a, b;
cin >> t;
while (t--) {
cin >> n;
arr.resize(n);
for (int i = 0; i < n; i++) {
cin >> a >> b;
arr[i] = {a, b};
}
dp.resize(n, vector<pair<long long, long long>>(3));
dp[0] = {{arr[0].first, 0},
{arr[0].first + 1, arr[0].second},
{arr[0].first + 2, 2 * arr[0].second}};
for (int i = 1; i < n; i++) {
for (int j = 0; j < 3; j++) {
dp[i][j] = paired(i, j);
}
}
long long ans =
min(dp[n - 1][0].second, min(dp[n - 1][1].second, dp[n - 1][2].second));
cout << ans << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> m;
int main() {
m["void"] = 0;
int N;
scanf("%d", &N);
;
for (int(n) = 0; n < (int)N; n++) {
string s1;
cin >> s1;
if (s1 == "typeof") {
string s2;
cin >> s2;
string help;
int num = 0;
for (int(n) = 0; n < (int)s2.length(); n++) {
if (s2[n] == '*') {
num++;
} else if (s2[n] == '&') {
num--;
} else {
help += s2[n];
}
}
if (m.find(help) == m.end() || (m[help] < 0) || (m[help] + num < 0)) {
puts("errtype");
} else {
printf("void");
int l = m[help] + num;
for (int(n) = 0; n < (int)l; n++) printf("*");
printf("\n");
}
} else {
string a, b;
cin >> a >> b;
int num = 0;
string name;
for (int(n) = 0; n < (int)a.length(); n++) {
if (a[n] == '&') {
num--;
} else if (a[n] == '*') {
num++;
} else {
name += a[n];
}
}
if (m.find(name) == m.end() || (m[name] < 0)) {
m[b] = -1;
} else {
m[b] = m[name] + num;
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long max1 = 11;
const long long max2 = 102;
const long long max3 = 1003;
const long long max4 = 10004;
const long long maxx = 100005;
const long long max6 = 1000006;
const long long max7 = 10000007;
const long long lg2 = 7;
const long long lg3 = 10;
const long long lg4 = 13;
const long long lg5 = 17;
const long long lg6 = 20;
const long long lg7 = 24;
const long long lg8 = 27;
const long long lg9 = 30;
const long long lg18 = 60;
const long long INF = 2LL * 1000000000;
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long is_prime(long long n) {
if (n == 1) return 0;
if (n == 2) return 1;
if (n % 2 == 0) return 0;
for (long long i = 3; i <= sqrt(n); i += 2)
if (n % i == 0) return 0;
return 1;
}
long long is_integer(double n) {
if (floor(n) == ceil(n)) return 1;
return 0;
}
long long sto_int(string s) {
stringstream ss(s);
long long n;
ss >> n;
return n;
}
string to_string(long long n) {
stringstream ss;
ss << n;
string s = ss.str();
return s;
}
long long n, k;
long long arr[maxx];
vector<pair<long long, long long> > v;
long long cnt[20];
long long divisible() {
for (long long i = 0; i < v.size(); i++) {
if (cnt[i] < v[i].second) return 0;
}
return 1;
}
void add_num(long long num) {
for (long long i = 0; i < v.size(); i++) {
if (num % v[i].first == 0) {
while (num % v[i].first == 0) {
num /= v[i].first;
cnt[i]++;
}
}
}
}
void del_num(long long num) {
for (long long i = 0; i < v.size(); i++) {
if (num % v[i].first == 0) {
while (num % v[i].first == 0) {
num /= v[i].first;
cnt[i]--;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
;
cin >> n >> k;
if (k == 1) {
cout << n * (n + 1) / 2LL << endl;
return 0;
}
for (long long i = 2; i * i <= k; i++) {
if (k % i == 0) {
v.push_back({i, 0});
while (k % i == 0) {
k /= i;
v[v.size() - 1].second++;
}
}
}
if (k > 1) {
v.push_back({k, 1});
}
for (long long i = 1; i <= n; i++) {
cin >> arr[i];
}
long long l = 1, r = 1;
long long x = 1;
long long ans = 0;
while (l <= n && r <= n) {
while (!divisible() && r <= n) {
add_num(arr[r]);
r++;
}
if (!divisible()) break;
while (divisible()) {
del_num(arr[l]);
l++;
}
ans = ans + 1LL * (l - x) * (n - r + 2);
x = l;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1000;
const int key = 701;
int n;
int perm[maxN];
int weight[maxN];
vector<pair<int, int> > edges;
int height[maxN];
set<int> parents[maxN];
int query(int v, vector<int> a, vector<int> b) {
cout << (int)a.size() << endl;
for (int i = 0; i < (int)a.size(); i++) cout << (i ? " " : "") << perm[a[i]];
cout << endl;
cout << (int)b.size() << endl;
for (int i = 0; i < (int)b.size(); i++) cout << (i ? " " : "") << perm[b[i]];
cout << endl;
cout << perm[v] << endl;
cout.flush();
int ans;
cin >> ans;
return ans;
}
int find_center(vector<int> &vertices, int H = 0) {
if ((int)vertices.size() <= 2) return vertices[0];
vector<int> ans;
vector<int> first(vertices.begin(),
vertices.begin() + (int)vertices.size() / 2);
vector<int> second(vertices.begin() + (int)vertices.size() / 2,
vertices.end());
for (auto x : vertices) ans.push_back(query(x, first, second));
return vertices[max_element(ans.begin(), ans.end()) - ans.begin()];
}
void find_tree(int v, vector<int> &vertices) {
vector<int> can;
vector<vector<int> > members;
int deg = 0;
for (auto i : vertices)
if (i != v) {
int s = 0, e = deg;
if (e > s && query(v, {i}, can) < (int)(can.size())) {
while (e - s > 1) {
int mid = (e + s) / 2;
if (query(v, {i}, vector<int>(can.begin() + s, can.begin() + mid)) ==
mid - s)
s = mid;
else
e = mid;
}
members[s].push_back(i);
} else {
can.push_back(i);
members.push_back({i});
deg++;
}
}
for (int j = 0; j < deg; j++) {
int u = find_center(members[j], height[v] + 1);
set<int> copy(parents[v]);
for (auto parent : copy) {
if (query(v, {parent}, members[j]) < (int)members[j].size())
parents[v].erase(parent), parents[u].insert(parent);
}
parents[u].insert(v);
height[u] = height[v] + 1;
find_tree(u, members[j]);
}
for (auto parent : parents[v]) edges.push_back(pair<int, int>(v, parent));
}
int main() {
srand(time(NULL));
cin >> n;
iota(perm, perm + n, 1);
random_shuffle(perm, perm + n);
vector<int> v(n);
iota(v.begin(), v.end(), 0);
find_tree(find_center(v), v);
cout << "ANSWER" << endl;
for (auto edge : edges)
cout << perm[edge.first] << ' ' << perm[edge.second] << endl;
cout.flush();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const char lend = '\n';
int good(int k, int n, int m) {
int a, b, c;
c = k / 6;
a = k / 2 - c;
b = k / 3 - c;
n = max(0, n - a);
m = max(0, m - b);
return n + m <= c;
}
int main() {
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 2;; ++i) {
if (good(i, n, m)) {
cout << i << endl;
break;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 4e3 + 10;
int dp[N][N];
int a[N], b[N];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
}
fill(dp[0], dp[0] + N, 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= k; j++) {
dp[i][j] = max(dp[i - 1][j], a[i]) + b[i];
if (j > 0) dp[i][j] = min(dp[i][j], dp[i - 1][j - 1]);
}
}
a[n + 1] = 86401;
int ans = 0;
for (int i = 0; i <= n; i++) {
ans = max(ans, a[i + 1] - dp[i][k]);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int isLower(char c) { return 97 <= c && c <= 122; }
int isUpper(char c) { return 65 <= c && c <= 90; }
char toLower(char ch) {
if (isLower(ch)) return ch;
return ch + 32;
}
string toLower(string str) {
string ans;
int i;
for ((i) = 0; (i) < (int)(((int)(str).size())); (i)++) {
ans += (isLower(str[i])) ? str[i] : (str[i] + 32);
}
return ans;
}
int main() {
int arr[105];
memset(arr, 0, sizeof(arr));
int n;
cin >> n;
string fbd[105], str;
string charr;
char ch;
int i, j, k;
for ((i) = 0; (i) < (int)(n); (i)++) cin >> fbd[i];
cin >> str;
cin >> charr;
ch = charr[0];
for ((i) = 0; (i) < (int)(n); (i)++) {
int len1 = ((int)(str).size()), len2 = ((int)(fbd[i]).size());
for ((j) = 0; (j) < (int)(len1 - len2 + 1); (j)++)
if (toLower(str.substr(j, len2)) == toLower(fbd[i])) {
for (k = j; k < j + len2; k++) arr[k] = 1;
}
}
for ((i) = 0; (i) < (int)(((int)(str).size())); (i)++)
if (arr[i]) {
if (toLower(str[i]) != toLower(ch)) {
if (isLower(str[i]))
str[i] = toLower(ch);
else
str[i] = (toLower(ch) - 32);
} else {
if (isLower(str[i])) {
if (toLower(ch) != 'a')
str[i] = 'a';
else
str[i] = 'b';
} else {
if (toLower(ch) != 'a')
str[i] = 'A';
else
str[i] = 'B';
}
}
}
cout << str;
cin.get();
cin.get();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n;
scanf("%d", &n);
printf("%d\n", (n - 1) / 2);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct cc {
int a;
int b;
} xx[100005];
bool vis[100005];
int ss[100005];
vector<cc> vec;
bool cmp(cc x, cc y) { return x.b < y.b; }
int main() {
int n, m, i, j, k, sum;
long long ans;
while (~scanf("%d%d", &n, &m)) {
ans = 0;
sum = 0;
memset(vis, false, sizeof vis);
memset(ss, 0, sizeof ss);
for (i = 1; i <= n; i++) {
scanf("%d", &xx[i].a);
ss[xx[i].a]++;
}
for (i = 1; i <= m; i++) {
if (ss[i] == 0) sum++;
}
for (i = 1; i <= n; i++) {
scanf("%d", &xx[i].b);
if (ss[xx[i].a] > 1) vec.push_back(xx[i]);
}
if (sum == 0) {
printf("%lld\n", ans);
vec.clear();
continue;
}
sort(vec.begin(), vec.end(), cmp);
i = 0;
while (1) {
if (ss[vec[i].a] > 1) {
ans += vec[i].b;
sum--;
ss[vec[i].a]--;
}
if (sum == 0) break;
i++;
}
vec.clear();
printf("%lld\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1001100;
int arr[N];
const int mod = 100000000;
struct point {
int i;
int j;
int strength;
} points[N];
bool cmp(point p1, point p2) { return p1.strength > p2.strength; }
int main() {
int n;
while (cin >> n) {
int cnt = 0;
for (int i = 2; i <= 2 * n; i++) {
for (int j = 1; j < i; j++) {
cin >> points[cnt].strength;
points[cnt].i = i;
points[cnt].j = j;
cnt++;
}
}
sort(points, points + cnt, cmp);
map<int, int> m;
map<int, int> ret;
for (int k = 0; k < cnt; k++) {
if (m[points[k].i] == 0 && m[points[k].j] == 0) {
ret[points[k].i] = points[k].j;
ret[points[k].j] = points[k].i;
m[points[k].i] = 1;
m[points[k].j] = 1;
}
}
for (int i = 1; i <= 2 * n; i++) cout << ret[i] << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int maxn = 1010000;
char str[maxn], a[maxn];
char xsk[10][5] = {"1869", "1968", "1689", "6198", "1698", "1986", "1896"};
int s1, s2, s3, s4;
int main() {
while (~scanf("%s%*c", str)) {
s1 = s2 = s3 = s4 = 1;
int t = 0, sum1 = 0, sum2 = 0;
int len = strlen(str);
for (int i = 0; i < len; i++)
if (str[i] == '0') sum1++;
for (int i = 0; i < len; i++) {
if (str[i] == '0') continue;
if (str[i] == '1' && s1) {
s1--;
continue;
}
if (str[i] == '6' && s2) {
s2--;
continue;
}
if (str[i] == '8' && s3) {
s3--;
continue;
}
if (str[i] == '9' && s4) {
s4--;
continue;
}
a[t++] = str[i];
sum2 = (sum2 * 10 + str[i] - '0') % 7;
}
printf("%s", a);
if (sum2 == 0) printf("%s", xsk[0]);
if (sum2 == 1) printf("%s", xsk[3]);
if (sum2 == 2) printf("%s", xsk[6]);
if (sum2 == 3) printf("%s", xsk[2]);
if (sum2 == 4) printf("%s", xsk[5]);
if (sum2 == 5) printf("%s", xsk[1]);
if (sum2 == 6) printf("%s", xsk[4]);
for (int i = 0; i < sum1; i++) printf("0");
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[222];
int main() {
int n;
cin >> n;
for (int i = 0; i < 2 * n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = 0; i < n; i++) {
int pos = 2 * i + 1;
for (int j = 2 * i + 1; j < 2 * n; j++) {
if (a[j] == a[2 * i]) pos = j;
}
for (int j = pos; j > 2 * i + 1; j--) {
a[j] = a[j - 1];
ans++;
}
a[2 * i + 1] = a[2 * i];
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, yes, i, j, k, t, x, y, l, r, tmp, mn, curr, ans;
long long arr[1000005];
vector<pair<long long, long long> > v;
string second;
int main() {
cin >> n >> k;
for (i = 0; i < n; i++) cin >> arr[i];
for (i = 0; i < n; i++) {
if (arr[i] == 1) {
tmp = 1;
while (i + 1 < n && arr[i + 1] == 1) {
tmp++;
i++;
}
v.push_back(make_pair(tmp, 1));
} else {
v.push_back(make_pair(arr[i], 0));
}
}
for (i = 0; i < v.size(); i++) {
curr = 1;
tmp = 0;
for (j = i; j < min((long long)v.size(), i + 100); j++) {
if (curr >= LLONG_MAX / v[j].first) break;
if (!v[j].second) {
curr *= v[j].first;
tmp += v[j].first;
if (curr % tmp == 0 && curr / tmp == k) {
ans++;
}
} else {
if (curr % k == 0 && curr / k > tmp && curr / k <= tmp + v[j].first)
ans++;
tmp += v[j].first;
}
}
if (v[i].second && v[i].first > 1) {
v[i].first--;
i--;
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int Pow(long long int a, long long int b, long long int md,
long long int ans = 1) {
for (; b; b >>= 1, a = a * a % md)
if (b & 1) ans = ans * a % md;
return ans % md;
}
const long long int MAXN = 1e5 + 10;
const long long int INF = 8e18;
const long long int MOD = 1e9 + 7;
long long int n;
int main() {
scanf("%lld", &n);
if (n <= 5) {
printf("-1\n");
for (long long int i = 2; i <= n; i++) printf("%lld %lld\n", i, i - 1);
return 0;
}
for (long long int i = 3; i <= n; i++) {
printf("%lld %lld\n", 2 - (i & 1), i);
}
printf("%lld %lld\n", 1LL, 2LL);
for (long long int i = 2; i <= n; i++) {
printf("%lld %lld\n", 1LL, i);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 305;
int n, x[N], y[N], a[N], ans;
int f(int i, int j, int k, int l) {
return x[i] * y[j] + x[j] * y[k] + x[k] * y[l] + x[l] * y[i] - x[j] * y[i] -
x[k] * y[j] - x[l] * y[k] - x[i] * y[l];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) continue;
int dx = x[j] - x[i];
int dy = y[i] - y[j];
pair<int, int> now = {-1, -1};
for (int k = 1; k <= n; k++) {
if (k == i || k == j) continue;
a[k] = x[k] * dy + y[k] * dx;
if (now.first == -1 || a[k] >= a[now.first]) {
now.second = now.first;
now.first = k;
} else if (now.second == -1 || a[k] >= a[now.second]) {
now.second = k;
}
}
for (int k = 1; k <= n; k++) {
if (k == i || k == j) continue;
int l = now.first;
if (l == k) {
l = now.second;
}
ans = max(ans, f(i, k, j, l));
}
}
}
cout << ans / 2 << "." << ((ans & 1) ? 5 : 0) << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, w, s, k, t;
long long fr(long long n) {
w = 0;
while (n) {
w += n / 10 * 9;
n /= 10;
}
return w;
}
int main() {
cin >> n >> s;
for (long long i = s; i <= n; i++) {
if (fr(i) >= s) {
cout << n - i + 1;
return 0;
}
}
cout << 0;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const int inf = 0x3f3f3f3f;
char str[1000005];
const int N = 4000005;
struct node {
int open, close, done;
node() {}
node(int a, int b, int c) : open(a), close(b), done(c) {}
void foo(const node &a, const node &b) {
int k = min(a.open, b.close);
open = a.open + b.open - k;
close = a.close + b.close - k;
done = a.done + b.done + 2 * k;
}
} tree[N];
void build(int no, int l, int r) {
if (l == r) {
if (str[l] == '(')
tree[no] = node(1, 0, 0);
else
tree[no] = node(0, 1, 0);
return;
}
int nl = no << 1, nr = nl + 1, mid = (l + r) >> 1;
build(nl, l, mid);
build(nr, mid + 1, r);
tree[no].foo(tree[nl], tree[nr]);
}
node query(int no, int l, int r, int i, int j) {
if (i > r || j < l) return node(0, 0, 0);
if (i <= l && r <= j) return tree[no];
int nl = no << 1, nr = nl + 1, mid = (l + r) >> 1;
node a = query(nl, l, mid, i, j);
node b = query(nr, mid + 1, r, i, j);
node c;
c.foo(a, b);
return c;
}
int main() {
scanf("%s", str);
int n = strlen(str);
build(1, 0, n - 1);
int q;
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
--l;
--r;
printf("%d\n", query(1, 0, n - 1, l, r).done);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
const long long inf = 4e18;
const int infi = 2e9;
int i, j, n, m, k, qq = 1, fr, to, w, x, y, mod = 998244353;
char ch;
vector<vector<int> > g;
vector<int> ans;
int max_pos;
void dfs(int second, int pr, int pos) {
ans[pos] = second;
ans[max_pos + g[second].size() + (second == pr)] = second;
max_pos += g[second].size() + (second == pr);
int cur_pos = max_pos;
int cnt = 0;
for (int i = 0; i < g[second].size(); i++) {
int to = g[second][i];
if (to != pr) {
cnt++;
dfs(to, second, cur_pos - cnt);
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
g.resize(n);
ans.resize(2 * n, -1);
for (int i = 1; i < n; i++) {
cin >> fr >> to;
fr--;
to--;
g[fr].push_back(to);
g[to].push_back(fr);
}
dfs(0, 0, 0);
vector<vector<int> > v(n);
for (int i = 0; i < 2 * n; i++) {
v[ans[i]].push_back(i + 1);
}
for (auto x : v) {
cout << x[0] << ' ' << x[1] << '\n';
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void getFoo(T &x) {
x = 0;
register char c = getchar_unlocked();
for (; c < 48 || c > 57; c = getchar_unlocked())
;
for (; c > 47 && c < 58; c = getchar_unlocked())
x = (x << 1) + (x << 3) + c - 48;
}
template <typename T1, typename T2>
void getFoo(T1 &x, T2 &y) {
getFoo(x);
getFoo(y);
}
template <typename T1, typename T2, typename T3>
void getFoo(T1 &x, T2 &y, T3 &z) {
getFoo(x);
getFoo(y);
getFoo(z);
}
inline void solve() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
getFoo(n);
vector<int> primes;
vector<int> ans;
for (long long i = (2); i < (n + 1); ++i) {
int cnt = 0;
for (long long j = (1); j < (i + 1); ++j) {
if (i % j == 0) ++cnt;
if (cnt > 2) break;
}
if (cnt == 2) {
int temp = i;
while (temp <= n) {
ans.push_back(temp);
temp *= i;
}
}
}
printf("%d\n", ans.size());
for (int x : ans) printf("%d ", x);
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
void ckmin(T &a, U b) {
if (a > b) a = b;
}
template <class T, class U>
void ckmax(T &a, U b) {
if (a < b) a = b;
}
int N, K;
vector<int> str;
vector<int> dp;
bitset<5013> ok[5013];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(12);
cerr << fixed << setprecision(4);
string temps;
cin >> temps;
N = ((int)((temps).size()));
str.resize(((int)((temps).size())));
for (auto i = (0); i < (((int)((temps).size()))); i++) {
str[i] = (temps[i] - 'a' + 1);
}
K = 31 - __builtin_clz(N);
dp.resize(N - (1 << K) + 1);
ok[0][0] = true;
for (auto i = (0); i < (((int)((dp).size()))); i++) {
dp[i] = 30;
for (auto j = (i); j < (N); j++) {
if (!ok[j][j - i]) continue;
ckmin(dp[i], str[j]);
for (auto k = (0); k < (K); k++) {
if ((j - i) & (1 << k)) continue;
ok[j + (1 << k)][j - i + (1 << k)] = true;
}
}
for (auto j = (i); j < (N); j++) {
if (!ok[j][j - i]) continue;
if (dp[i] == str[j]) {
ok[j + 1][j - i] = true;
}
}
}
for (auto i = (0); i < (((int)((dp).size()))); i++) {
cout << (char)(dp[i] + 'a' - 1);
}
cout << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2009;
int n, pos, vis[N];
long long dis[N], g[N][N], mi;
void dij(int u) {
memset(dis, 0x3f, sizeof(dis));
memset(vis, 0, sizeof(vis));
vis[u] = 1;
for (int i = 1; i <= n; i++) {
dis[i] = g[u][i];
for (int j = 1; j <= n; j++)
if (j != i) dis[i] = min(dis[i], 2 * g[i][j]);
}
for (int i = 1; i < n; i++) {
int u = -1;
for (int j = 1; j <= n; j++)
if (!vis[j] && (u == -1 || dis[j] < dis[u])) u = j;
vis[u] = 1;
for (int j = 1; j <= n; j++)
if (!vis[j] && dis[j] > dis[u] + g[u][j]) dis[j] = dis[u] + g[u][j];
}
return;
}
int main() {
scanf("%d", &n);
mi = 1e10, pos = 1;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
scanf("%lld", &g[i][j]);
g[j][i] = g[i][j];
if (g[i][j] < mi) mi = g[i][j], pos = i;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j) g[i][j] -= mi;
dij(pos);
for (int i = 1; i <= n; i++) {
printf("%lld\n", mi * (n - 1) + dis[i]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
const int maxn = 30000, J = 10;
struct Aca {
int next[maxn][J], fail[maxn];
int deep[maxn];
int root, L;
int newNode() {
for (int(i) = 0; (i) < (int)(J); (i)++) next[L][i] = -1;
L++;
return L - 1;
}
void init() {
L = 0;
root = newNode();
}
void insert(char *str, int len) {
int now = root;
for (int i = 0; i < len; i++) {
int temp = str[i] - '0';
if (next[now][temp] == -1) {
next[now][temp] = newNode();
deep[next[now][temp]] = deep[now] + 1;
}
now = next[now][temp];
}
}
void build() {
queue<int> que;
fail[root] = root;
for (int i = 0; i < J; i++) {
if (next[root][i] == -1) {
next[root][i] = root;
} else {
fail[next[root][i]] = root;
que.push(next[root][i]);
}
}
while (!que.empty()) {
int now = que.front();
que.pop();
for (int i = 0; i < J; i++) {
int t = next[now][i];
if (t == -1) {
next[now][i] = next[fail[now]][i];
} else {
fail[t] = next[fail[now]][i];
que.push(t);
}
}
}
}
} ac;
void add(int &x, int y) {
long long z = (long long)x + y;
if (z >= 1000000007) z -= 1000000007;
x = z;
}
char s[1005], x[105], y[105];
int d;
int dp[55][maxn][2][2][2];
void fmain() {
scanf("%s", s + 1);
scanf("%s%s", x + 1, y + 1);
n = strlen(x + 1);
d = n / 2;
int sl = strlen(s + 1);
ac.init();
for (int i = 1; i + d - 1 <= sl; i++) ac.insert(s + i, d);
ac.build();
dp[0][0][0][0][0] = 1;
for (int(i) = 1; (i) <= (int)(n); (i)++) {
for (int(v) = 0; (v) < (int)(ac.L); (v)++) {
for (int(b1) = 0; (b1) < (int)(2); (b1)++)
for (int(b2) = 0; (b2) < (int)(2); (b2)++)
for (int(b) = 0; (b) < (int)(2); (b)++)
if (dp[i - 1][v][b1][b2][b] != 0) {
int pre = dp[i - 1][v][b1][b2][b];
for (int(num) = 0; (num) < (int)(10); (num)++) {
int nv = ac.next[v][num];
if (b1 && b2) {
if (b)
add(dp[i][nv][1][1][1], pre);
else
add(dp[i][nv][1][1][ac.deep[nv] >= d], pre);
} else if (b1 && !b2) {
if (num > y[i] - '0') continue;
bool ok = num < y[i] - '0';
if (b)
add(dp[i][nv][1][ok][1], pre);
else
add(dp[i][nv][1][ok][ac.deep[nv] >= d], pre);
} else if (!b1 && b2) {
if (num < x[i] - '0') continue;
bool ok = num > x[i] - '0';
if (b)
add(dp[i][nv][ok][1][1], pre);
else
add(dp[i][nv][ok][1][ac.deep[nv] >= d], pre);
} else {
if (num > y[i] - '0' || num < x[i] - '0') continue;
bool ok2 = num < y[i] - '0';
bool ok1 = num > x[i] - '0';
if (b)
add(dp[i][nv][ok1][ok2][1], pre);
else
add(dp[i][nv][ok1][ok2][ac.deep[nv] >= d], pre);
}
}
}
}
}
int ans = 0;
for (int(i) = 0; (i) < (int)(ac.L); (i)++)
for (int(b1) = 0; (b1) < (int)(2); (b1)++)
for (int(b2) = 0; (b2) < (int)(2); (b2)++) add(ans, dp[n][i][b1][b2][1]);
printf("%d\n", ans);
}
int main() {
fmain();
return 0;
}
| 12 |
#include <bits/stdc++.h>
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
using namespace std;
string to_string(int a) {
stringstream ss;
ss << a;
string s = ss.str();
return s;
}
int dp[103][3];
int main() {
memset(dp, 0, sizeof(dp));
;
int n;
cin >> n;
int x;
for (int i = 1; i <= n; ++i) {
cin >> x;
dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][1], dp[i - 1][2]));
if (x == 1 || x == 3) dp[i][1] = max(dp[i - 1][0], dp[i - 1][2]) + 1;
if (x == 2 || x == 3) dp[i][2] = max(dp[i - 1][1], dp[i - 1][0]) + 1;
}
cout << n - max(dp[n][0], max(dp[n][1], dp[n][2]));
return 0;
}
| 3 |
/*-- ILSH --*/
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef double ld;
#define pb push_back
#define pop pop_back
#define mp make_pair
#define vii vector < ll >
#define dt cout<<"HERE\n";
#define pii pair < ll , ll >
#define vpi vector < pii >
#define fi first
#define se second
#define sz(x) ((ll)x.size())
#define len(x) ((ll)x.length())
const ll inf=1e18+1e17;
const ll mod =1e9+7;
using cd= complex < double > ;
//const ll mod = 998244353;
ll modInverse(ll a,ll m){ll m0=m;ll y=0,x=1;if(m == 1)return 0;while(a> 1){ll q=a/m;ll t=m;m=a%m,a=t;t=y;y=x-q*y;x=t;}if(x<0)x+=m0;return x;}
ll powm(ll a,ll b){a=a%mod;ll res=1;while(b){if(b&1)res=(res*a)%mod;a=(a*a)%mod;b>>=1;}return (res%mod);}
const ll N = 3e5 +5;
void solve(){
ll a, b, c;
cin>>a>>b>>c;
ll tot=(a+b+c);
if ( tot%9!=0){
cout<<"NO\n";
return;
}
ll cnt=tot/9;
ll mn=min( a,b);
mn=min( mn,c);
if ( mn<cnt){
cout<<"NO\n";
return;
}
cout<<"YES\n";
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie( NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen ("INPUT.txt" , "r" , stdin);
freopen ("OUTPUT.txt", "w" , stdout);
#endif
ll t=1;
cin>>t;
for ( ll i=1;i<=t;i++){
//cout<<"Case "<<i<<": ";
solve();
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 1;
const int lgN = 19;
vector<int> G[maxN];
int N, M, d[maxN], p[lgN][maxN], root, size[maxN];
void dfs(int u, int f) {
size[u] = 1;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v == f)
continue;
else {
p[0][v] = u;
d[v] = d[u] + 1;
dfs(v, u);
size[u] += size[v];
}
}
}
void init() {
for (int i = 0; i < lgN; ++i) {
p[i][root] = root;
}
for (int i = 1; i < lgN; ++i) {
for (int j = 1; j <= N; ++j) {
p[i][j] = p[i - 1][p[i - 1][j]];
}
}
}
int lca(int x, int y) {
if (d[y] > d[x]) swap(x, y);
for (int i = 0; i < lgN; ++i) {
if ((d[x] - d[y]) >> i & 1) {
x = p[i][x];
}
}
if (x == y) return x;
for (int i = lgN - 1; i >= 0; --i) {
if (p[i][x] != p[i][y]) {
x = p[i][x];
y = p[i][y];
}
}
return p[0][x];
}
int ancestor(int v, int l) {
int res = v;
for (int i = 0; i < lgN; ++i) {
if (l >> i & 1) {
res = p[i][res];
}
}
return res;
}
int solve(int a, int b) {
int LCA = lca(a, b);
int da = d[a] - d[LCA];
int db = d[b] - d[LCA];
if (db > da) {
swap(a, b);
swap(da, db);
}
if (a == b)
return N;
else if ((da + db) & 1)
return 0;
else if (da == db) {
int pa = ancestor(a, da - 1);
int pb = ancestor(b, db - 1);
return size[root] - size[pa] - size[pb];
} else {
int len = (da + db) / 2;
int pa = ancestor(a, len);
int pap = ancestor(a, len - 1);
return size[pa] - size[pap];
}
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N - 1; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
root = 1;
dfs(root, root);
init();
scanf("%d", &M);
for (int i = 0; i < M; ++i) {
int a, b;
scanf("%d%d", &a, &b);
int ans = solve(a, b);
printf("%d\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, ans, a[100005];
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (int i = (2); i <= (n - 1); ++i)
if (a[i] != a[1] && a[i] != a[n]) ++ans;
printf("%d", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int sr[26];
long long int sl[26];
int main() {
long long int n;
cin >> n;
string a, b;
cin >> a >> b;
double ans = 0;
for (int i = 0; i < a.length(); i++) {
sl[b[i] - 'A'] = sl[b[i] - 'A'] + i + 1;
ans = ans + sl[a[i] - 'A'] * (n - (i + 1) + 1);
}
for (int i = a.length() - 1; i >= 0; i--) {
ans = ans + sr[a[i] - 'A'] * (i + 1);
sr[b[i] - 'A'] = sr[b[i] - 'A'] + n - (i + 1) + 1;
}
double cnt = 0;
for (int i = 0; i < n; i++) {
cnt += (n - i) * (n - i);
}
ans /= cnt;
printf("%.10f", ans);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T GCD(T a, T b) {
if (a < 0) return GCD(-a, b);
if (b < 0) return GCD(a, -b);
return (b == 0) ? a : GCD(b, a % b);
}
template <class T>
inline T LCM(T a, T b) {
if (a < 0) return LCM(-a, b);
if (b < 0) return LCM(a, -b);
return a * (b / GCD(a, b));
}
template <class T>
inline bool isPrime(T n) {
if (n < 2) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
template <class T>
vector<T> Divisor(T num) {
vector<T> res;
res.clear();
for (int i = 1; i <= num / 2; i++)
if (num % i == 0) res.push_back(i);
return res;
}
template <class T, class M>
inline T POWER(T x, M y) {
T temp = 1;
if (y == 0) return 1;
for (int i = 1; i <= y; i++) temp *= x;
return temp;
}
template <class T, class M>
bool Exist(T x, M element) {
for (int i = 0; i < x.size(); i++)
if (x[i] == element) return true;
return false;
}
template <class T>
vector<T> Unique(vector<T> v) {
T temp;
vector<T> res;
res.clear();
for (int i = 0; i < v.size(); i++) {
temp = v[i];
if (Exist(res, temp) == false) res.push_back(temp);
}
return res;
}
template <class T>
vector<T> Parse(T temp) {
vector<T> ans;
ans.clear();
T s;
istringstream is(temp);
while (is >> s) {
ans.push_back(s);
}
return ans;
}
template <class T>
string toString(T x) {
stringstream s;
s << x;
return s.str();
}
template <class T>
long long toInt(T x) {
istringstream is(x);
long long num;
is >> num;
return num;
}
template <class T>
inline void checkMin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkMax(T &a, T b) {
if (b > a) a = b;
}
bool isLowerCase(char c) { return (c >= 'a' && c <= 'z'); }
bool isUpperCase(char c) { return (c >= 'A' && c <= 'Z'); }
char toLowerCase(char c) { return (isUpperCase(c) ? (c + 32) : c); }
char toUpperCase(char c) { return (isLowerCase(c) ? (c - 32) : c); }
bool isLetter(char c) { return (isUpperCase(c)) || (isLowerCase(c)); }
bool isDigit(char c) { return (c >= '0' && c <= '9'); }
template <class T>
void print(T ans) {
for (unsigned int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
}
template <class T>
void print2(T ans) {
cout << ans;
cout << endl;
}
int doIt(string str) {
if (str == "S") return 0;
if (str == "M") return 1;
if (str == "L") return 2;
if (str == "XL") return 3;
if (str == "XXL") return 4;
}
int main() {
string size[] = {"S", "M", "L", "XL", "XXL"};
vector<string> ans;
vector<int> num(5);
int k;
for (int i = 0; i < 5; i++) cin >> num[i];
cin >> k;
vector<string> ask(k);
for (int i = 0; i < k; i++) cin >> ask[i];
for (int i = 0; i < ((int)(ask).size()); i++) {
int index = doIt(ask[i]);
int step = 1;
if (num[index] > 0) {
num[index]--;
ans.push_back(size[index]);
} else {
while (true) {
if (index + step < 5 && num[index + step] > 0) {
num[index + step]--;
ans.push_back(size[index + step]);
break;
} else if (index - step >= 0 && num[index - step] > 0) {
num[index - step]--;
ans.push_back(size[index - step]);
break;
}
step++;
}
}
}
for (int i = 0; i < ((int)(ans).size()); i++) cout << ans[i] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int len = 0, ans = 0;
char s[N];
struct node {
int id;
int num;
node() { id = num = 0; }
node(int i, int n) { id = i, num = n; }
} p[N];
void unit() {
int k = len;
len = 0;
for (int i = 1; i <= k; i++) {
if (p[i].num > 0) {
if (p[i].id == p[len].id)
p[len].num += p[i].num;
else
p[++len] = p[i];
}
}
}
void solve() {
while (len > 1) {
for (int i = 2; i < len; i++) p[i].num -= 2;
p[1].num--, p[len].num--;
unit();
ans++;
}
cout << ans << endl;
}
int main() {
scanf("%s", s + 1);
len = strlen(s + 1);
p[0].id = -1;
for (int i = 1; i <= len; i++) p[i].id = s[i] - 'a', p[i].num = 1;
unit();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};
char dc[4] = {'N', 'S', 'W', 'E'};
int main() {
int t;
string s;
cin >> t;
while (t--) {
cin >> s;
stack<char> st;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'A')
st.push(s[i]);
else {
if (st.empty())
st.push(s[i]);
else
st.pop();
}
}
cout << (st.size()) << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
if (n == 2 || n == 3) {
cout << -1 << endl;
continue;
}
if (n % 2 == 0) {
for (long long i = 2; i <= n; i += 2) {
cout << i << " ";
}
cout << n - 3 << " " << n - 1 << " ";
for (long long i = n - 5; i > 0; i -= 2) {
cout << i << " ";
}
cout << endl;
} else {
for (long long i = 1; i <= n; i += 2) {
cout << i << " ";
}
cout << n - 3 << " " << n - 1 << " ";
for (long long i = n - 5; i > 0; i -= 2) {
cout << i << " ";
}
cout << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bitset<26> ans, tmp;
int n, cnt = 0;
char ch;
string s;
int main() {
ans.set();
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> ch >> s;
if (ans.count() == 1 && i < n && ch != '.')
cnt++;
else {
tmp.reset();
for (int i = 0; i <= s.length(); i++) tmp[s[i] - 'a'] = 1;
if (ch == '!')
ans &= tmp;
else
ans &= ~tmp;
}
}
cout << cnt << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char _;
const int MOD = 1000000007;
const int INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long fpow(long long b, long long exp, long long mod) {
if (exp == 0) return 1;
long long t = fpow(b, exp / 2, mod);
if (exp & 1) return t * t % mod * b % mod;
return t * t % mod;
}
long long divmod(long long i, long long j, long long mod) {
i %= mod, j %= mod;
return i * fpow(j, mod - 2, mod) % mod;
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
int N, dep[7005], in[7005], out[7005];
long long int v[7005], B[7005], res;
bool vis[7005], done[7005];
vector<int> n2[7005];
set<pair<int, int> > s;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 1; i <= N; i++) {
cin >> v[i];
}
for (int i = 1; i <= N; i++) {
cin >> B[i];
res += B[i];
}
for (int i = 1; i <= N; i++) {
for (int k = 1; k <= N; k++) {
if (i == k) continue;
if ((v[i] & v[k]) == v[i]) {
n2[k].push_back(i);
out[i]++;
in[k]++;
}
}
}
for (int i = 1; i <= N; i++) s.insert({out[i], i});
while (s.size()) {
pair<int, int> t = *s.begin();
s.erase(s.begin());
if (t.first) break;
res -= B[t.second];
done[t.second] = true;
for (int c : n2[t.second]) {
if (done[c]) continue;
s.erase({out[c], c});
s.insert({--out[c], c});
}
}
cout << res << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
double f[55][55], g[55], w[55];
pair<int, int> p[55];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i].first);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i].second);
}
double st = clock();
sort(p + 1, p + n + 1);
auto chk = [&](double x) {
for (int i = 0; i <= n; i++) {
w[i] = p[i].first - x * p[i].second;
for (int j = 0; j <= n; j++) f[i][j] = 1e18;
}
f[0][0] = 0;
for (int i = 1, _i; i <= n; i = _i) {
for (_i = i; _i <= n && p[i].first == p[_i].first; _i++)
;
fill(g, g + _i - i + 1, 1e18), g[0] = 0;
for (int j = i; j < _i; j++) {
for (int k = _i - i; k; k--) g[k] = min(g[k], g[k - 1] + w[j]);
}
for (int j = 0; j < i; j++) {
for (int k = 0; k <= j; k++) {
for (int l = 1; l <= _i - i; l++) {
int nk = max(0, k + i - j - 1 - l) + _i - i - l;
f[_i - 1][nk] = min(f[_i - 1][nk], f[j][k] + g[l]);
}
}
}
}
return f[n][0] <= 0;
};
double l = 0, r = 1e8;
while ((clock() - st) / CLOCKS_PER_SEC < 0.7) {
double mid = (l + r) / 2;
chk(mid) ? r = mid : l = mid;
}
printf("%.0f\n", ceil(r * 1000 - 1e-6));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int a[N];
int main() {
int n, x, res = 1000000007;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
a[x] = 1;
}
a[0] = a[1] = 1;
for (int i = 1; i <= (1e6); i++) {
if (a[i] == 0)
a[i] = a[i - 1];
else
a[i] = i;
}
int nxt = 1000000;
for (int i = 1000000; i >= 1; i--) {
res = min(res, max(1000000 - i, a[i - 1] - 1));
}
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, MOD = 1e9 + 7;
using ll = long long;
ll fast_pow(ll a, int n) {
if (n == 0) return 1;
if (n % 2 == 0) return fast_pow(a * a % MOD, n / 2);
return fast_pow(a * a % MOD, n / 2) * a % MOD;
}
ll dp[N][N];
int main() {
int k;
ll pa, pb;
scanf("%d%lld%lld", &k, &pa, &pb);
ll pab = fast_pow((pa + pb) % MOD, MOD - 2);
pa = (pa * pab) % MOD;
pb = (pb * pab) % MOD;
dp[0][0] = 1;
ll res = 0;
for (int i = 1; i <= k; ++i) {
for (int j = 0; j < k; ++j) {
ll pow_b = 1;
int l = j;
ll rem = 1;
for (; l < k; l += i) {
dp[i][l] = (dp[i][l] + dp[i - 1][j] * (pa * pow_b % MOD)) % MOD;
rem = (rem + MOD - (pa * pow_b % MOD)) % MOD;
pow_b = pow_b * pb % MOD;
}
res = (res + (l * dp[i - 1][j] % MOD) * rem) % MOD;
}
}
ll ep = fast_pow(pb, MOD - 2);
for (int j = 0; j < k; ++j) {
res = (res + dp[k][j] * (j + k + ep)) % MOD;
}
printf("%lld\n", res);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long a[3000000];
long long b[3000000];
long long c[3000000];
int main() {
long long t;
scanf("%lld", &t);
while (t--) {
long long n;
scanf("%lld", &n);
long long sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld %lld", &a[i], &b[i]);
}
for (int i = 1; i <= n; i++) {
if (i == 1)
c[i] = max(0ll, a[i] - b[n]);
else {
c[i] = max(0ll, a[i] - b[i - 1]);
}
sum += c[i];
}
long long minn = 0x3f3f3f3f3f3f3f3f;
for (int i = 1; i <= n; i++) {
minn = min(minn, sum - c[i] + a[i]);
}
cout << minn << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 3e5 + 10;
int a[N];
int main() {
int n;
scanf("%d", &n);
int z;
scanf("%d", &z);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
int l = 0, r = n / 2;
int ans = 0;
while (l <= r) {
int mid = (l + r) / 2;
int ptr = n - mid + 1;
int flag = 1;
for (int i = 1; i <= mid; i++) {
if (a[ptr++] - a[i] < z) {
flag = 0;
break;
}
}
if (flag)
ans = mid, l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int N = 300300;
using namespace std;
struct edge {
int ul, ur, dl, dr, a, al, ar;
long long xl, xr;
};
edge comb(edge a, edge b, int sa, int sb) {
edge g;
g.a = max(a.a, b.a);
g.al = a.al;
g.xl = a.xl;
g.ul = a.ul;
g.dl = a.dl;
g.ar = b.ar;
g.xr = b.xr;
g.ur = b.ur;
g.dr = b.dr;
if (a.xr == b.xl) {
return g;
} else if (a.xr > b.xl) {
g.a = max(g.a, a.ar + b.dl);
if (sb == b.dl) g.ar = a.ar + b.dl;
if (sa == a.a) g.al = a.a + b.dl;
if (sa == a.dl) g.dl += b.dl;
if (sb == b.ur) g.ur += a.ur;
g.a = max(g.a, max(g.al, g.ar));
return g;
} else {
g.a = max(g.a, a.dr + b.al);
if (sb == b.a) g.ar = a.dr + b.a;
if (sa == a.dr) g.al = a.dr + b.al;
if (sb == b.dr) g.dr += a.dr;
if (sa == a.ul) g.ul += b.ul;
g.a = max(g.a, max(g.al, g.ar));
return g;
}
}
edge t[4 * N];
int n;
int a[N];
long long lz[4 * N];
void push(int x) {
if (lz[x] == 0) return;
t[x * 2].xl += lz[x];
t[x * 2].xr += lz[x];
t[x * 2 + 1].xl += lz[x];
t[x * 2 + 1].xr += lz[x];
lz[x * 2] += lz[x];
lz[x * 2 + 1] += lz[x];
lz[x] = 0;
}
void build(int x, int l, int r) {
if (l == r) {
t[x].xl = t[x].xr = a[l];
t[x].a = t[x].al = t[x].ar = t[x].dl = t[x].dr = t[x].ul = t[x].ur = 1;
return;
}
int m = (l + r) / 2;
build(x * 2, l, m);
build(x * 2 + 1, m + 1, r);
t[x] = comb(t[x * 2], t[x * 2 + 1], m - l + 1, r - m);
}
void upd(int x, int l, int r, int tl, int tr, long long d) {
if (tl > tr) return;
if (l == tl && r == tr) {
lz[x] += d;
t[x].xl += d;
t[x].xr += d;
return;
}
push(x);
int m = (l + r) / 2;
upd(x * 2, l, m, tl, min(m, tr), d);
upd(x * 2 + 1, m + 1, r, max(m + 1, tl), tr, d);
t[x] = comb(t[x * 2], t[x * 2 + 1], m - l + 1, r - m);
}
int main() {
ios_base::sync_with_stdio(0);
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, 1, n);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int l, r, d;
scanf("%d%d%d", &l, &r, &d);
upd(1, 1, n, l, r, d);
printf("%d\n", t[1].a);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INFint = 2147483647;
const long long INF = 9223372036854775807ll;
const long long MOD = 1000000007ll;
int d[110][10100];
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int p = -1;
for (int j = 0; j < m; j++)
if (s[j] == '1') {
p = j;
break;
}
if (p == -1) {
cout << -1;
return 0;
}
int cr = 0;
for (int j = 0; j < m; j++) {
if (s[(p + j) % m] == '1')
cr = 0;
else
cr++;
d[i][(j + p) % m] = cr;
}
cr = 0;
for (int j = m - 1; j > -1; j--) {
if (s[(p + j) % m] == '1')
cr = 0;
else
cr++;
d[i][(j + p) % m] = min(cr, d[i][(j + p) % m]);
}
}
long long ans = INF;
for (int i = 0; i < m; i++) {
long long cnt = 0;
for (int j = 0; j < n; j++) {
cnt += d[j][i];
}
ans = min(ans, cnt);
}
cout << ans << endl;
fprintf(stderr, "\nTIME = %lf\n", 1.0 * clock() / CLOCKS_PER_SEC);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.14159265359;
const long long MOD = (long long)998244353;
const long long MAXN = (long long)2e5 + 10;
const long long INF = (long long)2242545357980376863;
const long double EPS = (long double)1e-8;
const long long LOG = (long long)30;
long long mul(long long a, long long b) { return (a * b) % MOD; }
long long dp[MAXN], f[MAXN], sub[MAXN], son[MAXN];
vector<long long> G[MAXN];
void DFS(long long u, long long p) {
sub[u] = 1;
dp[u] = 1;
long long sn = 0;
for (auto adj : G[u]) {
if (adj == p) continue;
sn++;
DFS(adj, u);
sub[u] += sub[adj];
dp[u] = mul(dp[u], dp[adj]);
}
if (u != 1)
dp[u] = mul(dp[u], f[sn + 1]);
else
dp[u] = mul(dp[u], f[sn]);
son[u] = sn;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
f[0] = 1;
for (int i = 1; i < MAXN; i++) f[i] = mul(f[i - 1], i);
long long n;
cin >> n;
long long u, v;
for (int i = 1; i < n; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
DFS(1, -1);
cout << mul(n, dp[1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Z = (int)2e3 + 111;
const int inf = (int)1e9 + 111;
const long long llinf = (long long)1e18 + 5;
const int MOD = (int)1e9 + 7;
long long a[Z], b[Z];
int main() {
srand(time(0));
ios_base::sync_with_stdio(false);
int n;
long long sum1 = 0, sum2 = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
sum1 += a[i];
}
int m;
cin >> m;
for (int i = 1; i <= m; ++i) {
cin >> b[i];
sum2 += b[i];
}
long long val = abs(sum1 - sum2);
vector<int> ans;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (abs(sum1 - 2 * a[i] + 2 * b[j] - sum2) < val) {
val = abs(sum1 - 2 * a[i] + 2 * b[j] - sum2);
ans.clear();
ans.push_back(i);
ans.push_back(j);
}
}
}
set<pair<long double, pair<int, int> > > mn;
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
mn.insert(make_pair(a[i] + a[j], make_pair(i, j)));
}
}
for (int i = 1; i <= m; ++i) {
for (int j = i + 1; j <= m; ++j) {
long long y = b[i] + b[j];
long double cur = (long double)(sum1 + 2 * y - sum2) / 2;
auto it = mn.lower_bound(make_pair(cur, make_pair(-1, -1)));
if (it != mn.end()) {
if ((it->first - cur) * 2 < val) {
val = (it->first - cur) * 2;
ans.clear();
ans.push_back((it->second).first);
ans.push_back(i);
ans.push_back((it->second).second);
ans.push_back(j);
}
}
if (it != mn.begin()) {
it--;
if ((cur - it->first) * 2 < val) {
val = (cur - it->first) * 2;
ans.clear();
ans.push_back((it->second).first);
ans.push_back(i);
ans.push_back((it->second).second);
ans.push_back(j);
}
}
}
}
cout << val << '\n';
cout << (int)ans.size() / 2 << '\n';
for (int i = 0; i < (int)ans.size(); i += 2) {
cout << ans[i] << ' ' << ans[i + 1] << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
template <typename T>
static T randint(T lo, T hi) {
return uniform_int_distribution<T>(lo, hi)(rng);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
vector<pair<int, int>> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first;
v[i].second = i;
}
sort(v.begin(), v.end(),
[](pair<int, int> x, pair<int, int> y) { return x.first > y.first; });
vector<vector<bool>> ans(v[0].first + 1, vector<bool>(n));
auto print = [](vector<vector<bool>> arr) {
for (auto &i : arr) {
for (int j = 0; j < i.size(); j++) cout << (i[j] ? 1 : 0);
cout << '\n';
}
cout << '\n';
};
int pos = 0;
int depth = v[0].first;
while (pos < n) {
for (int i = 0; i < v[pos].first; i++) ans[depth - i - 1][pos] = true;
for (int i = pos + 1; i < n && v[i].first == depth && depth > 0; i++) {
--v[i].first;
ans[depth][i] = true;
}
++pos;
--depth;
}
vector<vector<bool>> sol;
for (int i = 0; i < v[0].first + 1; i++) {
vector<bool> temp(n);
for (int j = 0; j < n; j++) temp[v[j].second] = ans[i][j];
bool have = false;
for (int j = 0; j < n; j++) have |= temp[j];
if (have) sol.push_back(temp);
}
cout << sol.size() << '\n';
for (auto &i : sol) {
for (int j = 0; j < n; j++) cout << (i[j] ? 1 : 0);
cout << '\n';
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
const int mod = 1e9 + 7;
vector<int> g[N];
int n;
long long d[N], f[N];
bool ye[N];
void dfs1(int u, int fa) {
int sz = g[u].size();
d[u] = 1;
for (int i = 0; i <= sz - 1; ++i)
if (g[u][i] != fa) {
int v = g[u][i];
dfs1(v, u);
d[u] = d[u] * d[v] % mod;
}
if (sz != 1 || u == 1)
d[u] = d[u] * 2 % mod;
else
ye[u] = 1;
}
void dfs2(int u, int fa) {
int sz = g[u].size();
long long sum = 1;
for (int i = 0; i <= sz - 1; ++i)
if (g[u][i] != fa) {
int v = g[u][i];
f[v] = f[u] * sum % mod;
sum = sum * d[v] % mod;
}
sum = 1;
for (int i = sz - 1; i >= 0; --i)
if (g[u][i] != fa) {
int v = g[u][i];
f[v] = f[v] * sum % mod;
if (sz != 1) f[v] = f[v] * 2 % mod;
sum = sum * d[v] % mod;
dfs2(v, u);
}
}
int main() {
scanf("%d", &n);
if (n == 1) {
puts("1");
return 0;
}
for (int i = 1; i <= n - 1; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs1(1, -1);
f[1] = 1;
dfs2(1, -1);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
long long cur = d[i] * f[i] % mod;
if (ye[i]) cur = cur * 2 % mod;
ans = (ans + cur) % mod;
}
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios_base ::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a;
int z = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x != 0) a.push_back(x);
}
vector<int> b;
int z1 = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x != 0) b.push_back(x);
}
int j = 0;
while (a[0] != b[j]) j++;
bool ans = true;
for (int i = 0; i < n - 1; i++)
if (a[i] != b[(j + i) % (n - 1)]) {
ans = false;
}
if (ans)
cout << "YES";
else
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100224;
vector<int> ans;
int n, d, f, s;
pair<int, int> a[MaxN];
int main() {
cin.sync_with_stdio(0);
cin >> n >> d;
cin >> f >> s;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a[i].first = f * x + s * y;
a[i].second = i + 1;
}
sort(a, a + n);
for (int i = 0; i < n && d > 0; i++) {
d -= a[i].first;
if (d >= 0) ans.push_back(a[i].second);
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
char s[100];
int main() {
cin >> s;
stringstream ss(s);
long long val;
if (ss >> val) {
if (-128 <= val && val <= 127)
puts("byte");
else if (-(32768) <= val && val <= 32767)
puts("short");
else if (-(2147483648LL) <= val && val <= 2147483647LL)
puts("int");
else
puts("long");
} else {
puts("BigInteger");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int xorr(int a, int b) { return ((a | b) & (~a | ~b)); }
int main() {
int n, m;
scanf("%d %d", &n, &m);
char a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
int r = 0;
int c = 0;
int p = 0;
int j = 0;
int ansl;
int ansr;
for (int i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (a[i][j] == 'B') {
p = 1;
c = i;
while (a[i][j] == 'B') {
r++;
i++;
}
break;
}
}
if (p == 1) {
ansl = (c + i - 1) / 2;
ansr = (j + r / 2);
cout << ansl + 1 << " " << ansr + 1;
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, s, p, k, m, t, x, y, ans, res;
cin >> t;
while (t--) {
cin >> n;
long long a[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
ans = 0;
m = INT_MAX;
for (int i = n; i >= 1; i--) {
if (a[i] > m) ans++;
m = min(a[i], m);
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class F, class T>
T convert(F a, int p = -1) {
stringstream ss;
if (p >= 0) ss << fixed << setprecision(p);
ss << a;
T r;
ss >> r;
return r;
}
template <class T>
void db(T a, int p = -1) {
if (p >= 0) cout << fixed << setprecision(p);
cout << a << " ";
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T cube(T x) {
return x * x * x;
}
template <class T>
struct Triple {
T x, y, z;
Triple() {}
Triple(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {}
};
template <class T>
Triple<T> euclid(T a, T b) {
if (b == 0) return Triple<T>(1, 0, a);
Triple<T> r = euclid(b, a % b);
return Triple<T>(r.y, r.x - a / b * r.y, r.z);
}
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return s == 0 ? 0 : cntbit(s >> 1) + (s & 1);
}
const int bfsz = 1 << 16;
char bf[bfsz + 5];
int rsz = 0;
int ptr = 0;
char gc() {
if (rsz <= 0) {
ptr = 0;
rsz = fread(bf, 1, bfsz, stdin);
if (rsz <= 0) return EOF;
}
--rsz;
return bf[ptr++];
}
void ga(char &c) {
c = EOF;
while (!isalpha(c)) c = gc();
}
int gs(char s[]) {
int l = 0;
char c = gc();
while (isspace(c)) c = gc();
while (c != EOF && !isspace(c)) {
s[l++] = c;
c = gc();
}
s[l] = '\0';
return l;
}
template <class T>
bool gi(T &v) {
v = 0;
char c = gc();
while (c != EOF && c != '-' && !isdigit(c)) c = gc();
if (c == EOF) return false;
bool neg = c == '-';
if (neg) c = gc();
while (isdigit(c)) {
v = v * 10 + c - '0';
c = gc();
}
if (neg) v = -v;
return true;
}
const double PI = 2 * acos(0);
const string months[] = {"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"};
const int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int dr[] = {-1, 0, +1, 0};
const int dc[] = {0, +1, 0, -1};
const int inf = (int)1e9 + 5;
const long long linf = (long long)1e16 + 5;
const double eps = 1e-9;
const long long mod = 1000000007LL;
int n, a[105];
long long C[105][105], dp[105][10];
long long c(int n, int k) {
if (k < 0 || k > n) return 0;
return C[n][k];
}
long long go(int n, int dmin) {
if (dmin == 10) return n == 0 ? 1LL : 0;
long long &ret = dp[n][dmin];
if (ret != -1) return ret;
ret = 0;
for (typeof(n) x = (a[dmin]); x <= (n); ++x) {
long long delta = (dmin > 0) ? c(n, x) : c(n - 1, x);
ret = (ret + go(n - x, dmin + 1) * delta % mod) % mod;
}
return ret;
}
long long doit() {
memset(dp, -1, sizeof(dp));
long long ret = 0;
for (typeof(n) i = (1); i <= (n); ++i) {
long long temp = go(i, 0);
ret = (ret + temp) % mod;
}
return ret;
}
int main() {
memset(C, 0, sizeof(C));
C[0][0] = 1;
for (typeof(100) n = (1); n <= (100); ++n) {
C[n][0] = 1;
for (typeof(n) k = (1); k <= (n); ++k)
C[n][k] = (C[n - 1][k - 1] + C[n - 1][k]) % mod;
}
gi(n);
for (typeof(10) i = 0; i < (10); ++i) gi(a[i]);
cout << doit() << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T CHMAX(T& x, const T y) {
return x = (x < y) ? y : x;
}
template <class T>
inline T CHMIN(T& x, const T y) {
return x = (x > y) ? y : x;
}
using PII = pair<int, int>;
using PLL = pair<long long, long long>;
using LL = long long;
using ULL = unsigned long long;
template <class T>
using V = vector<T>;
template <class T>
using V2 = vector<vector<T>>;
template <class T, int W = 255>
using A = array<T, W>;
template <class T, int W = 255, int H = 255>
using A2 = array<array<T, W>, W>;
const int INF = 1 << 20;
int n, q;
std::string religion_word;
V<V<int>> next_oc;
V<std::string> words;
int dp[252][252][252];
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
;
cin >> n;
cin >> q;
cin >> religion_word;
next_oc.resize(n + 2);
words.resize(3);
for (int i = 0; i < static_cast<int>(26); i++) {
next_oc[n].push_back(n);
next_oc[n + 1].push_back(n);
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) {
char c = religion_word[i];
if (j == c - 'a')
next_oc[i].push_back(i);
else
next_oc[i].push_back(next_oc[i + 1][j]);
}
}
dp[0][0][0] = -1;
for (int l = 0; l < static_cast<int>(q); l++) {
char action;
cin >> action;
int group;
cin >> group;
group--;
if (action == '+') {
char c;
cin >> c;
words[group] += c;
int start0 = (group == 0) ? words[0].size() : 0;
int start1 = (group == 1) ? words[1].size() : 0;
int start2 = (group == 2) ? words[2].size() : 0;
for (int i = start0; i <= words[0].size(); i++) {
for (int j = start1; j <= words[1].size(); j++) {
for (int k = start2; k <= words[2].size(); k++) {
int& x = dp[i][j][k];
x = n;
if (i >= 1)
x = std::min(next_oc[dp[i - 1][j][k] + 1][words[0][i - 1] - 'a'],
x);
if (j >= 1)
x = std::min(next_oc[dp[i][j - 1][k] + 1][words[1][j - 1] - 'a'],
x);
if (k >= 1)
x = std::min(next_oc[dp[i][j][k - 1] + 1][words[2][k - 1] - 'a'],
x);
}
}
}
} else {
words[group].pop_back();
}
if (dp[words[0].size()][words[1].size()][words[2].size()] == n)
cout << "NO"
<< "\n";
else
cout << "YES"
<< "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 3;
long long int x[maxn], y[maxn];
long long int w[maxn];
int ct[maxn];
vector<int> v[maxn];
int ans[maxn];
int done_per[maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> w[i];
}
memset(ct, 0, sizeof(ct));
for (int i = 0; i < m; ++i) {
cin >> x[i] >> y[i];
ct[x[i] - 1]++;
ct[y[i] - 1]++;
x[i]--;
y[i]--;
v[x[i]].push_back(i);
v[y[i]].push_back(i);
}
memset(done_per, 0, sizeof(done_per));
vector<int> in;
int last = m - 1;
for (int i = 0; i < n; i++) {
if (ct[i] <= w[i]) {
in.push_back(i);
}
}
if (in.size() == 0) {
cout << "DEAD"
<< "\n";
exit(0);
}
while (1) {
vector<int> in1;
for (int j = 0; j < (int)in.size(); j++) {
int t1 = in[j];
for (int i = 0; i < (int)v[t1].size(); i++) {
if (!done_per[v[t1][i]]) {
ans[last--] = v[t1][i];
done_per[v[t1][i]] = 1;
int temp = v[t1][i];
if (x[temp] != t1) {
ct[x[temp]]--;
if (ct[x[temp]] <= w[x[temp]]) in1.push_back(x[temp]);
} else {
ct[y[temp]]--;
if (ct[y[temp]] <= w[y[temp]]) in1.push_back(y[temp]);
}
}
}
}
if (last == -1) break;
if (in1.size() == 0) {
cout << "DEAD"
<< "\n";
exit(0);
}
in.clear();
for (int t4 : in1) in.push_back(t4);
}
cout << "ALIVE"
<< "\n";
for (int i = 0; i < m; i++) {
cout << ans[i] + 1 << " ";
}
cout << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
string x, y;
stringstream ss;
for (int i = a + 1; i <= 200000; i++) {
ss.str("");
ss << i;
x = ss.str();
y = "";
for (int j = 0; j < x.size(); j++) {
if (x[j] == '4' || x[j] == '7') {
y += x[j];
}
}
if (atoi(y.c_str()) == b) {
cout << x;
return 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int read() {
char s;
int k = 0, base = 1;
while ((s = getchar()) != '-' && s != EOF && !(s >= '0' && s <= '9'))
;
if (s == EOF) exit(0);
if (s == '-') base = -1, s = getchar();
while (s >= '0' && s <= '9') {
k = k * 10 + (s - '0');
s = getchar();
}
return k * base;
}
void write(int x) {
if (x < 0) {
putchar('-');
write(-x);
} else {
if (x / 10) write(x / 10);
putchar(x % 10 + '0');
}
}
int n, m;
int ax, ay, ix, iy;
int x, y, d;
int s;
char ch;
int main() {
n = read();
m = read();
ix = 101;
iy = 101;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
ch = getchar();
while (ch != 'W' && ch != 'B') ch = getchar();
if (ch == 'W') continue;
ax = max(ax, i);
ay = max(ay, j);
ix = min(ix, i);
iy = min(iy, j);
s++;
}
if (s == 0) {
printf("1");
return 0;
}
x = ax - ix + 1;
y = ay - iy + 1;
d = max(x, y);
if (d > n || d > m) {
write(-1);
return 0;
}
d = d * d - s;
printf("%d", d);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
inline long long sbt(long long x) { return __builtin_popcountll(x); }
inline long long iceil(double a) { return (long long)(ceil(a)); }
inline long long mul(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
return ((a % m) * (b % m)) % m;
}
inline long long add(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
return (a + b) % m;
}
inline long long sub(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
return (a - b + m) % m;
}
long long fastpow(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
long long res = 1;
while (b > 0) {
if (b & 1) res = mul(res, a, m);
a = mul(a, a, m);
b >>= 1;
}
return res;
}
long long modinv(long long a, long long m = (long long)(1e9 + 7)) {
return fastpow(a, m - 2, m);
}
vector<pair<long long, long long> > adj[510][510];
long long n, m;
map<long long, long long> mp;
long long vis[510][510] = {0};
string a, b;
void dfs(long long i, long long j) {
vis[i][j] = 1;
for (auto k : adj[i][j]) {
if (!vis[k.first][k.second]) {
dfs(k.first, k.second);
}
}
}
void get_ac() {
cin >> n >> m;
cin >> a >> b;
long long c = 1;
for (auto i : a) {
if (i == '<') {
for (auto j = 2; j <= m; j++) {
adj[c][j].push_back({c, j - 1});
}
} else {
for (auto j = 1; j <= m - 1; j++) {
adj[c][j].push_back({c, j + 1});
}
}
c++;
}
c = 1;
for (auto i : b) {
if (i == 'v') {
for (auto j = 1; j <= n - 1; j++) {
adj[j][c].push_back({j + 1, c});
}
} else {
for (auto j = 2; j <= n; j++) {
adj[j][c].push_back({j - 1, c});
}
}
c++;
}
for (auto y = 1; y <= n; y++) {
for (auto z = 1; z <= m; z++) {
vis[y][z] = 0;
}
}
dfs(1, 1);
for (auto y = 1; y <= n; y++) {
for (auto z = 1; z <= m; z++) {
if (!vis[y][z]) {
cout << "NO";
return;
}
}
}
for (auto& i : a) {
if (i == '<')
i = '>';
else
i = '<';
}
for (auto& i : b) {
if (i == '^')
i = 'v';
else
i = '^';
}
for (auto i = 1; i <= n; i++) {
for (auto j = 1; j <= m; j++) {
adj[i][j].clear();
}
}
c = 1;
for (auto i : a) {
if (i == '<') {
for (auto j = 2; j <= m; j++) {
adj[c][j].push_back({c, j - 1});
}
} else {
for (auto j = 1; j <= m - 1; j++) {
adj[c][j].push_back({c, j + 1});
}
}
c++;
}
c = 1;
for (auto i : b) {
if (i == 'v') {
for (auto j = 1; j <= n - 1; j++) {
adj[j][c].push_back({j + 1, c});
}
} else {
for (auto j = 2; j <= n; j++) {
adj[j][c].push_back({j - 1, c});
}
}
c++;
}
for (auto y = 1; y <= n; y++) {
for (auto z = 1; z <= m; z++) {
vis[y][z] = 0;
}
}
dfs(1, 1);
for (auto y = 1; y <= n; y++) {
for (auto z = 1; z <= m; z++) {
if (!vis[y][z]) {
cout << "NO";
return;
}
}
}
cout << "YES";
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin.tie(NULL);
{
get_ac();
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, r[100], l[100], n, x, cnt = 1, ans;
int main() {
cin >> n >> x;
for (i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
ans += (l[i] - cnt) % x;
ans += (r[i] - l[i] + 1);
cnt = r[i] + 1;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct node {
char decimal;
int flag;
bool operator<(const node &b) const {
if (decimal > b.decimal)
return 1;
else if (decimal == b.decimal) {
if (flag < b.flag)
return 1;
else
return 0;
} else
return 0;
}
};
int main() {
char figure[20];
node a[20];
int k, len;
while (cin >> figure >> k) {
len = strlen(figure);
for (int i = 0; i < len; i++) {
int t = i;
for (int j = i + 1; j <= i + k && j < len; j++) {
if (figure[j] > figure[t]) t = j;
}
char temp = figure[t];
for (int j = t; j > i; j--) {
figure[j] = figure[j - 1];
k--;
}
figure[i] = temp;
if (k == 0) break;
}
cout << figure << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int inf = 0x3f3f3f3f;
long long infl = 0x3f3f3f3f3f3f3f3fLL;
long double infd = 1.0 / 0.0;
const long long MOD = 1e9 + 7;
const long double pi = 2 * acos(0.0);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
int n, k;
cin >> n >> k;
int cnt = 0;
int time = 0;
for (int i = 0; i < k; i++) {
int m;
cin >> m;
int f = 0;
for (int j = 0; j < m; j++) {
int x;
cin >> x;
if (x == j + 1 && f == 0)
cnt++;
else
f = 1;
if (f && j > 0) time++;
}
}
cout << n - cnt + time;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
ll pwr(ll a, ll b);
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int& x : a) cin >> x;
int i = 0, j = n - 1, ac = 0, bc = 0, moves = 0, lb = 0, la = 0;
while (true) {
int t1 = lb + 1;
lb = 0;
while (t1 > 0 and i <= j) {
t1 -= a[i];
ac += a[i];
la += a[i];
i++;
}
moves++;
if (i > j) break;
int t2 = la + 1;
la = 0;
while (t2 > 0 and j >= i) {
t2 -= a[j];
bc += a[j];
lb += a[j];
j--;
}
moves++;
if (j < i) break;
}
cout << moves << " " << ac << " " << bc << "\n";
}
}
ll pwr(ll a, ll b) {
a %= mod;
ll res = 1;
while (b > 0) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
void init() {
scanf("%d%d", &n, &k);
printf("%d\n", (6 * n - 1) * k);
for (int i = 0; i < n; ++i) {
printf("%d %d %d %d\n", (i * 6 + 1) * k, (i * 6 + 2) * k, (i * 6 + 3) * k,
(i * 6 + 5) * k);
}
}
int main() {
init();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 9e18L;
const long long int mod = 1e9 + 7;
long long int power(long long int x, long long int y) {
long long int res = 1;
int mod = 1e9 + 7;
while (y > 0) {
if (y & 1) (res = res * x) %= mod;
(x = x * x) %= mod;
y = y >> 1;
}
return res % mod;
}
vector<int> adj[150001], vis(150001, 0), v;
int c;
void dfs(int u) {
vis[u] = 1;
c++;
v.push_back(u);
for (auto x : adj[u]) {
if (vis[x] == 0) {
dfs(x);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
int flag = 1;
for (int i = 1; i < n + 1 && flag; i++) {
if (vis[i] == 0) {
c = 0;
dfs(i);
for (auto x : v) {
if (adj[x].size() != c - 1) {
flag = 0;
break;
}
}
v.clear();
}
}
if (flag)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.