solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2")
using namespace std;
vector<int> n[2][2] = {};
vector<int> merge(vector<int> &a, vector<int> &b) {
vector<int> r;
r.insert(r.end(), (a).begin(), (a).end());
r.insert(r.end(), (b).begin(), (b).end());
return r;
}
int output(vector<int> v) {
cout << v.size() << endl;
for (int first : v) cout << (first + 1) << " ";
cout << endl;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int N;
cin >> N;
vector<pair<int, int> > v(N);
for (auto &pr : v) {
cin >> pr.first >> pr.second;
pr.first += 1000000;
pr.second += 1000000;
}
while (true) {
for (auto i = (0); i != (2); ++i)
for (auto j = (0); j != (2); ++j) {
n[i][j].clear();
}
for (auto i = (0); i != (N); ++i) {
n[v[i].first % 2][v[i].second % 2].push_back(i);
}
bool cont = false;
for (auto i = (0); i != (2); ++i)
for (auto j = (0); j != (2); ++j) {
if (n[i][j].size() == N) {
for (auto _ = (0); _ != (N); ++_) {
v[_].first /= 2;
v[_].second /= 2;
}
cont = true;
}
}
if (cont) continue;
vector<int> A = merge(n[0][0], n[1][1]);
if (A.size() != 0 && A.size() != N) {
return output(A);
}
if (A.empty())
return output(n[0][1]);
else
return output(n[0][0]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long k, x;
for (int i = 0; i < n; i++) {
cin >> k >> x;
cout << k * 9 + x - 9 << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
vector<int> adj[maxn], cost[maxn];
long long dist[maxn], pcost[maxn];
int par[maxn];
vector<int> base[maxn];
vector<long long> sum[maxn];
bool cmp(int &u, int &v) { return dist[u] < dist[v]; }
void dfs(int u, int p) {
par[u] = p;
if (par) dist[u] = dist[p] + pcost[u];
base[u].push_back(dist[u]);
vector<int> tmp1, tmp2;
if (adj[u].size() >= 1) {
dfs(adj[u][0], u);
merge(base[u].begin(), base[u].end(), base[adj[u][0]].begin(),
base[adj[u][0]].end(), back_inserter(tmp1));
}
if (adj[u].size() >= 2) {
dfs(adj[u][1], u);
merge(tmp1.begin(), tmp1.end(), base[adj[u][1]].begin(),
base[adj[u][1]].end(), back_inserter(tmp2));
}
if (tmp2.size())
base[u] = tmp2;
else if (tmp1.size())
base[u] = tmp1;
sum[u].resize(base[u].size());
sum[u][0] = base[u][0];
for (int i = 1; i < base[u].size(); i++)
sum[u][i] = sum[u][i - 1] + base[u][i];
}
long long h;
long long get(int u, long long l, long long c) {
int lo = 0, hi = base[u].size() - 1, ans = -1;
while (lo <= hi) {
int mid = lo + hi >> 1;
if (base[u][mid] <= l + dist[u]) {
ans = mid, lo = mid + 1;
} else
hi = mid - 1;
}
if (ans == -1)
return 0;
else
return h * (ans + 1) - (sum[u][ans] - (ans + 1) * dist[u] + (ans + 1) * c);
}
long long solve(int u, long long l, int ch = 0) {
if (!u || l < 0) return 0;
long long ret = l;
for (int v : adj[u])
if (v - ch) {
if (l - pcost[v] >= 0) ret += get(v, l - pcost[v], h - l + pcost[v]);
}
return ret + solve(par[u], l - pcost[u], u);
}
int main(int argc, char const *argv[]) {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i < n; i++) {
int l, j = (i + 1) / 2;
scanf("%d", &l);
adj[j].push_back(i + 1);
pcost[i + 1] = l;
}
dfs(1, 0);
while (m--) {
int u;
scanf("%d %lld", &u, &h);
printf("%lld\n", solve(u, h));
}
}
| 7 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
using namespace std;
typedef long long ll;
const int N = 1005;
ll arr_x[N], arr_y[N];
int main(){
int t;
cin >> t;
while(t --){
int n;
cin >> n;
for(int i = 1;i <= n;i ++){
scanf("%lld%lld", &arr_x[i], &arr_y[i]);
}
ll x_r = 1, y_r = 1;
if((n & 1) == 0){
sort(arr_x + 1, arr_x + n + 1);
sort(arr_y + 1, arr_y + n + 1);
x_r = arr_x[n / 2 + 1] - arr_x[n / 2] + 1;
y_r = arr_y[n / 2 + 1] - arr_y[n / 2] + 1;
}
cout << x_r * y_r << endl;
}
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t K;
cin >> K;
int N = 2000;
int ans[2000] = {0};
ans[1998]--;
K += N;
while (K % (N - 1)) {
ans[1998]--;
K += N;
}
ans[1999] = K / (N - 1);
cout << N << endl;
for (int i = 0; i < N; i++) cout << ans[i] << " \n"[i == N - 1];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MN = 2e5 + 10, inf = 1e9;
long long n;
vector<long long> l, r;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) {
long long L, R;
cin >> L >> R;
r.push_back(R);
l.push_back(L);
}
sort(r.begin(), r.end());
sort(l.begin(), l.end());
reverse(r.begin(), r.end());
reverse(l.begin(), l.end());
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans += max(l[i], r[i]);
}
cout << ans + n << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, b;
bool operator<(const node &t) const { return a > t.a; }
};
struct logaritamska {
int n;
vector<int> v;
logaritamska(int N) {
n = N;
v.resize(N + 1, 0);
}
int interval(int hi) {
int ret = 0;
for (; hi > 0; hi -= (hi & -hi)) ret = max(v[hi], ret);
return ret;
}
void update(int x, int vr) {
for (; x <= n; x += (x & -x)) v[x] = max(vr, v[x]);
}
};
vector<node> v;
int main() {
int n, t;
scanf("%d", &n);
logaritamska log(n + 1);
v.resize(n);
for (int i = 1; i <= n; i++) {
scanf("%d", &t);
v[t - 1].a = i;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &t);
v[t - 1].b = i;
}
sort(v.begin(), v.end());
int ret = 1, tmp;
for (int i = 0; i < v.size(); i++) {
t = v[i].b;
tmp = log.interval(t);
tmp++;
ret = max(ret, tmp);
log.update(t, tmp);
}
printf("%d\n", ret);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize(2)
const long long mod = 10007;
const long long maxn = 5e5 + 5;
int a[maxn], b[maxn], pre[maxn], pp[maxn];
struct node {
int id;
int l, r;
int ans;
} mea[maxn];
bool cmp(node a, node b) { return a.r < b.r; }
bool cmpp(node a, node b) { return a.id < b.id; }
long long tree[maxn << 2];
void pushup(int rt) { tree[rt] = min(tree[rt << 1], tree[rt << 1 | 1]); }
void build(int l, int r, int rt) {
if (l == r) {
tree[rt] = 0x3f3f3f3f;
return;
}
int mid = (l + r) / 2;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
pushup(rt);
}
void update(int l, int r, int rt, int x, long long k) {
if (l == r) {
tree[rt] = min(tree[rt], k);
return;
}
int mid = (l + r) / 2;
if (x <= mid)
update(l, mid, rt << 1, x, k);
else
update(mid + 1, r, rt << 1 | 1, x, k);
pushup(rt);
}
long long query(int l, int r, int rt, int x, int y) {
if (x <= l && y >= r) {
return tree[rt];
}
int mid = (l + r) / 2;
long long ans = 0x3f3f3f3f;
if (x <= mid) ans = min(ans, query(l, mid, rt << 1, x, y));
if (y > mid) ans = min(ans, query(mid + 1, r, rt << 1 | 1, x, y));
return ans;
}
int main() {
std::ios_base::sync_with_stdio(false), cin.tie(), cout.tie();
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b + 1, b + n + 1);
int len = unique(b + 1, b + n + 1) - b - 1;
for (int i = 1; i <= n; i++)
a[i] = (lower_bound(b + 1, b + len + 1, a[i]) - b);
build(1, n, 1);
for (int i = 1; i <= n; i++) {
if (pp[a[i]] == 0) {
pp[a[i]] = i;
pre[i] = -1;
} else {
pre[i] = pp[a[i]];
pp[a[i]] = i;
}
}
for (int i = 1; i <= m; i++) {
cin >> mea[i].l >> mea[i].r;
mea[i].id = i;
}
int pos = 1;
sort(mea + 1, mea + m + 1, cmp);
for (int i = 1; i <= n; i++) {
if (pre[i] != -1) {
update(1, n, 1, pre[i], i - pre[i]);
}
while (mea[pos].r == i) {
mea[pos].ans = query(1, n, 1, mea[pos].l, i);
pos++;
}
}
sort(mea + 1, mea + m + 1, cmpp);
for (int i = 1; i <= m; i++) {
if (mea[i].ans == 0x3f3f3f3f)
cout << -1 << endl;
else
cout << mea[i].ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int X = 0, p = 1;
char c = getchar();
for (; c > '9' || c < '0'; c = getchar())
if (c == '-') p = -1;
for (; c >= '0' && c <= '9'; c = getchar()) X = X * 10 + c - '0';
return X * p;
}
const int N = 1e5 + 5;
int n, a[N], b[N];
int main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i <= n; ++i) b[i] = read();
if (a[1] != b[1] || a[n] != b[n]) return puts("No"), 0;
for (int i = 1; i <= n - 1; ++i) {
a[i] = a[i + 1] - a[i];
b[i] = b[i + 1] - b[i];
}
sort(a + 1, a + n);
sort(b + 1, b + n);
for (int i = 1; i < n; ++i)
if (a[i] != b[i]) return puts("No");
puts("Yes");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int fac[1000010], inv[1000010], sum[2][1000010], many[4][1000010], many1, ans,
n;
char str[1000010];
int C(int n, int m) {
return 1ll * fac[n] * inv[m] % 998244353 * inv[n - m] % 998244353;
}
int qpow(int x, int y) {
int tmp = 1;
while (y) {
if (y & 1) tmp = 1ll * x * tmp % 998244353;
y >>= 1, x = 1ll * x * x % 998244353;
}
return tmp;
}
int main() {
scanf("%s", str + 1), n = strlen(str + 1);
for (int i = 1; i <= n; i++) many1 += str[i] == '?';
if (many1 + 1 > 1000009) printf("Fuck\n");
for (int i = 1; i <= n; i++)
many[0][i] = many[0][i - 1] + (str[i] == '('),
many[1][i] = many[1][i - 1] + (str[i] == '?');
for (int i = n; i; i--)
many[2][i] = many[2][i + 1] + (str[i] == ')'),
many[3][i] = many[3][i + 1] + (str[i] == '?');
for (int i = fac[0] = 1; i <= n; i++)
fac[i] = 1ll * fac[i - 1] * i % 998244353;
for (int i = inv[0] = 1; i <= n; i++) inv[i] = qpow(fac[i], 998244353 - 2);
for (int i = 1; i <= many1 + 1; i++)
sum[1][i] = (sum[1][i - 1] + C(many1, i - 1)) % 998244353;
for (int i = 1; i <= many1; i++)
sum[0][i] = (sum[0][i - 1] + C(many1 - 1, i - 1)) % 998244353;
for (int i = 1; i <= n; i++)
if (str[i] == '(')
(ans +=
sum[1][max(0, min(many[2][i + 1] - many[0][i - 1] + many[3][i + 1],
many1 + 1))]) %= 998244353;
for (int i = 1; i <= n; i++)
if (str[i] == '?')
(ans += sum[0][max(
0, min(many[2][i + 1] - many[0][i - 1] + many[3][i + 1], many1))]) %=
998244353;
printf("%d\n", (ans + 998244353) % 998244353);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, i, c = 0;
cin >> n >> h;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
if (a[i] > h) {
c = c + 2;
} else {
c = c + 1;
}
}
cout << c;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
map<long long, long long> a, b;
map<pair<long long, long long>, long long> c;
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
ans += a[x]++ + b[y]++ - c[make_pair(x, y)]++;
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
const int M = 1e7 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const int INF = 2e9;
const int seed = 131;
vector<int> G[N];
int n, k, r, dis[N], vis[N], dep[N], fat[N][22], fa[N];
int get(int x) {
if (x == fa[x]) return x;
return fa[x] = get(fa[x]);
}
void merge(int u, int v) {
u = get(u), v = get(v);
if (u != v) fa[v] = u;
}
void dfs(int u, int pa) {
for (auto &v : G[u]) {
if (v == pa) continue;
dep[v] = dep[u] + 1;
fat[v][0] = u;
for (int j = 1; j <= 20; ++j) {
fat[v][j] = fat[fat[v][j - 1]][j - 1];
}
dfs(v, u);
}
}
int cal(int u, int d) {
int d1 = d, u1 = u;
for (int i = 0; i <= 20; ++i) {
if ((d >> i) & 1) {
u = fat[u][i];
}
}
return u;
}
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
u = cal(u, dep[u] - dep[v]);
if (u == v) return u;
for (int i = 20; i >= 0; --i) {
if (fat[u][i] != fat[v][i]) {
u = fat[u][i];
v = fat[v][i];
}
}
return fat[u][0];
}
int walk(int u, int v, int Lca, int d) {
if (d <= dep[u] - dep[Lca]) return cal(u, d);
d -= dep[u] - dep[Lca];
return cal(v, dep[v] - dep[Lca] - d);
}
bool solve(int u, int v) {
int Lca = lca(u, v);
if (dep[u] + dep[v] - 2 * dep[Lca] <= 2 * k) return 1;
int u1 = walk(u, v, Lca, k), v1 = walk(v, u, Lca, k);
return (get(u1) == get(v1));
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k >> r;
int u, v;
for (int i = 1; i < n; ++i) {
cin >> u >> v;
G[u].emplace_back(n + i);
G[n + i].emplace_back(u);
G[n + i].emplace_back(v);
G[v].emplace_back(n + i);
}
for (int i = 1; i <= n * 2; ++i) fa[i] = i;
queue<int> Q;
for (int i = 0; i < r; ++i) {
cin >> u;
vis[u] = 1;
Q.push(u);
}
while (!Q.empty()) {
u = Q.front();
Q.pop();
if (dis[u] >= k) break;
for (auto &v : G[u]) {
merge(u, v);
if (!vis[v]) {
Q.push(v);
dis[v] = dis[u] + 1;
vis[v] = 1;
}
}
}
dfs(1, 0);
int q;
cin >> q;
while (q--) {
cin >> u >> v;
cout << (solve(u, v) ? "YES" : "NO") << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
Point() {}
Point(int xx, int yy) : x(xx), y(yy) {}
friend bool operator<(const Point &a, const Point &b) {
return a.x < b.x || a.x == b.x && a.y == b.y;
}
friend bool operator==(const Point &a, const Point &b) {
return a.x == b.x && a.y == b.y;
}
};
Point operator-(Point a, Point b) { return Point(a.x - b.x, a.y - b.y); }
struct polygon_convex {
vector<Point> P;
polygon_convex(int Size = 0) { P.resize(Size); }
};
int Cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
polygon_convex convex_hull(vector<Point> a) {
polygon_convex res(2 * a.size() + 5);
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
int m = 0;
for (int i = 0; i < a.size(); ++i) {
while (m > 1 &&
Cross(res.P[m - 1] - res.P[m - 2], a[i] - res.P[m - 2]) <= 0)
--m;
res.P[m++] = a[i];
}
int k = m;
for (int i = int(a.size()) - 2; i >= 0; --i) {
while (m > k &&
Cross(res.P[m - 1] - res.P[m - 2], a[i] - res.P[m - 2]) <= 0)
--m;
res.P[m++] = a[i];
}
res.P.resize(m);
if (a.size() > 1) res.P.resize(m - 1);
return res;
}
int main() {
vector<Point> a;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
Point p;
scanf("%d%d", &p.x, &p.y);
a.push_back(p);
}
vector<Point> p = convex_hull(a).P;
int m = p.size();
int max = 0;
if (m == 3) {
int ans = Cross(p[1] - p[0], p[2] - p[0]);
int min = 0x7fffffff;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int area = Cross(p[(i + 1) % m] - p[i], a[j] - p[i]);
if (area > 0 && area < min) {
min = area;
}
}
}
printf("%.6lf\n", fabs(ans - min) / 2.0);
} else {
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
for (int k = j + 1; k < m; k++) {
for (int l = k + 1; l < m; l++) {
int area = Cross(p[j] - p[i], p[k] - p[i]) +
Cross(p[k] - p[i], p[l] - p[i]);
if (max < area) {
max = area;
}
}
}
}
}
printf("%.6lf\n", fabs(max / 2.0));
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5, MAXM = 4e5 + 5, BOUND = 2e5, MOD = 1e9 + 7,
INF = 0x3f3f3f3f;
const long long INFL = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1.0), eps = 1e-3;
char gdffsaw;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long m, n, P, a[1 << 21], b[1 << 21], c[1 << 21], t;
inline int getC(int x) {
int cnt = 0;
while (x) {
cnt++;
x -= -x & x;
}
return cnt;
}
void fwt_xor(long long *a, int tp) {
for (int i = 1; i < n; i <<= 1) {
for (int p = i << 1, j = 0; j < n; j += p) {
for (int k = 0; k < i; k++) {
long long x = a[j + k], y = a[j + k + i];
a[j + k] = (x + y) % P;
a[j + k + i] = (x - y + P) % P;
}
}
}
if (tp == -1)
for (int i = 0; i < n; i++) a[i] /= n;
}
long long mult(long long x, long long y, long long mod) {
long long tmp =
(x * y - (long long)((long double)x / mod * y + 1.0e-8) * mod);
return tmp < 0 ? tmp + mod : tmp;
}
long long qPow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = mult(res, a, P);
a = mult(a, a, P), b >>= 1;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> m >> t >> P;
n = 1 << m;
P *= n;
for (int i = (0); i <= (n - 1); ++i) cin >> a[i];
for (int i = (0); i <= (m); ++i) cin >> b[i];
int len = 1 << m;
for (int i = (0); i <= (n - 1); ++i) c[i] = b[getC(i)];
fwt_xor(a, 1);
fwt_xor(c, 1);
for (int i = (0); i <= (n - 1); ++i) a[i] = mult(a[i], qPow(c[i], t), P);
fwt_xor(a, -1);
for (int i = (0); i <= (n - 1); ++i) cout << a[i] << '\n';
return 0;
}
| 11 |
#include<iostream>
using namespace std;
int main()
{
int t;
cin>>t;
while(t--)
{
int n,k1,k2,w,b;
cin>>n>>k1>>k2>>w>>b;
if((k1+k2)>=2*w && ((n*2)-(k1+k2))>=b*2)
{
cout<<"YES"<<endl;
}
else
{
cout<<"NO"<<endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10 * 1000 + 20;
int n;
pair<int, int> a[N];
set<pair<int, int> > ans;
void solve(int st = 0, int en = n) {
if (en - st == 1) return;
int mid = st + en >> 1;
for (int i = st; i < en; i++)
ans.insert(pair<int, int>(a[mid].first, a[i].second));
solve(st, mid);
solve(mid, en);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
sort(a, a + n,
[](pair<int, int> i, pair<int, int> j) { return i.first < j.first; });
solve();
for (int i = 0; i < n; i++)
ans.insert(pair<int, int>(a[i].first, a[i].second));
cout << ans.size() << "\n";
for (auto i : ans) cout << i.first << " " << i.second << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
void in() {}
template <typename T, class... U>
void in(T &t, U &...u) {
cin >> t;
in(u...);
}
void out() { cout << "\n"; }
template <typename T, class... U>
void out(const T &t, const U &...u) {
cout << t;
if (sizeof...(u)) cout << " ";
out(u...);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ios::sync_with_stdio(false);
cin.tie(0);
ios::sync_with_stdio(false);
cin.tie(0);
ios::sync_with_stdio(false);
cin.tie(0);
ios::sync_with_stdio(false);
cin.tie(0);
ios::sync_with_stdio(false);
cin.tie(0);
ios::sync_with_stdio(false);
cin.tie(0);
ios::sync_with_stdio(false);
cin.tie(0);
ios::sync_with_stdio(false);
cin.tie(0);
ios::sync_with_stdio(false);
cin.tie(0);
ios::sync_with_stdio(false);
cin.tie(0);
ios::sync_with_stdio(false);
cin.tie(0);
ios::sync_with_stdio(false);
cin.tie(0);
ios::sync_with_stdio(false);
cin.tie(0);
int H;
in(H);
int W;
in(W);
int k;
in(k);
string path;
for (long long i = 0; i < H - 1; i++) {
path += 'U';
}
for (long long i = 0; i < W - 1; i++) {
path += 'L';
}
for (long long i = 1; i < H + 1; i++) {
if (i & 1) {
for (long long i = 0; i < W - 1; i++) path += "R";
} else {
for (long long i = 0; i < W - 1; i++) path += "L";
}
if (i != H) path += "D";
}
out(path.size());
out(path);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, maa = 0, mii = 1000000000;
cin >> n;
vector<int> v, a, b(n);
for (int i = 0; i < n; i++) {
int t;
cin >> t;
if (maa <= t) maa = t;
a.push_back(maa);
v.push_back(t);
}
for (int i = n - 1; i >= 0; i--) {
if (mii >= v[i]) mii = v[i];
b[i] = mii;
}
int ct = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i] <= b[i + 1]) ct++;
}
cout << ct + 1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int v1, v2, t, d, cnt = 0;
int T[100 + 8][10000 + 8];
set<pair<int, int> > Q;
int main() {
cin >> v1 >> v2 >> t >> d;
Q.insert(make_pair(0, v1));
T[0][v1] = v1;
while (!Q.empty()) {
set<pair<int, int> >::iterator it = Q.begin();
pair<int, int> tmp = *it;
Q.erase(it);
if (tmp.first == t - 1) continue;
for (int i = 0; i <= d; i++) {
T[tmp.first + 1][tmp.second + i] =
max(T[tmp.first + 1][tmp.second + i],
T[tmp.first][tmp.second] + tmp.second + i);
Q.insert(make_pair(tmp.first + 1, tmp.second + i));
if (tmp.second - i < 0) continue;
T[tmp.first + 1][tmp.second - i] =
max(T[tmp.first + 1][tmp.second - i],
T[tmp.first][tmp.second] + tmp.second - i);
Q.insert(make_pair(tmp.first + 1, tmp.second - i));
}
}
cout << T[t - 1][v2] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
const double PI = acos(-1.0);
const double e = exp(1.0);
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
inline T Min(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline T Max(T a, T b) {
return a > b ? a : b;
}
bool cmpbig(int a, int b) { return a > b; }
bool cmpsmall(int a, int b) { return a < b; }
using namespace std;
int dp[505][505];
int mod;
int a[505];
int main() {
int k, n, m, b;
while (~scanf("%d %d %d %d", &n, &m, &b, &mod)) {
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
memset(dp, 0, sizeof(dp));
int ans = 0;
dp[0][0] = 1;
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= m; i++) {
for (int j = a[k]; j <= b; j++) {
dp[i][j] += dp[i - 1][j - a[k]];
dp[i][j] %= mod;
}
}
}
for (int i = 0; i <= b; i++) {
ans += dp[m][i];
ans %= mod;
}
printf("%d\n", ans % mod);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int M = 110;
const int N = 101000 + M;
const int MOD = (int)1e9 + 7;
int a[N], F[N], Finv[N], Inv[N], n, m, Array[N][M], Fun[N][M];
void init() {
Inv[1] = 1;
F[0] = Finv[0] = 1;
for (int i = 2; i < N; i++) {
Inv[i] = (long long)Inv[MOD % i] * (MOD - MOD / i) % MOD;
}
for (int i = 1; i < N; i++) {
F[i] = (long long)F[i - 1] * i % MOD;
Finv[i] = (long long)Finv[i - 1] * Inv[i] % MOD;
}
Fun[0][0] = 1;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (i) (Fun[i][j] += Fun[i - 1][j]) %= MOD;
if (j) (Fun[i][j] += Fun[i][j - 1]) %= MOD;
}
}
}
int C(int a, int b) {
if (a < b) return 0;
return (long long)F[a] * Finv[b] % MOD * Finv[a - b] % MOD;
}
int main() {
init();
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
int l, r, K;
scanf("%d%d%d", &l, &r, &K);
l--;
(Array[l][K] += 1) %= MOD;
for (int j = K; j >= 0; j--) {
(Array[r][j] -= Fun[r - l - 1][K - j]) %= MOD;
}
}
for (int i = 0; i < n; i++) {
for (int j = 100; j >= 0; j--) {
if (i) (Array[i][j] += Array[i - 1][j]) %= MOD;
if (j != 100) (Array[i][j] += Array[i][j + 1]) %= MOD;
}
printf("%d\n", ((a[i] + Array[i][0]) % MOD + MOD) % MOD);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("avx")
#pragma GCC diagnostic ignored "-Wunused-result"
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%" PRId64, &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%" PRId64, x); }
void _W(const double &x) { printf("%.16f\n", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
template <class T>
inline bool chkmax(T &a, const T &b) {
return b > a ? a = b, true : false;
}
template <class T>
inline bool chkmin(T &a, const T &b) {
return b < a ? a = b, true : false;
}
template <class T, class F = less<T>>
void sort_uniq(vector<T> &v, F f = F()) {
sort(begin(v), end(v), f);
v.resize(unique(begin(v), end(v)) - begin(v));
}
template <class T>
using MaxHeap = priority_queue<T>;
template <class T>
using MinHeap = priority_queue<T, vector<T>, greater<T>>;
struct SplitMix64 {
uint64_t s;
SplitMix64(uint64_t _s = 0) : s(_s) {}
uint64_t operator()() {
uint64_t z = (s += 0x9E3779B97F4A7C15);
z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9;
z = (z ^ (z >> 27)) * 0x94D049BB133111EB;
return z ^ (z >> 31);
}
} rnd;
template <int MOD>
struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int _x) {
x = _x % MOD;
if (x < 0) x += MOD;
}
ModInt(long long _x) {
x = _x % MOD;
if (x < 0) x += MOD;
}
ModInt operator-() const { return {x == 0 ? 0 : MOD - x}; }
ModInt &operator+=(ModInt rhs) {
x += rhs.x;
if (x >= MOD) x -= MOD;
return *this;
}
ModInt &operator-=(ModInt rhs) {
x -= rhs.x;
if (x < 0) x += MOD;
return *this;
}
ModInt &operator*=(ModInt rhs) {
x = (long long)x * rhs.x % MOD;
return *this;
}
ModInt &operator/=(ModInt rhs) { return *this *= rhs.inv(); }
ModInt operator+(ModInt rhs) const { return ModInt(*this) += rhs; }
ModInt operator-(ModInt rhs) const { return ModInt(*this) -= rhs; }
ModInt operator*(ModInt rhs) const { return ModInt(*this) *= rhs; }
ModInt operator/(ModInt rhs) const { return ModInt(*this) /= rhs; }
ModInt inv() const {
int a = x, b = MOD, u = 1, v = 0;
while (b != 0) {
int t = a / b;
a -= t * b;
u -= t * v;
swap(a, b);
swap(u, v);
}
return u;
}
ModInt pow(long long e) {
ModInt r = 1, p = *this;
while (e) {
if (e & 1) r *= p;
p *= p;
e >>= 1;
}
return r;
}
bool operator==(ModInt rhs) { return x == rhs.x; }
bool operator!=(ModInt rhs) { return x != rhs.x; }
bool operator<(ModInt rhs) { return x < rhs.x; }
bool operator<=(ModInt rhs) { return x <= rhs.x; }
bool operator>(ModInt rhs) { return x > rhs.x; }
bool operator>=(ModInt rhs) { return x >= rhs.x; }
friend ostream &operator<<(ostream &os, ModInt i) { return os << i.x; }
};
const int MOD = 1e9 + 7;
using mint = ModInt<MOD>;
const int N = 2510;
const int L = 1e5 + 10;
int n, a[N];
mint tbl[L], tbl2[L];
int main() {
R(n);
for (int i = 0; i < int(n); i++) R(a[i]);
if (n == 1) {
W(0);
return 0;
}
mint m = 0;
for (int i = 0; i < int(n); i++) m += a[i];
int ub = min(m.x - 1, 100000);
for (int i = (1); i <= int(ub); i++) {
auto v = (m - i).inv();
tbl[i] = tbl[i - 1] + v;
tbl2[i] = tbl2[i - 1] + v * i;
}
mint ans = 0;
for (int i = 0; i < int(n); i++) {
mint s = 0;
s += tbl[a[i]] * a[i];
s -= tbl2[a[i]];
mint now = (m - 1) * (m - 1) - m * (m - 1) / a[i] * s;
ans += mint(a[i]) / m * now;
}
W(ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
int n, vals[maxn], in[maxn], out[maxn], cnt;
vector<pair<int, int>> g[maxn];
vector<pair<int, int>> leaf[maxn];
vector<pair<pair<int, int>, int>> ret;
void init(int u, int p) {
in[u] = ++cnt;
for (pair<int, int> v : g[u]) {
if (v.first == p) continue;
init(v.first, u);
}
out[u] = cnt;
}
int dfs(int u, int p) {
if (g[u].size() == 1) return u;
for (pair<int, int> v : g[u]) {
if (v.first == p) continue;
int b = dfs(v.first, u);
if (b) return b;
}
return 0;
}
void prop(int u, int n, int p, int val) {
for (pair<int, int> v : g[u]) {
if (v.first == p) continue;
if (in[v.first] <= in[n] && out[v.first] >= in[n]) {
vals[v.second] -= val;
prop(v.first, n, u, val);
}
}
}
void solve(int u, int p) {
if (g[u].size() == 1) return;
for (pair<int, int> v : g[u]) {
if (v.first == p) continue;
pair<int, int> a = make_pair(dfs(v.first, u), vals[v.second]);
pair<int, int> b = leaf[u][0].first == a.first ? leaf[u][1] : leaf[u][0];
pair<int, int> c = leaf[u][0].first == a.first ? leaf[u][2]
: leaf[u][1].first == a.first ? leaf[u][2]
: leaf[u][1];
ret.push_back(make_pair(make_pair(a.first, b.first), a.second / 2));
ret.push_back(make_pair(make_pair(b.first, c.first), -a.second / 2));
ret.push_back(make_pair(make_pair(a.first, c.first), a.second / 2));
prop(u, a.first, p, vals[v.second]);
solve(v.first, u);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b, c;
scanf(" %d %d %d", &a, &b, &c);
g[a].push_back(make_pair(b, i));
g[b].push_back(make_pair(a, i));
vals[i] = c;
}
if (n == 2) {
printf("YES\n1\n");
printf("1 2 %d\n", vals[1]);
return 0;
}
for (int i = 1; i <= n; i++)
if (g[i].size() == 2) return 0 * printf("NO\n");
int rt = 1;
for (int i = 1; i <= n; i++) {
if (g[i].size() == 1) continue;
for (int k = 0; k < min((int)g[i].size(), 3); k++)
leaf[i].push_back(make_pair(dfs(g[i][k].first, i), vals[g[i][k].second]));
rt = i;
}
init(rt, -1);
solve(rt, -1);
printf("YES\n%d\n", (int)ret.size());
for (pair<pair<int, int>, int> v : ret)
printf("%d %d %d\n", v.first.first, v.first.second, v.second);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
double pi = 3.14159265;
long long n;
vector<vector<long long> > g;
vector<int> c;
long long rt;
vector<long long> ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
g.resize(n + 1);
c.resize(n + 1);
for (long long i = 1; i <= n; i++) {
long long temp1;
int id;
cin >> temp1 >> id;
if (temp1 == -1) {
rt = i;
c[i] = id;
} else {
g[i].push_back(temp1);
g[temp1].push_back(i);
c[i] = id;
}
}
queue<long long> q;
q.push(rt);
vector<bool> vis(n + 1, false);
vis[rt] = true;
while (!q.empty()) {
long long cur = q.front();
q.pop();
int flag = 1;
for (auto x : g[cur]) {
if (!vis[x]) {
vis[x] = true;
q.push(x);
if (c[x] == 0) flag = 0;
}
}
if (c[cur] == 1 && flag == 1) ans.push_back(cur);
}
sort((ans).begin(), (ans).end());
if (ans.empty())
cout << -1;
else
for (auto x : ans) cout << x << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
long x, sum = 0, k;
scanf("%d", &n);
scanf("%ld", &x);
for (long int i = 0; i < n; ++i) {
cin >> a;
sum = sum + a;
}
k = x - sum;
if (k == n - 1)
printf("YES");
else
printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> L[200001];
int plus_minus[400001];
int ap1[400001], ap2[400001], apcom[400001];
int command[200001];
int f[400001], nr, nrcom;
void dfs(int i) {
f[i] = 1;
plus_minus[++nr] = i;
command[++nrcom] = nr;
apcom[i] = nrcom;
ap1[i] = nr;
for (auto it : L[i])
if (!f[it]) dfs(it);
plus_minus[++nr] = i;
ap2[i] = nr;
}
int main() {
int n, q, i, x, u, v, z, pas;
scanf("%d%d", &n, &q);
for (i = 2; i <= n; i++) {
scanf("%d", &x);
L[i].push_back(x);
L[x].push_back(i);
}
for (i = 1; i <= n; i++) sort(L[i].begin(), L[i].end());
dfs(1);
while (q--) {
scanf("%d%d", &u, &v);
z = apcom[u] - 1;
pas = 1 << 20;
while (pas) {
if (z + pas <= nrcom && command[z + pas] < ap2[u]) z += pas;
pas /= 2;
}
if (apcom[u] - 1 + v <= z)
printf("%d\n", plus_minus[command[apcom[u] - 1 + v]]);
else
printf("-1\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> ar(n);
for (int i = 0; i < ar.size(); i++) cin >> ar[i];
long long prev = ar[n - 1], sum = ar[n - 1];
for (int i = n - 2; i >= 0; i--) {
if (prev > ar[i]) {
sum += ar[i];
prev = ar[i];
} else if (prev != 0) {
sum += prev - 1;
prev--;
} else
break;
}
cout << sum;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
char str[N];
long long dp[N][5];
long long calc(int i, int s) {
if (str[i] == 0) return 0;
long long &ret = dp[i][s];
if (ret != -1) return ret;
ret = 0;
if (s == 0) {
ret += calc(i + 1, 0);
if (isalpha(str[i])) ret += calc(i + 1, 1);
} else if (s == 1) {
if (isalnum(str[i]) || str[i] == '_')
ret += calc(i + 1, 1);
else if (str[i] == '@')
ret += calc(i + 1, 2);
} else if (s == 2) {
if (isalnum(str[i])) ret += calc(i + 1, 3);
} else if (s == 3) {
if (isalnum(str[i]))
ret += calc(i + 1, 3);
else if (str[i] == '.')
ret += calc(i + 1, 4);
} else {
if (isalpha(str[i])) ret += 1 + calc(i + 1, 4);
}
return ret;
}
int main() {
scanf("%s", str);
memset(dp, -1, sizeof dp);
cout << calc(0, 0);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct order {
int w, x, y;
} ord[1000000 + 5];
long long k;
int f[1000000 + 5], num[1000000 + 5];
int ans[1000 + 5][1000 + 5], a[1000 + 5][1000 + 5];
int n, m, cnt;
int st[2][4] = {{1, 0, -1, 0}, {0, 1, 0, -1}};
bool comp(order a, order b) { return a.w > b.w; }
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int Hash(int x, int y) { return (x - 1) * m + y; }
void cover(int x, int y, int v, int &rest) {
if (rest == 0) return;
ans[x][y] = v, rest--;
for (int i = 0; i < 4; i++) {
int sx = x + st[0][i], sy = y + st[1][i];
if (sx < 1 || sx > n || sy < 1 || sy > m) continue;
if (a[sx][sy] >= v && ans[sx][sy] == 0) cover(sx, sy, v, rest);
}
}
void unite(int x, int y) {
if (find(x) == find(y)) return;
int fx = find(x), fy = find(y);
f[fy] = fx, num[fx] += num[fy];
}
void print() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%d ", ans[i][j]);
puts("");
}
}
void solve() {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
f[Hash(i, j)] = Hash(i, j), num[Hash(i, j)] = 1;
for (int i = 1; i <= cnt; i++) {
int pos = Hash(ord[i].x, ord[i].y);
for (int j = 0; j < 4; j++) {
int sx = ord[i].x + st[0][j], sy = ord[i].y + st[1][j], cur;
if (sx < 1 || sx > n || sy < 1 || sy > m) continue;
if (a[sx][sy] >= ord[i].w) cur = Hash(sx, sy), unite(pos, cur);
}
if (k % ord[i].w == 0 && num[find(pos)] >= k / ord[i].w) {
puts("YES");
int res = k / ord[i].w;
cover(ord[i].x, ord[i].y, ord[i].w, res);
print();
return;
}
}
puts("NO");
}
int main() {
scanf("%d%d%I64d", &n, &m, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
ord[++cnt] = (order){a[i][j], i, j};
}
sort(ord + 1, ord + cnt + 1, comp);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N;
void read() { scanf("%d", &N); }
int a[1000000];
int abs(int x) { return x > 0 ? x : -x; }
void solve() {
if (N == 4) {
printf("4\n3 1 4 2\n");
return;
}
int idx = 0;
for (int i = 1; i <= N; i += 2) a[idx++] = i;
for (int j = 2; j <= N; j += 2)
if (abs(a[idx - 1] - j) > 1) a[idx++] = j;
printf("%d\n", idx);
for (int i = 0; i < idx; i++) printf("%d ", a[i]);
}
int main() {
read();
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100][100];
int main() {
int n, t;
cin >> n >> t;
t *= (1 << 9);
a[0][0] = t;
int num = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i + 1; j++) {
if (a[i][j] >= (1 << 9)) num++;
a[i + 1][j] += max(a[i][j] - (1 << 9), 0) / 2;
a[i + 1][j + 1] += max(a[i][j] - (1 << 9), 0) / 2;
}
}
cout << num << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, r;
int a[105], b[105];
vector<pair<int, int> > V;
priority_queue<pair<int, int> > pq;
bool vis[105];
int main() {
ios::sync_with_stdio(false);
cin >> n >> r;
for (int i = 1; i <= n; ++i) cin >> a[i] >> b[i];
for (int i = 1; i <= n; ++i) {
if (b[i] >= 0) V.push_back(make_pair(a[i], b[i]));
}
sort(V.begin(), V.end());
for (int i = 0; i < V.size(); ++i) {
if (r < V[i].first) {
cout << "NO";
return 0;
}
r += V[i].second;
}
int cnt = V.size();
if (cnt == n) {
cout << "YES";
return 0;
}
V.clear();
for (int i = 1; i <= n; ++i)
if (b[i] < 0) r += b[i];
if (r < 0) {
cout << "NO";
return 0;
}
while (1) {
bool bad = 1;
for (int i = 1; i <= n; ++i)
if (b[i] < 0 && !vis[i] && r - b[i] >= a[i]) {
r -= b[i];
vis[i] = 1;
++cnt;
bad = 0;
}
if (bad) break;
}
if (cnt < n)
cout << "NO";
else
cout << "YES";
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int a[n];
std::set<int> multime;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
multime.insert(a[i]);
}
for (int i = 0; i < n; i++) {
auto it = multime.find(a[i]);
it++;
if (it == multime.end()) it = multime.begin();
printf("%d ", *it);
}
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char s[100055];
inline bool G(char x) {
return x == 'A' || x == 'H' || x == 'I' || x == 'M' || x == 'O' || x == 'T' ||
x == 'U' || x == 'V' || x == 'W' || x == 'X' || x == 'Y';
}
int main() {
gets(s);
for (int l = 0, r = strlen(s) - 1; l <= r; l++, r--) {
if ((!G(s[l])) || s[l] != s[r]) {
puts("NO");
return 0;
}
}
puts("YES");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int st, sst, en;
int a[505], g[505], o[505];
int b[505 * 505], e[505 * 505], h[505 * 505], w[505 * 505], c[505 * 505],
pre[505 * 505], p[505 * 505];
long long d[505 * 505];
queue<int> q;
long long ans;
int tot = 1;
char op[1005][105];
int get(int x) {
int s = 0;
while (x) {
x &= (x - 1);
s++;
}
return s;
}
int spfa() {
for (int i = 0; i <= en; i++) {
d[i] = 100000;
p[i] = 0;
}
d[st] = 0;
p[st] = 1;
q.push(st);
while (!q.empty()) {
int k = q.front();
q.pop();
p[k] = 0;
for (int go = h[k]; go; go = e[go])
if (d[b[go]] > d[k] + w[go] && c[go]) {
d[b[go]] = d[k] + w[go];
pre[b[go]] = go;
if (p[b[go]] == 0) {
p[b[go]] = 1;
q.push(b[go]);
}
}
}
if (d[en] < 100000) {
long long flow = 100000;
for (int go = en; go != st; go = b[pre[go] ^ 1])
flow = min(flow, (long long)c[pre[go]]);
if (flow * d[en] >= 0) return 0;
ans += flow * d[en];
for (int go = en; go != st; go = b[pre[go] ^ 1])
c[pre[go]] -= flow, c[pre[go] ^ 1] += flow;
return 1;
}
return 0;
}
void add(int x, int y, int z, int q) {
b[++tot] = y;
c[tot] = z;
w[tot] = q;
e[tot] = h[x];
h[x] = tot;
b[++tot] = x;
c[tot] = 0;
w[tot] = -q;
e[tot] = h[y];
h[y] = tot;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
g[i] = get(a[i]);
}
st = 2 * n;
sst = st + 1;
en = sst + 1;
add(st, sst, m, 0);
for (int i = 0; i < n; i++) {
add(sst, i, 1, g[i]);
add(i + n, en, 1, 0);
add(i, i + n, 1, -100000);
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
if (a[i] == a[j])
add(i + n, j, 1, 0);
else
add(i + n, j, 1, g[j]);
}
while (spfa())
;
int now = 0, sum = 0;
m = 0;
for (int i = 0; i < n; i++) {
for (int go = h[i]; go; go = e[go])
if (c[go] == 1) {
if (b[go] == sst) {
o[i] = now++;
sum += 2;
sprintf(op[m++], "%c=%d\nprint(%c)\n", o[i] + 'a', a[i], o[i] + 'a');
} else {
o[i] = o[b[go] - n];
if (w[go] != 0) {
sum += 2;
sprintf(op[m++], "%c=%d\nprint(%c)\n", o[i] + 'a', a[i],
o[i] + 'a');
} else {
sum++;
sprintf(op[m++], "print(%c)\n", o[i] + 'a');
}
}
}
}
printf("%d %I64d\n", sum, ans + n * 100000);
for (int i = 0; i < m; i++) printf("%s", op[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool compare(string s1, string s2) {
for (int i = 0; i < s1.length(); i++) {
if (s1[i] != s2[i]) return false;
}
return true;
}
int main() {
string s;
string real = "CODEFORCES";
cin >> s;
bool f1 = 0, f2 = 0, f3 = 0;
if (s.length() < 10) {
cout << "No" << endl;
return 0;
}
string s1 = s.substr(s.length() - 10, 10);
string s2 = s.substr(0, 10);
if (compare(s1, "CODEFORCES")) f1 = true;
if (compare(s2, "CODEFORCES")) f3 = true;
for (int i = 1; i <= 9; i++) {
if (compare(s.substr(0, i), real.substr(0, i)) &&
compare(s.substr(s.length() - 10 + i, 10 - i),
real.substr(real.length() - 10 + i, 10 - i)))
f2 = true;
}
if (f1 || f2 || f3) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<char> s, ans;
ostream& operator<<(ostream& out, vector<char>& t) {
for (int i = 0; i < t.size(); i++) printf("%c", t[i]);
return out;
}
void genSuff(int ind, int fr, int sv, vector<char>& a) {
while (a.size() > ind) a.pop_back();
for (int i = 0; i < fr; i++) a.push_back('4');
for (int i = 0; i < sv; i++) a.push_back('7');
}
void tryGen(vector<char> s) {
if (s.size() & 1) return;
int mini = -1, kfr, ksv, n = s.size(), fr = n / 2, sv = n / 2;
for (int i = 0; i < n && ans.size() < n; i++)
if (s[i] < '4') {
ans.push_back(fr != 0 ? '4' : '7');
genSuff(i + 1, fr - (fr > 0), sv - (fr == 0), ans);
} else if (s[i] == '4' && fr > 0) {
ans.push_back('4');
fr--;
if (sv != 0) {
mini = i;
kfr = fr;
ksv = sv;
}
} else if (s[i] == '4') {
ans.push_back('7');
genSuff(i + 1, fr, sv - 1, ans);
} else if (s[i] <= '7' && sv > 0) {
ans.push_back('7');
sv--;
if (s[i] < '7') genSuff(i + 1, fr, sv, ans);
} else {
if (mini == -1) {
ans.clear();
return;
}
ans[mini] = '7';
ksv--;
kfr++;
genSuff(mini + 1, kfr, ksv, ans);
}
}
int main() {
char r;
while (cin >> r) s.push_back(r);
tryGen(s);
if (ans.size() == 0) genSuff(0, (s.size() + 2) / 2, (s.size() + 2) / 2, ans);
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int N, M;
cin >> N >> M;
vector<long long> boys(N), girls(M);
for (auto &b : boys) cin >> b;
for (auto &g : girls) cin >> g;
sort(boys.begin(), boys.end());
sort(girls.begin(), girls.end());
if (boys.back() > girls.front()) {
cout << -1 << '\n';
return 0;
}
vector<long long> from(M - 1, boys.back());
if (boys.back() == girls.front())
from.push_back(boys.back());
else
from.push_back(boys[N - 2]);
long long total = 0;
for (int i = 0; i < N; i++) total += boys[i] * M;
for (auto &x : from) total -= x;
for (int i = 0; i < M; i++) total += girls[i];
cout << total << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, j, num[2005], l, r, mid, ans, dp[2005];
bool check(long long x) {
memset(dp, 0, sizeof(dp));
long long i, j;
for (i = 1; i <= n; i++) dp[i] = i - 1;
for (i = 1; i <= n; i++) {
for (j = i; j < n; j++) {
if ((j - i + 1) * x >= abs(num[i] - num[j + 1])) {
dp[j + 1] = min(dp[i] + j - i, dp[j + 1]);
}
}
dp[n] = min(dp[n], dp[i] + n - i);
}
return dp[n] <= m;
}
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> num[i];
}
l = 0;
ans = r = 2e9;
while (l < r) {
mid = (l + r) / 2;
if (check(mid)) {
r = mid;
ans = mid;
} else
l = mid + 1;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool ask(int x, int y) {
static char ty[10];
printf("1 %d %d\n", x, y);
fflush(stdout);
scanf("%s", ty);
return *ty == 'T';
}
int find(int l, int r) {
while (l < r) {
int mid = (l + r) >> 1;
int flag = ask(mid, mid + 1);
if (flag)
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
int N, K;
scanf("%d%d", &N, &K);
int ans[2];
ans[0] = find(1, N);
ans[1] = 0;
if (ans[0] > 1) {
ans[1] = find(1, ans[0] - 1);
if (!ask(ans[1], ans[0])) ans[1] = 0;
}
if (!ans[1] && ans[0] < N) ans[1] = find(ans[0] + 1, N);
printf("2 %d %d\n", ans[0], ans[1]);
fflush(stdout);
return 0;
}
| 7 |
#include <bits/stdc++.h>
int min(int o, int p) { return (o < p) ? o : p; }
struct Edge {
int v, next;
} E[4000001];
int label[2000], list[2000];
struct Tarjan {
Edge *E;
bool in[5000];
int DFN[5000], Low[5000], st[5000], top, *list, *label, compo, deep;
int DirGraphShrink(int N, int *list, Edge *E, int *label) {
this->list = list;
this->E = E;
this->label = label;
memset(in, false, sizeof(in));
memset(DFN, 0, sizeof(DFN));
top = compo = deep = 0;
for (int i = 0; i < N; i++)
if (DFN[i] == 0) _tarjan(i);
return compo;
}
void _tarjan(int u) {
DFN[u] = Low[u] = ++deep;
st[top++] = u;
in[u] = true;
for (int p = list[u]; p != -1; p = E[p].next) {
int v = E[p].v;
if (DFN[v] == 0) {
_tarjan(v);
Low[u] = min(Low[u], Low[v]);
} else if (in[v])
Low[u] = min(Low[u], DFN[v]);
}
if (Low[u] == DFN[u]) {
int v;
do {
v = st[--top];
label[v] = compo;
in[v] = false;
} while (v != u);
compo++;
}
}
} dir_tarjan;
int main() {
int n, tot = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) list[i] = -1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
int x;
scanf("%d", &x);
if (x > 0) {
E[tot].v = j;
E[tot].next = list[i];
list[i] = tot;
tot++;
}
}
if (dir_tarjan.DirGraphShrink(n, list, E, label) == 1)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
int n, h, r;
struct Spell {
int index;
int pow;
int dmg;
bool used;
};
Spell s[1111];
struct Result {
int t, index;
};
Result result[2222];
int main() {
scanf("%d%d%d", &n, &h, &r);
int maxi = h;
for (int i = 0; i < n; i++) {
scanf("%d%d", &s[i].pow, &s[i].dmg);
s[i].index = i + 1;
s[i].used = false;
}
bool ok = false, defeated = false;
int cnt = 0, total = 0, anslen = 0;
while (!ok || cnt < 3000) {
ok = true;
int ih = h;
h -= total;
h += r;
if (h <= 0) {
defeated = true;
break;
}
if (h > maxi) h = maxi;
if (ih > h) ok = false;
int now = 0, id = -1;
for (int i = 0; i < n; i++) {
if (!s[i].used && s[i].pow / 100.0 - 1.0 * h / maxi > -10e-8) {
if (now < s[i].dmg) {
now = s[i].dmg;
id = s[i].index;
}
}
}
if (id != -1) {
ok = false;
result[anslen].t = cnt;
result[anslen].index = id;
s[id - 1].used = true;
anslen++;
total += now;
}
cnt++;
}
if (defeated) {
printf("YES\n");
printf("%d %d\n", cnt, anslen);
for (int i = 0; i < anslen; i++) {
printf("%d %d\n", result[i].t, result[i].index);
}
} else
printf("NO\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
const double Pi = acos(-1);
using namespace std;
int debug = 01;
int main() {
map<int, string> m, n, x;
m[1] = "one", m[2] = "two", m[3] = "three", m[4] = "four", m[5] = "five",
m[6] = "six", m[7] = "seven", m[8] = "eight", m[9] = "nine";
n[2] = "twenty", n[3] = "thirty", n[4] = "forty", n[5] = "fifty",
n[6] = "sixty", n[7] = "seventy", n[8] = "eighty", n[9] = "ninety";
x[10] = "ten", x[11] = "eleven", x[12] = "twelve", x[13] = "thirteen",
x[14] = "fourteen", x[15] = "fifteen", x[16] = "sixteen", x[17] = "seventeen",
x[18] = "eighteen", x[19] = "nineteen";
int s;
cin >> s;
if (!s) {
cout << "zero";
return 0;
}
if (s < 10) {
cout << m[s];
return 0;
}
if (s < 20) {
cout << x[s];
return 0;
}
cout << n[s / 10];
if (s % 10) cout << "-" << m[s % 10];
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2, s3;
int sum1 = 0, sum2 = 0, sum3 = 0, size, i, j;
getline(cin, s1);
size = s1.length();
for (j = 0; j < size; j++) {
if (s1[j] == 'a') sum1++;
if (s1[j] == 'e') sum1++;
if (s1[j] == 'i') sum1++;
if (s1[j] == 'o') sum1++;
if (s1[j] == 'u') sum1++;
}
getline(cin, s2);
size = s2.length();
for (j = 0; j < size; j++) {
if (s2[j] == 'a') sum2++;
if (s2[j] == 'e') sum2++;
if (s2[j] == 'i') sum2++;
if (s2[j] == 'o') sum2++;
if (s2[j] == 'u') sum2++;
}
getline(cin, s3);
size = s3.length();
for (j = 0; j < size; j++) {
if (s3[j] == 'a') sum3++;
if (s3[j] == 'e') sum3++;
if (s3[j] == 'i') sum3++;
if (s3[j] == 'o') sum3++;
if (s3[j] == 'u') sum3++;
}
if (sum1 == 5 && sum2 == 7 && sum3 == 5)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename T>
string to_str(T str) {
stringstream stream;
stream << str;
return stream.str();
}
template <typename T>
int to_int(T num) {
int val;
stringstream stream;
stream << num;
stream >> val;
return val;
}
vector<string> split(const string& s, char delim) {
vector<string> elems;
stringstream ss(s);
string item;
while (getline(ss, item, delim)) elems.push_back(item);
return elems;
}
const int dr[] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[] = {0, 1, 1, 1, 0, -1, -1, -1};
long long int s1, s2, last;
int main() {
int n;
scanf("%d", &n);
vector<int> f, l;
for (int i = 0; i < (n); i++) {
int x;
scanf("%d", &x);
if (x < 0)
s2 += -x, last = 2, l.push_back(-x);
else
s1 += x, last = 1, f.push_back(x);
}
if (s1 > s2)
puts("first");
else if (s2 > s1)
puts("second");
else {
for (int i = 0; i < (((int)f.size())); i++) {
if (f[i] > l[i]) {
puts("first");
return 0;
}
if (l[i] > f[i]) {
puts("second");
return 0;
}
}
if (last == 1)
puts("first");
else
puts("second");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 111111;
const double eps = 1e-8;
int tmp, n, i, j, v1, v2, cnt;
long long l, L, V;
long long q[MAXN + MAXN], a[MAXN], ans[MAXN];
map<long long, int> ma;
map<long long, int>::iterator it;
int main() {
scanf("%d%d%d%d", &n, &tmp, &v1, &v2);
l = tmp;
L = l * v2;
l *= 2LL * (v1 + v2);
j = 0;
for ((i) = +0; (i) < (int)(n); ++(i)) {
scanf("%d", &tmp);
q[j++] = a[i] = (long long)tmp * (v1 + v2);
q[j++] = (a[i] + l - L) % l;
ma[a[i]]++;
}
sort(q, q + j);
j = unique(q, q + j) - q;
sort(a, a + n);
cnt = 0;
for ((i) = +0; (i) < (int)(n); ++(i))
if (q[0] <= a[i] && a[i] <= q[0] + L) cnt++;
for ((i) = 1 + 0; (i) < (int)(j); ++(i)) {
cnt -= ma[q[i - 1]];
ans[cnt] += q[i] - q[i - 1];
cnt += ma[(q[i] + L) % l];
}
if (j > 1) {
cnt -= ma[q[j - 1]];
ans[cnt] += q[0] + l - q[j - 1];
}
for ((i) = +0; (i) < (int)(n + 1); ++(i))
printf("%.20lf\n", (double)ans[i] / l);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
string x;
cin >> x;
bool cond = false;
string ans[2];
for (auto ch : x) {
if (ch == '1') {
if (cond) {
ans[!cond] += '1';
ans[cond] += '0';
} else {
ans[0] += '0';
ans[1] += '1';
cond = true;
}
} else if (ch == '2') {
if (cond) {
ans[!cond] += '2';
ans[cond] += '0';
} else {
ans[0] += '1';
ans[1] += '1';
}
} else {
ans[0] += '0';
ans[1] += '0';
}
}
cout << ans[0] << "\n" << ans[1] << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N];
bool vis[N];
int main() {
int n, i, j, k;
while (~scanf("%d", &n)) {
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
int cnt = 0;
for (i = 30; i >= 0; i--) {
memset(vis, false, sizeof(vis));
cnt = 0;
bool flag = true;
for (j = 1; j <= n; j++)
if (a[j] & (1 << i)) vis[j] = true, cnt++;
for (j = i - 1; j >= 0 && flag; j--) {
int num_0 = 0;
for (k = 1; k <= n && !num_0; k++)
if (vis[k]) {
if (!(a[k] & (1 << j))) num_0 = 1;
}
if (!num_0) flag = false;
}
if (flag) break;
}
printf("%d\n", cnt);
for (i = 1; i <= n; i++) {
if (vis[i]) {
cnt--;
if (cnt == 0)
printf("%d\n", a[i]);
else
printf("%d ", a[i]);
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, inf = 1e8;
long long s[N], a[N], b[N];
long long sum, c1, c2, res1, res2, m1, m2;
vector<pair<long long, long long> > v1, v2;
int main() {
long long n, ss;
cin >> n >> ss;
m1 = inf;
m2 = inf;
for (int i = 1; i <= n; i++) {
cin >> s[i] >> a[i] >> b[i];
sum += s[i];
if (a[i] >= b[i]) {
c1 += s[i];
res1 += s[i] * a[i];
v1.push_back({a[i] - b[i], s[i]});
} else {
c2 += s[i];
res2 += s[i] * b[i];
v2.push_back({b[i] - a[i], s[i]});
}
}
long long res = (sum + ss - 1) / ss;
if (res == (c1 + ss - 1) / ss + (c2 + ss - 1) / ss)
cout << res1 + res2 << endl;
else {
res = res1 + res2;
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
long long rem1 = c1 - ((c1 + ss - 1) / ss - 1) * ss;
long long rem2 = c2 - ((c2 + ss - 1) / ss - 1) * ss;
long long tem = res, ans;
while (rem1 > 0) {
for (auto u : v1) {
tem -= u.first * min(u.second, rem1);
rem1 -= u.second;
if (rem1 <= 0) break;
}
ans = tem;
}
tem = res;
while (rem2 > 0) {
for (auto u : v2) {
tem -= u.first * min(u.second, rem2);
rem2 -= u.second;
if (rem2 <= 0) break;
}
ans = max(ans, tem);
}
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
const int INF = 0x7fffffff;
struct max_flow_t {
struct edge_t {
int u, v, next, cap, flow;
edge_t() {}
edge_t(int a, int b, int c, int d, int e)
: u(a), v(b), next(c), cap(d), flow(e) {}
};
vector<edge_t> G;
vector<int> head, nowhead, d;
int n, s, t, tot;
max_flow_t() {
G.clear();
head.clear();
tot = 1;
}
max_flow_t(int nn) {
n = nn;
s = 0;
t = n + 1;
G.clear();
head.clear();
head.resize(n + 2, 0);
tot = 1;
}
inline void addedge(int u, int v, int cap) {
G.resize(tot + 3);
G[++tot] = (edge_t){u, v, head[u], cap, 0}, head[u] = tot;
G[++tot] = (edge_t){v, u, head[v], 0, 0}, head[v] = tot;
}
int bfs() {
d.clear();
d.resize(n + 2, 0);
d[s] = 1;
queue<int> q;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
for (register int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
if (G[i].cap > G[i].flow && d[v] == 0) {
d[v] = d[u] + 1;
q.push(v);
}
}
}
return d[t];
}
int dfs(int u, int Flow) {
if (u == t || !Flow) return Flow;
int flow = 0, f;
for (register int &i = nowhead[u]; i; i = G[i].next) {
int v = G[i].v;
if (d[v] == d[u] + 1 &&
(f = dfs(v, min(Flow, G[i].cap - G[i].flow))) > 0) {
G[i].flow += f;
G[i ^ 1].flow -= f;
flow += f;
Flow -= f;
if (!Flow) break;
}
}
return flow;
}
int dinic() {
int ans = 0;
while (bfs()) {
nowhead = head;
ans += dfs(s, INF);
}
return ans;
}
} M;
const int N = 1005;
int p1[N], p2[N];
int n, a, b;
int main() {
M = max_flow_t(4000);
read(n);
read(a);
for (register int i = 2; i <= a; i++) {
int fa;
read(fa);
M.addedge(fa, i, 2000);
M.addedge(M.s, i, 1);
}
for (register int i = 1; i <= n; i++) read(p1[i]);
read(b);
for (register int i = 2; i <= b; i++) {
int fa;
read(fa);
M.addedge(i + a, fa + a, 2000);
M.addedge(i + a, M.t, 1);
}
for (register int i = 1; i <= n; i++) {
read(p2[i]);
M.addedge(p1[i], p2[i] + a, 2000);
}
print(a + b - 2 - M.dinic(), '\n');
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 100 * 10 + 2;
pair<int, int> points[maxn];
pair<int, int> cur[maxn];
pair<int, int> pre[maxn];
pair<int, int> cur2[maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
scanf("%d%d", &(points[i].first), &(points[i].second));
}
sort(points, points + m);
pre[0].first = 1;
pre[0].second = 1;
int preSize = 1, curSize = 0, cur2Size = 0;
int last = 0;
for (int i = 0; i < m;) {
if (points[i].first - 1 != last) {
if (preSize == 0) {
cout << -1 << endl;
return 0;
}
pair<int, int> p = make_pair(pre[0].first, n);
preSize = 1;
pre[0] = p;
}
last = points[i].first;
curSize = 0;
cur2Size = 0;
if (points[i].second - 1 >= 1) {
cur[0] = make_pair(1, points[i].second - 1);
curSize++;
}
int j;
for (j = i + 1; j < m && points[j].first == points[i].first; ++j) {
if ((points[j].second - 1) - (points[j - 1].second + 1) >= 0) {
cur[curSize] =
make_pair(points[j - 1].second + 1, points[j].second - 1);
++curSize;
}
}
if (points[j - 1].second < n) {
cur[curSize] = make_pair(points[j - 1].second + 1, n);
curSize++;
}
for (int k = 0; k < curSize; ++k) {
int t = cur[k].first;
long long l = 0, r = preSize - 1, mid;
while (l <= r) {
mid = (l + r);
mid >>= 1;
if (pre[mid].second < t) {
l = mid + 1;
} else if (pre[mid].second == t) {
r = mid;
break;
} else {
if (l == r) break;
r = mid;
}
}
l = r;
if (pre[l].first <= t && t <= pre[l].second) {
cur2[cur2Size] = cur[k];
cur2Size++;
} else if (cur[k].first <= pre[l].first &&
pre[l].first <= cur[k].second) {
cur2[cur2Size] = make_pair(pre[l].first, cur[k].second);
cur2Size++;
}
}
i = j;
for (int j = 0; j < cur2Size; ++j) pre[j] = cur2[j];
preSize = cur2Size;
}
if (preSize == 0) {
cout << -1 << endl;
} else if (last != n) {
cout << (n - 1) * 2 << endl;
} else {
if (pre[preSize - 1].second >= n)
cout << (n - 1) * 2 << endl;
else
cout << -1 << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long int z = 0;
long long int p = accumulate(a, a + n, z);
long long int k = 0, maxi = -999999999999999, flag = 0, x = 0, y = 0;
for (int i = 0; i < n; i++) {
k = k + a[i];
if (k > maxi) {
maxi = k;
y = i;
}
if (k <= 0) {
k = 0;
x = i;
}
}
if (maxi > p)
cout << "NO" << endl;
else if (maxi == p && x == 0 && y == n - 1)
cout << "YES" << endl;
else if (maxi < p)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
int n, k;
int bef;
int tmp;
int main() {
int i;
scanf("%d %d", &n, &k);
if (1 + k < n)
for (i = n; i > 1 + k; i--) printf("%d ", i);
for (i = 0; i < 1 + k; i++)
if (i % 2 == 0)
printf("%d ", 1 + k - i / 2);
else
printf("%d ", 1 + i / 2);
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e17 + 9;
vector<int> adj[100009];
int vis[100009];
void addedge(int a, int b) { adj[a].push_back(b); }
long long ult = -1;
void dfs(int x) {
vis[x] = 1;
for (auto e : adj[x]) {
if (vis[e] == -1) {
ult = e;
dfs(e);
}
}
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int inc[100009];
memset(vis, -1, sizeof vis);
memset(inc, 0, sizeof inc);
vector<pair<long long, long long> > comp;
for (long long i = 1; i <= (long long)(n); i++) {
int a;
cin >> a;
addedge(i, a);
inc[a]++;
}
for (long long i = 1; i <= (long long)(n); i++) {
if (inc[i] == 0) {
ult = -1;
dfs(i);
if (ult == -1) ult = i;
comp.push_back({i, ult});
}
}
for (long long i = 1; i <= (long long)(n); i++) {
ult = -1;
if (vis[i] == -1) dfs(i), comp.push_back({i, ult});
}
memset(vis, -1, sizeof vis);
if (comp.size() == 1) dfs(comp[0].second);
if (comp.size() == 1 && vis[comp[0].first] == 1)
cout << "0\n";
else {
cout << comp.size() << "\n";
for (long long i = 0; i < (long long)(comp.size() - 1); i++) {
cout << comp[i].second << " " << comp[i + 1].first << "\n";
}
cout << comp.back().second << " " << comp[0].first << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double a;
cin >> a;
if (a <= 127)
cout << "byte" << endl;
else if (a <= 32767)
cout << "short" << endl;
else if (a <= 2147483647)
cout << "int" << endl;
else if (a <= 9223372036854775807)
cout << "long" << endl;
else
cout << "BigInteger" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int h, m, h1, m1;
char s;
int main() {
cin >> h >> s >> m;
cin >> h1 >> s >> m1;
h += 23;
m += 60;
m -= m1;
h += m / 60;
m %= 60;
h -= h1;
h %= 24;
if (h < 10) cout << 0;
cout << h << ":";
if (m < 10) cout << 0;
cout << m;
cin >> m;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265359;
const long long int Maxi = 1e18;
multiset<pair<long long, long long> > v;
multiset<pair<long long, long long> >::iterator it;
long long a[300005];
long long b[300005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, i, j, l, k = 0, p = 0, s = 0, t = 1, x, y, z, r, c;
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> a[i];
if (i <= k + 1) v.insert({a[i], i});
}
x = k + 1;
for (i = 1; i <= n; i++) {
k++;
x++;
it = v.end();
it--;
s += (k - it->second) * it->first;
b[it->second] = k;
v.erase(it);
if (x <= n) v.insert({a[x], x});
}
cout << s << endl;
for (i = 1; i <= n; i++) cout << b[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1000000001;
int n, m;
int c3, c4, c5, ans, x, y, z, g, gg;
int gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x == 3) c3++;
if (x == 4) c4++;
if (x == 5) c5++;
}
n = c3 + c4 + c5;
ans = oo;
gg = gcd(c4, c5);
g = c5 / gg;
for (int i = m / n; i >= 0; i--) {
if ((m - c3 * i) % gg) continue;
for (int j = (m - c3 * i) / (n - c3), v = 1; j >= i; j -= v) {
int t1 = c3 * i, t2 = c4 * j;
int k = (m - c3 * i - c4 * j) / c5;
int t3 = c5 * k;
if (t3 - t2 >= ans) break;
if (t1 + t2 + t3 != m)
continue;
else
v = g;
int tmp = abs(t1 - t2) + abs(t2 - t3);
if (tmp < ans) {
ans = tmp;
x = i;
y = j;
z = k;
}
}
}
if (ans == oo)
printf("-1\n");
else
printf("%d %d %d\n", x, y, z);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100004] = {0}, i, j, x;
int main() {
cin >> n;
for (i = 0, j = n; i < n; i++) {
cin >> x;
a[x] = 1;
if (a[j] == 1) {
while (j >= 1 && a[j--] == 1) {
cout << j + 1 << " ";
}
j++;
}
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void fastio() {}
int main() {
fastio();
int T = 1;
string s;
cin >> s;
long long int m = 0, i;
for (i = 0; i < s.size(); i++) {
m = ((m * 10) + (s[i] - '0'));
m %= 4;
}
if (m == 0)
cout << 4;
else
cout << 0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string s1, s2, s3;
bool beats(string s, string t) {
if (s == "rock") {
if (t == "scissors")
return 1;
else
return 0;
} else if (s == "paper") {
if (t == "rock")
return 1;
else
return 0;
} else {
if (t == "paper")
return 1;
else
return 0;
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> s1;
cin >> s2;
cin >> s3;
if (s1 == s2 && s1 == s3) {
cout << "?\n";
return 0;
}
if (s1 == s2) {
if (beats(s1, s3))
cout << "?\n";
else
cout << "S\n";
return 0;
}
if (s1 == s3) {
if (beats(s1, s2))
cout << "?\n";
else
cout << "M\n";
return 0;
}
if (s2 == s3) {
if (beats(s2, s1))
cout << "?\n";
else
cout << "F\n";
return 0;
}
cout << "?\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, a, s, t, v, ans = 0;
scanf("%lf%lf%lf", &n, &a, &s);
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &t, &v);
ans = max(ans, t + (v * v <= 2 * s * a ? v / a + (s - v * v / a / 2) / v
: sqrt(2 * s / a)));
printf("%.12f\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int cal[28], n;
string s;
map<int, int> mp;
int main(void) {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> s;
memset(cal, 0, sizeof(cal));
for (auto t : s) {
cal[t - 'a']++;
}
int val = 0;
for (int j = 0; j < 26; ++j) {
if (cal[j] % 2) {
val ^= (1 << j);
}
}
mp[val]++;
}
long long rt = 0;
for (auto item : mp) {
int num = item.second, id = item.first;
rt += 1LL * num * (num - 1) / 2;
for (int i = 0; i < 26; ++i) {
if (id & (1 << i)) {
rt += 1LL * num * mp[id ^ (1 << i)];
}
}
}
cout << rt << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool uax(T &x, T y) {
return (y > x) ? x = y, true : false;
}
template <typename T>
inline bool uin(T &x, T y) {
return (y < x) ? x = y, true : false;
}
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
template <typename A>
string to_string(A);
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ": " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool f = false;
string r = "{";
for (auto x : v) {
if (f) r += ", ";
r += to_string(x);
f = true;
}
return r += "}";
}
template <typename A>
string to_string(vector<vector<A>> v) {
string r;
for (auto x : v) r += "\n" + to_string(x);
return r;
}
int Nerr;
template <typename A>
string to_string(A *p) {
return to_string(vector<A>(p, p + Nerr));
}
void err(istream_iterator<string>) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " =: " << to_string(a) << "; ";
err(++it, args...);
}
template <typename T>
void kek(T ans) {
cout << ans << endl;
exit(0);
}
long long const INF = 1e18 + 42;
const int MOD = 998244353;
inline int add(int a, int b, int mod = MOD) {
a += b;
return a >= mod ? a - mod : a;
}
inline int sub(int a, int b, int mod = MOD) {
a -= b;
return a < 0 ? a + mod : a;
}
inline int mul(int a, int b, int mod = MOD) {
return int((long long)a * b % mod);
}
inline int mpow(int base, long long ex, int mod = MOD) {
int res = 1;
for (; ex > 0; ex >>= 1) {
if (ex & 1) res = mul(res, base, mod);
base = mul(base, base, mod);
}
return res;
}
inline int inv(int a, int mod = MOD) { return mpow(a, mod - 2, mod); }
inline int mdiv(int a, int b, int mod = MOD) {
return mul(a, mpow(b, mod - 2, mod));
}
inline void adds(int &a, int b, int mod = MOD) {
a += b;
if (a >= mod) a -= mod;
}
inline void subs(int &a, int b, int mod = MOD) {
a -= b;
if (a < 0) a += mod;
}
inline void muls(int &a, int b, int mod = MOD) {
a = int((long long)a * b % mod);
}
inline void mdivs(int &a, int b, int mod = MOD) { a = mdiv(a, b, mod); }
template <typename T, int K>
struct Basis {
array<T, K> bas;
int n, rank;
Basis() : bas(), n(), rank() {}
bool add(T x) {
++n;
for (int i = K - 1; i >= 0; --i) {
if (x >> i & 1) {
if (bas[i]) {
x ^= bas[i];
} else {
bas[i] = x, ++rank;
return true;
}
}
}
return false;
}
int ways(T x) {
for (int i = K - 1; i >= 0; --i) {
if (x >> i & 1) x ^= bas[i];
}
return x == 0 ? mpow(2, n - rank) : 0;
}
Basis operator+(Basis o) const {
for (int i = 0; i < K; ++i)
if (bas[i]) o.add(bas[i]);
return o;
}
};
const int M = 35, F = 15, S = M - F;
int pc[1 << S];
int dp[1 + F][1 << F];
vector<long long> s, t;
inline int calc(int b, int nask) {
if (~dp[b][nask]) return dp[b][nask];
for (int i = 0; i <= F; ++i) dp[i][nask] = 0;
for (long long &x : s) ++dp[pc[x ^ nask]][nask];
return dp[b][nask];
};
int32_t main() {
cin.tie(nullptr)->sync_with_stdio(false);
memset(dp, -1, sizeof dp);
for (int i = 1; i < (1 << S); ++i) pc[i] = pc[i >> 1] + (i & 1);
int n, m;
cin >> n >> m;
Basis<long long, M> basis;
for (int i = 0; i < n; ++i) {
long long x;
cin >> x;
basis.add(x);
}
{
set<long long> seen;
for (int nask = 0; nask < (1 << F); ++nask) {
long long val = 0;
for (int i = 0; i < F; ++i)
if (nask >> i & 1) {
val ^= basis.bas[i];
}
if (seen.count(val))
;
else
s.push_back(val), seen.insert(val);
}
}
vector<int> ans(M + 1);
{
set<long long> seen;
for (int nask = 0; nask < (1 << S); ++nask) {
long long val = 0;
for (int i = 0; i < S; ++i)
if (nask >> i & 1) {
val ^= basis.bas[i + F];
}
if (seen.count(val))
;
else {
seen.insert(val);
long long rt = val & ((1 << F) - 1);
int cnt = pc[(val ^ rt) >> F];
for (int i = 0; i <= F; ++i) adds(ans[cnt + i], calc(i, (int)rt));
}
}
}
ans.resize(m + 1);
const int pw = mpow(2, n - basis.rank);
for (int x : ans) cout << mul(x, pw) << ' ';
cout << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long k;
cin >> k;
map<long long, long long> no;
for (long long i = 0; i < k; i++) {
long long a, b;
cin >> a >> b;
no[a]++;
no[b]++;
}
long long c;
cout << n - 1 << endl;
for (long long i = 1; i < n + 1; i++) {
if (no[i] == 0) c = i;
}
for (long long i = 1; i <= n; i++) {
if (c != i) cout << i << " " << c << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long getInt() {
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
int flag = 1;
if (c == '-') flag = -1, c = getchar();
long long x = 0;
while (isdigit(c)) {
x = (x * 10) + (c - '0');
c = getchar();
}
if (flag == -1) return -x;
return x;
}
const int INF = 1000000007;
const int N = 666666;
int a[N], b[N];
int n, m;
int visit[N], pre[N];
int main() {
scanf("%d", &n);
int i;
for (i = 1; i <= n; i++) scanf("%d", &a[i]), b[i] = a[i];
sort(b + 1, b + n + 1);
m = unique(b + 1, b + n + 1) - (b + 1);
for (i = 1; i <= n; i++) a[i] = lower_bound(b + 1, b + m + 1, a[i]) - b;
int last = 1;
set<int> s;
vector<int> ans;
memset(visit, -1, sizeof(visit));
memset(pre, -1, sizeof(pre));
for (i = 1; i <= n; i++) {
if (-1 == visit[a[i]]) {
if (pre[a[i]] == -1)
pre[a[i]] = i;
else {
int L = pre[a[i]];
int R = i - 1;
if (L > R) continue;
set<int>::iterator it = s.upper_bound(L);
vector<int> tmp;
while (it != s.end() && *it <= R) {
visit[a[*it]] = a[i];
tmp.push_back(*it);
it++;
}
int j;
for (j = 0; j < tmp.size(); j++) s.erase(tmp[j]);
}
s.insert(i);
} else {
ans.push_back(visit[a[i]]);
ans.push_back(a[i]);
ans.push_back(visit[a[i]]);
ans.push_back(a[i]);
int j;
for (j = last; j <= i; j++) visit[a[j]] = -1, pre[a[j]] = -1;
last = i + 1;
s.clear();
}
}
printf("%d\n", (int)ans.size());
for (i = 0; i < ans.size(); i++) {
if (i) putchar(' ');
printf("%d", b[ans[i]]);
}
puts("");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {1, -1, 0, 0, 0, 0};
const int dy[] = {0, 0, 1, -1, 0, 0};
const int dz[] = {0, 0, 0, 0, 1, -1};
int a[12][12][12], b[12][12][12];
char ss[1000];
int q[1 << 20];
int main() {
int k, n, m;
scanf("%d%d%d\n\n", &k, &n, &m);
memset(b, 1, sizeof b);
for (int kk = 1; kk <= k; kk++) {
for (int i = 1; i <= n; i++) {
gets(ss);
for (int j = 1; j <= m; j++) {
a[kk][i][j] = ss[j - 1] == '#';
b[kk][i][j] = 0;
}
}
scanf("\n");
}
int sx, sy;
scanf("%d%d", &sx, &sy);
int qb = 0, qe = 0;
q[qe++] = (1 << 8) + (sx << 4) + (sy << 0);
b[1][sx][sy] = 1;
while (qb < qe) {
int v = q[qb++];
int x = v >> 8, y = (v >> 4) & 15, z = v & 15;
for (int d = 0; d < (6); d++) {
int xx = x + dx[d], yy = y + dy[d], zz = z + dz[d];
if (!b[xx][yy][zz] && !a[xx][yy][zz]) {
b[xx][yy][zz] = 1;
q[qe++] = (xx << 8) + (yy << 4) + zz;
}
}
}
printf("%d\n", qe);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int m, n, Q, num;
int ans[222222] = {0};
int mm[444444] = {0};
pair<int, int> cd[222222];
struct master {
int x1, x2, y1, y2, num;
void input(int i) {
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
num = i;
}
} que[2222222];
bool cmp(const master &a, const master &b) { return a.y1 < b.y1; }
int findmax(int nl, int nr, int l, int r, int th) {
if (nl == l && nr == r) return mm[th];
int mid = nl + nr >> 1;
if (r <= mid) return findmax(nl, mid, l, r, th << 1);
if (l > mid) return findmax(mid + 1, nr, l, r, th << 1 | 1);
return max(findmax(nl, mid, l, mid, th << 1),
findmax(mid + 1, nr, mid + 1, r, th << 1 | 1));
}
void update(int nl, int nr, int x, int k, int th) {
if (nl == nr)
mm[th] = k;
else {
int mid = nl + nr >> 1;
if (x <= mid)
update(nl, mid, x, k, th << 1);
else
update(mid + 1, nr, x, k, th << 1 | 1);
mm[th] = max(mm[th], k);
}
}
vector<int> point[111111];
vector<int> in[111111];
int now[111111] = {0};
void solve() {
memset(now, 0, sizeof(now));
memset(mm, 0, sizeof(mm));
for (int i = 1; i <= m; i++) point[i].clear();
for (int i = 1; i <= n; i++) in[i].clear();
sort(que + 1, que + Q + 1, cmp);
sort(cd + 1, cd + num + 1);
for (int i = 1; i <= num; i++) point[cd[i].first].push_back(cd[i].second);
for (int i = 1; i <= m; i++) {
if (point[i].size() == 0)
update(1, m, i, n + 1, 1);
else
update(1, m, i, point[i][0], 1), in[point[i][0]].push_back(i);
}
int j = 1;
for (int i = 1; i <= n; i++) {
while (que[j].y1 == i && j <= Q) {
if (findmax(1, m, que[j].x1, que[j].x2, 1) <= que[j].y2)
ans[que[j].num] = 1;
j++;
}
for (int a = 0; a <= (int)in[i].size() - 1; a++) {
int th = in[i][a];
if (now[th] == point[th].size() - 1)
update(1, m, th, n + 1, 1);
else
now[th]++, update(1, m, th, point[th][now[th]], 1),
in[point[th][now[th]]].push_back(th);
}
}
}
int main() {
cin >> m >> n >> num >> Q;
for (int i = 1; i <= num; i++) scanf("%d%d", &cd[i].first, &cd[i].second);
for (int i = 1; i <= Q; i++) que[i].input(i);
solve();
swap(m, n);
for (int i = 1; i <= num; i++) swap(cd[i].first, cd[i].second);
for (int i = 1; i <= Q; i++)
swap(que[i].x1, que[i].y1), swap(que[i].x2, que[i].y2);
solve();
for (int i = 1; i <= Q; i++) {
if (ans[i])
puts("YES");
else
puts("NO");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i = 0, j, k, l, n, m;
cin >> n;
if (n % 400 == 0 || (n % 4 == 0 && n % 100 != 0))
j = 1;
else
j = 0;
while (1) {
if (n % 400 == 0 || (n % 4 == 0 && n % 100 != 0))
i = (i + 2) % 7;
else
i = (i + 1) % 7;
if (i == 0) {
if (j == 1) {
if ((n + 1) % 400 == 0 || ((n + 1) % 4 == 0 && (n + 1) % 100 != 0))
break;
} else if (j == 0) {
if ((n + 1) % 400 == 0 || ((n + 1) % 4 == 0 && (n + 1) % 100 != 0))
;
else
break;
}
}
n++;
}
cout << n + 1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int HASH_CONST = 120599;
const int HASH_BASE = (int)1E9 + 7;
const int MAXN = (int)1E4 + 10;
const int MAXM = (int)1E5 + 10;
const int MAXL = (int)1E3 + 10;
int n, m, maxLen;
string s, a[MAXM];
map<int, int> exist[MAXL];
int f[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
cin >> s;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> a[i];
maxLen = max(maxLen, (int)a[i].size());
long long h = 0;
for (int j = 0; a[i][j]; j++) {
int v = (a[i][j] <= 'Z') ? a[i][j] + 32 : a[i][j];
h = (h * HASH_CONST + v) % HASH_BASE;
}
exist[(int)a[i].size()][h] = i;
}
memset(f, 255, sizeof(f));
for (int i = 0; i < n; i++) {
long long h = 0;
for (int j = i; j >= 0 && i - j + 1 <= maxLen; j--) {
h = (h * HASH_CONST + s[j]) % HASH_BASE;
if ((j == 0 || f[j - 1] != -1) &&
exist[i - j + 1].find(h) != exist[i - j + 1].end()) {
f[i] = exist[i - j + 1][h];
break;
}
}
}
vector<int> ans;
for (int i = n - 1; i >= 0; i = i - (int)a[f[i]].size()) ans.push_back(f[i]);
for (int i = (int)ans.size() - 1; i >= 0; i--) cout << a[ans[i]] << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 12, maxV = 1201, maxQ = 500000;
int cnt[1 << maxN], val[1 << maxN], w[maxN];
vector<pair<int, int> > qs[1 << maxN];
int n, T[maxV], res[maxQ];
int getint(char* in) {
int res = 0;
for (int(i) = (0); (i) < (n); (i)++)
if (in[i] == '1') res |= 1 << i;
return res;
}
int main() {
int m, q;
scanf("%d%d%d", &n, &m, &q);
for (int(i) = (0); (i) < (n); (i)++) scanf("%d", w + i);
for (int(i) = (1); (i) < (1 << n); (i)++) {
int j = __builtin_ctz(i);
val[i] = val[i ^ 1 << j] + w[j];
}
while (m--) {
char in[13];
scanf("%s", in);
cnt[getint(in)]++;
}
for (int(i) = (0); (i) < (q); (i)++) {
char in[13];
scanf("%s", in);
int k;
scanf("%d", &k);
qs[getint(in)].push_back(make_pair(k, i));
}
int g = (1 << n) - 1;
for (int(i) = (0); (i) < (1 << n); (i)++) {
for (int(j) = (0); (j) < (1 << n); (j)++) {
int v = ~(i ^ j) & g;
T[val[v]] += cnt[j];
}
sort((qs[i]).begin(), (qs[i]).end());
int j = -1, cnt = 0;
for (pair<int, int> p : qs[i]) {
while (j < p.first) cnt += T[++j];
res[p.second] = cnt;
}
fill(T, T + maxV, 0);
}
for (int(i) = (0); (i) < (q); (i)++) printf("%d\n", res[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N, K, t;
cin >> t;
for (long i = 0; i < t; i++) {
cin >> N >> K;
long long Res = 0;
if (N % K != 0) {
Res += N % K;
N -= N % K;
}
while (N > 0) {
N /= K;
Res++;
if (N % K != 0) {
Res += N % K;
N -= N % K;
}
}
cout << Res << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[2000010];
int Map[300010];
long long e[25], ans = 0;
void f(int val, int pot = 18, int i = 0) {
while (true) {
dp[i]++;
if (pot < 0) break;
if (val & (1 << pot)) {
i = i * 2 + 1;
pot--;
} else {
i = i * 2 + 2;
pot--;
}
}
}
void g(long long val, long long x, long long num = 0, int pot = 18, int i = 0) {
while (true) {
if (pot < 0) {
ans += dp[i];
break;
}
long long temp = num + e[pot];
if (val & (1 << pot)) {
if (x < temp) {
i = i * 2 + 1;
pot--;
} else {
ans += dp[i * 2 + 1];
i = i * 2 + 2;
num = temp;
pot--;
}
continue;
} else {
if (x < temp) {
pot--;
i = i * 2 + 2;
} else {
ans += dp[i * 2 + 2];
i = i * 2 + 1;
num = temp;
pot--;
}
}
}
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
long long n, q;
e[0] = 1;
for (int i = 1; i <= 20; i++) {
e[i] = 2LL * e[i - 1];
}
cin >> n >> q;
while (n--) {
long long aux;
cin >> aux;
if (Map[aux] == 0) f(aux);
Map[aux] = 1;
}
long long temp = 0;
while (q--) {
long long u;
cin >> u;
temp ^= u;
if (Map[temp] == 0) {
cout << 0 << "\n";
continue;
}
long long ini = 1, fin = e[19] - 1, aux;
while (ini <= fin) {
long long mid = (ini + fin) >> 1;
ans = 0;
g(temp, mid);
if (ans < mid + 1) {
aux = mid;
fin = mid - 1;
} else {
ini = mid + 1;
}
}
cout << aux << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int INF = 1e9 + 7;
long long LLINF = 1e18;
long long MOD = 1e9 + 7;
ostream& operator<<(ostream& out, vector<int>& v) {
for (int num : v) out << num << ' ';
return out;
}
ostream& operator<<(ostream& out, vector<long long>& v) {
for (long long num : v) out << num << ' ';
return out;
}
istream& operator>>(istream& in, vector<int>& v) {
for (int i = 0; i < v.size(); i++) in >> v[i];
return in;
}
istream& operator>>(istream& in, vector<long long>& v) {
for (int i = 0; i < v.size(); i++) in >> v[i];
return in;
}
struct eu_st {
long long x, y, gcd;
};
eu_st euex(int a, int b) {
if (a > b) swap(a, b);
if (a == 0) return {0, 1, b};
eu_st nxt = euex(b % a, a);
return {nxt.y - b / a * nxt.x, nxt.x, nxt.gcd};
}
long long binpow(unsigned long long a, unsigned long long pow,
unsigned long long mod) {
unsigned long long cur = a;
unsigned long long ans = 1;
for (; pow > 0; pow >>= 1) {
if (pow & 1) ans *= cur;
ans %= mod;
cur *= cur;
cur %= mod;
}
return ans;
}
vector<int> lp;
vector<int> pr;
void erat(int n) {
lp = vector<int>(n + 1, 0);
for (int i = 2; i <= n; i++) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back(i);
}
for (int j = 0; j < pr.size() && pr[j] * i <= n && pr[j] <= lp[i]; j++)
lp[i * pr[j]] = pr[j];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long a, b, c, d;
cin >> a >> b >> c >> d;
if (a > b * c) {
cout << "-1\n";
continue;
}
long long k = a / (b * d);
cout << a * (k + 1) - b * d * k * (k + 1) / 2 << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int times(string s, string g) {
long long int occurrences = 0;
long long int pos = 0;
while ((pos = s.find(g, pos)) != string::npos) {
++occurrences;
pos += g.length();
}
return occurrences;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, i, maxm = INT_MIN, k = 0, z = 0, sum = 0, y = 0, x = 0,
flag = 0, maxm1 = INT_MIN, l = 0, r = 0, cnt = 0, j = 0,
minm = INT_MAX, minm2 = INT_MAX, sum1 = 0, cnt1 = 0,
cnt2 = 0, u = 0, d = 0;
string s;
cin >> s;
string f = "AB";
string p = "BA";
unordered_map<char, long long int> m;
for (i = 0; i < s.length(); i++) {
m[s[i]]++;
}
if (m['A'] >= 2 && m['B'] >= 2) {
if ((s.find(f) != string::npos) && (s.find(p) != string::npos)) {
if (times(s, f) == 1 && times(s, p) == 1) {
x = s.find(f);
y = s.find(p);
if (abs(x - y) == 1)
cout << "NO" << endl;
else
cout << "YES" << endl;
} else {
if (times(s, f) == 2 && times(s, p) == 1) {
x = s.find(f);
y = s.find(f, x + 1);
z = s.find(p);
if (abs(x - z) == 1 && abs(x - y) == 2)
cout << "NO" << endl;
else
cout << "YES" << endl;
} else if (times(s, f) == 1 && times(s, p) == 2) {
x = s.find(p);
y = s.find(p, x + 1);
z = s.find(f);
if (abs(x - z) == 1 && abs(x - y) == 2)
cout << "NO" << endl;
else
cout << "YES" << endl;
} else
cout << "YES" << endl;
}
} else
cout << "NO" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> m;
int main() {
int n;
scanf("%d ", &n);
m["void"] = 1;
for (int i = 0; i < n; i++) {
char a[40], b[40], amp[40], ast[40], nome[40];
amp[0] = ast[0] = nome[0] = 0;
int k;
scanf("type");
if (scanf("def %s %s ", &a, &b) > 0) {
sscanf(a, "%[&]", &);
k = strlen(amp);
sscanf(a + k, "%[^*]%[*]", &nome, &ast);
int x = m[nome];
if (x > 0) x += strlen(ast);
if (x > strlen(amp))
x -= strlen(amp);
else
x = 0;
m[b] = x;
} else {
scanf("of %s ", &a);
sscanf(a, "%[&]", &);
k = strlen(amp);
sscanf(a + k, "%[^*]%[*]", &nome, &ast);
int x = m[nome];
if (x > 0) x += strlen(ast);
if (x > strlen(amp))
x -= strlen(amp);
else
x = 0;
if (x == 0)
printf("errtype\n");
else {
printf("void");
for (int i = 0; i < x - 1; i++) printf("*");
printf("\n");
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t;
int main() {
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
if (b < a) swap(a, b);
int x = b - a;
int sum = 0;
for (int i = 10; i >= 1; --i) {
if (x >= i) {
sum += x / i;
x %= i;
}
}
printf("%d\n", sum);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXP = 50, LOG = 13;
const long long MOD = 1e9 + 7;
int K;
int ZZ, MZ;
int Z[MAXP];
bool D;
long long N, H;
long long S[MAXP];
long long P[MAXP];
long long R[2][MAXP][MAXP];
void brute(int id, long long now) {
if (id == ZZ) {
H += now;
if (H >= MOD) H -= MOD;
return;
}
for (int i = 0; i <= Z[id]; i++) {
brute(id + 1, now * R[D][Z[id]][i] % MOD);
now = now * P[id] % MOD;
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> K;
for (long long i = 2; i * i <= N; i++) {
if (N % i == 0) {
P[ZZ] = i;
while (N % i == 0) {
N /= i;
Z[ZZ]++;
}
MZ = max(MZ, Z[ZZ]);
ZZ++;
}
}
if (N > 1) {
P[ZZ] = N % MOD;
Z[ZZ] = 1;
MZ = max(MZ, Z[ZZ]);
ZZ++;
}
S[0] = 1;
R[0][0][0] = 1;
for (int i = 1; i <= MZ; i++) {
S[i] = (MOD - MOD / (i + 1)) * S[MOD % (i + 1) - 1] % MOD;
R[0][i][i] = 1;
}
for (int i = LOG; i >= 0; i--) {
if (K >> (i + 1)) {
for (int j = 0; j <= MZ; j++) {
for (int k = 0; k <= j; k++) {
R[!D][j][k] = 0;
for (int l = k; l <= j; l++) {
R[!D][j][k] += R[D][j][l] * R[D][l][k];
R[!D][j][k] %= MOD;
}
}
}
D = !D;
}
if ((K >> i) & 1) {
for (int j = 0; j <= MZ; j++) {
for (int k = 0; k <= j; k++) {
R[!D][j][k] = 0;
for (int l = k; l <= j; l++) {
R[!D][j][k] += R[D][j][l] * S[l];
R[!D][j][k] %= MOD;
}
}
}
D = !D;
}
}
brute(0, 1);
cout << H << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long cnt1, cnt2, x, y;
bool valid(long long mid) {
long long equ1 = mid - (mid / x);
long long equ2 = mid - (mid / y);
long long equ3 = mid - (mid / (x * y));
return equ1 >= cnt1 && equ2 >= cnt2 && equ3 >= cnt1 + cnt2;
}
int main() {
cin >> cnt1 >> cnt2 >> x >> y;
long long start = 0, end = 1e18;
while (start < end) {
long long mid = (start + end) / 2;
if (valid(mid)) {
end = mid;
} else
start = mid + 1;
}
cout << start << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Str {
vector<int64_t> h, d;
const int64_t P = 31, MOD = 1e9 + 7;
int64_t md(int64_t a) { return (a + MOD) % MOD; }
Str() {}
Str(string str) {
h.resize(str.size() + 1);
d.resize(str.size() + 1);
d[0] = 1;
for (int64_t i = 0; i < str.size(); ++i) {
h[i + 1] = md(h[i] * P + str[i] - 'a' + 1);
d[i + 1] = md(d[i] * P);
}
}
int64_t hsh(int64_t l, int64_t r) {
return md(h[r + 1] - md(h[l] * d[r - l + 1]));
}
};
bool ch(int64_t &o, int64_t hsh) {
if (o == -1) {
o = hsh;
return true;
}
return (hsh == o);
}
int32_t main() {
ios_base::sync_with_stdio(false);
string a, b;
cin >> a >> b;
int64_t A = 0, B = 0, ans = 0;
for (int64_t i = 0; i < a.size(); ++i) {
if (a[i] == '0')
++A;
else
++B;
}
Str str = Str(b);
for (int64_t i = 1; i <= b.size(); ++i) {
if (i * A >= b.size()) break;
int64_t j = b.size() - i * A;
if (j % B) continue;
j /= B;
int64_t tec = 0;
int64_t o1 = -1, o2 = -1;
bool b = true;
for (int64_t t = 0; t < a.size(); ++t) {
if (a[t] == '0') {
b &= ch(o1, str.hsh(tec, tec + i - 1));
tec += i;
} else {
b &= ch(o2, str.hsh(tec, tec + j - 1));
tec += j;
}
};
if (b && o1 != o2) ++ans;
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, x, y, z, b = 0, c, d;
cin >> a;
for (x = 2; x < a; x++)
for (z = a; z; b += z % x, z /= x)
;
for (x = b, y = a - 2; z = x % y; x = y, y = z)
;
c = b / y;
d = ((a - 2) / y);
cout << c << "/" << d;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
if (n == 1) cout << "0" << endl;
if (n == 2) cout << m << endl;
if (n > 2) cout << 2 * m << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int M = 2e5 + 5;
int f[N];
int fa(int x) { return x == f[x] ? f[x] : f[x] = fa(f[x]); }
bool Merge(int u, int v) {
u = fa(u);
v = fa(v);
if (u == v) return false;
f[u] = v;
return true;
}
struct Node {
int u, v, w, c, idx;
bool operator<(const Node &rhs) const { return w < rhs.w; }
} E[M];
struct node {
int e, next, w;
} edge[N << 1];
int tot;
int first[N];
void init(int n) {
tot = 0;
for (int i = 0; i <= n; i++) first[i] = -1, f[i] = i;
}
void add(int u, int v, int w) {
edge[tot] = (node){v, first[u], w};
first[u] = tot++;
}
const int LOG = 18;
int par[N][LOG], dep[N], UP[N], mx[N][LOG];
void dfs(int u, int fa, int depth) {
dep[u] = depth;
if (u == 1) {
for (int i = 0; i < LOG; i++) par[u][i] = 1, mx[u][i] = 0;
} else {
par[u][0] = fa;
mx[u][0] = UP[u];
for (int i = 1; i < LOG; i++)
par[u][i] = par[par[u][i - 1]][i - 1],
mx[u][i] = max(mx[u][i - 1], mx[par[u][i - 1]][i - 1]);
}
for (int i = first[u]; i != -1; i = edge[i].next) {
int v = edge[i].e;
if (v == fa) continue;
UP[v] = edge[i].w;
dfs(v, u, depth + 1);
}
}
int up(int &x, int step) {
int mxv = 0;
for (int i = 0; i < LOG; i++)
if (step & (1 << i)) mxv = max(mxv, mx[x][i]), x = par[x][i];
return mxv;
}
int get_mx(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
int mxv = up(u, dep[u] - dep[v]);
if (u == v) return mxv;
for (int i = LOG - 1; i >= 0; i--) {
if (par[u][i] != par[v][i]) {
mxv = max(mxv, mx[u][i]);
mxv = max(mxv, mx[v][i]);
u = par[u][i];
v = par[v][i];
}
}
return max(mxv, max(mx[u][0], mx[v][0]));
}
int n, m, S;
int used[M];
int main() {
scanf("%d%d", &n, &m);
init(n);
for (int i = 1; i <= m; i++) scanf("%d", &E[i].w), E[i].idx = i;
for (int i = 1; i <= m; i++) scanf("%d", &E[i].c);
for (int i = 1; i <= m; i++) scanf("%d%d", &E[i].u, &E[i].v);
scanf("%d", &S);
sort(E + 1, E + 1 + m);
long long sum = 0;
for (int i = 1; i <= m; i++)
if (Merge(E[i].u, E[i].v)) {
sum += E[i].w;
used[i] = 1;
add(E[i].u, E[i].v, E[i].w);
add(E[i].v, E[i].u, E[i].w);
}
dfs(1, -1, 1);
int best = -1;
long long bsum = sum;
for (int i = 1; i <= m; i++) {
if (used[i]) {
long long nsum = sum - S / E[i].c;
if (bsum > nsum) {
best = i;
bsum = nsum;
}
} else {
long long nsum = sum - get_mx(E[i].u, E[i].v) + E[i].w - S / E[i].c;
if (bsum > nsum) {
best = i;
bsum = nsum;
}
}
}
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= m; i++) used[i] = 0;
Merge(E[best].u, E[best].v);
used[best] = 1;
for (int i = 1; i <= m; i++)
if (Merge(E[i].u, E[i].v)) used[i] = 1;
printf("%I64d\n", bsum);
for (int i = 1; i <= m; i++)
if (used[i]) {
if (i == best)
printf("%d %d\n", E[i].idx, E[i].w - S / E[i].c);
else
printf("%d %d\n", E[i].idx, E[i].w);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
double start_moment = 0;
double get_runtime() { return 1.0 * clock() / CLOCKS_PER_SEC; }
void reset_timer() { start_moment = get_runtime(); }
double timer_time() { return get_runtime() - start_moment; }
void runtime() { cout << fixed << setprecision(5) << get_runtime() << endl; }
template <class T>
void read(vector<T> &a, int n) {
T x;
a.clear();
for (int i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
}
template <class T>
void write(vector<T> &a) {
for (T x : a) cout << x << ' ';
cout << '\n';
}
const int N = 2003;
const int INF = 1000000000;
int T, len;
string second, t;
int cnt1[26], cnt2[26];
int have_s[26][N];
int have_t[26][N];
int get(int *have, int x) { return have[x]; }
int get(int *have, int l, int r) { return get(have, r) - get(have, l - 1); }
int dp[N][N];
int go(int x, int y) {
if (dp[x][y] != INF) return dp[x][y];
if (second[x - 1] == t[y - 1]) dp[x][y] = min(dp[x][y], go(x - 1, y - 1));
dp[x][y] = min(dp[x][y], go(x - 1, y) + 1);
char c = t[y - 1];
if (get(have_s[c - 'a'], x, len) > get(have_t[c - 'a'], y, len))
dp[x][y] = min(dp[x][y], go(x, y - 1));
return dp[x][y];
}
int main() {
ios_base::sync_with_stdio(0);
cin >> T;
while (T--) {
memset(cnt1, 0, sizeof(cnt1));
memset(cnt2, 0, sizeof(cnt2));
cin >> len;
cin >> second >> t;
for (char c : second) cnt1[c - 'a']++;
for (char c : t) cnt2[c - 'a']++;
bool bad = 0;
for (int i = 0; i < 26; i++)
if (cnt1[i] != cnt2[i]) bad = 1;
if (bad) {
cout << -1 << '\n';
continue;
;
}
for (int i = 0; i <= len; i++)
for (int j = 0; j <= len; j++) dp[i][j] = INF;
for (int i = 0; i <= len; i++)
for (int j = 0; j < 26; j++) {
have_t[j][i] = 0;
have_s[j][i] = 0;
}
for (char c = 'a'; c <= 'z'; c++) {
for (int i = 0; i < len; i++) {
have_s[c - 'a'][i] = (c == second[i]);
have_t[c - 'a'][i] = (c == t[i]);
}
for (int i = 1; i < len; i++) {
have_s[c - 'a'][i] += have_s[c - 'a'][i - 1];
have_t[c - 'a'][i] += have_t[c - 'a'][i - 1];
}
}
for (int i = 0; i <= len; i++) dp[0][i] = 0;
cout << go(len, len) << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
cout << n << "\n";
for (int i = 1; i <= n; i++) cout << i << " \n"[i == n];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int mas[2000007];
int w;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &w);
mas[w]++;
}
int res = 0;
for (int i = 0; i <= 1001000; i++) {
mas[i + 1] += mas[i] / 2;
mas[i] = mas[i] % 2;
if (mas[i] == 1) res++;
}
printf("%d", res);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
char sn[1000010][110];
int ln[1000010];
bool mp[26][26];
int in[26];
int q[26], l, r;
bool visit[26];
char an[26];
int main() {
int z;
int n, m;
int i, j, k;
cin >> n >> k;
memset(visit, 0, sizeof(visit));
memset(ln, 0, sizeof(ln));
memset(mp, 0, sizeof(mp));
memset(in, 0, sizeof(in));
for (i = 0; i < n; i++) {
int p;
scanf("%d", &p);
for (int ii = 0; ii < k; ii++) {
int id = p * k + ii;
scanf("%s", sn[id]);
ln[id] = strlen(sn[id]);
for (j = 0; j < ln[id]; j++) {
visit[sn[id][j] - 'a'] = 1;
}
}
}
bool ok = 1;
for (i = 1; i < n * k; i++) {
for (j = 0; j < min(ln[i - 1], ln[i]); j++) {
if (sn[i][j] != sn[i - 1][j]) {
char a = sn[i - 1][j] - 'a';
char b = sn[i][j] - 'a';
if (!mp[a][b]) {
mp[a][b] = 1;
in[b]++;
}
break;
}
}
if (j == ln[i] && ln[i - 1] > ln[i]) {
ok = 0;
break;
}
}
int num = 0;
int sum = 0;
if (ok) {
l = r = 0;
for (i = 0; i < 26; i++) {
if (visit[i]) {
sum++;
if (in[i] == 0) q[r++] = i;
}
}
while (l < r) {
int k = q[l++];
an[num++] = k;
for (i = 0; i < 26; i++) {
if (mp[k][i]) {
in[i]--;
if (in[i] == 0) {
q[r++] = i;
}
}
}
}
ok = (num == sum);
}
if (ok) {
for (i = 0; i < num; i++) cout << char(an[i] + 'a');
cout << endl;
} else
cout << "IMPOSSIBLE" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acosl(-1.0);
const double EPS = 1e-12;
void showBit(int no, int N) {
for (int i = N - 1; i >= 0; i--)
if ((no >> i) & 1)
printf("1");
else
printf("0");
printf("\n");
}
int binToDec(string s) {
int ln = s.length();
int sum = 0;
for (int i = ln - 1, k = 0; i >= 0; i--, k++)
sum = sum + (s[i] - '0') * (1 << k);
return sum;
}
void combination(long long com[][1005]) {
com[0][0] = 1;
int sz = 1000;
for (int i = 1; i <= sz; i++) {
com[i][0] = 1;
for (int j = 1; j <= i; j++) {
com[i][j] = com[i - 1][j] + com[i - 1][j - 1];
com[i][j] = com[i][j] % 1000000007;
}
}
}
int find_par(int cn) {}
int gcd(int u, int v) {
if (v == 0) return u;
return gcd(v, u % v);
}
void insert_ind(int cs, int ci, int s, int e) {
if (s == e) {
return;
}
int mid = (s + e) / 2;
if (ci <= mid)
insert_ind(2 * cs, ci, s, mid);
else
insert_ind(2 * cs + 1, ci, mid + 1, e);
}
void update_ind(int cs, int ci, int s, int e, int val) {
if (s == e) {
return;
}
int mid = (s + e) / 2;
if (ci <= mid)
update_ind(2 * cs, ci, s, mid, val);
else
update_ind(2 * cs + 1, ci, mid + 1, e, val);
}
void update_seg(int cs, int ds, int de, int s, int e, int val) {
if (ds == s && de == e) {
return;
}
int mid = (s + e) / 2;
if (ds <= mid) update_seg(2 * cs, ds, min(mid, de), s, mid, val);
if (de > mid) update_seg(2 * cs + 1, max(mid + 1, ds), de, mid + 1, e, val);
}
void pattern_match(char pat[], const int len, int pi[]) {
pi[1] = 0;
for (int i = 2; i <= len; i++) {
int st = i - 1;
while (st >= 0 && pat[pi[st] + 1] != pat[i]) st = pi[st];
if (st == 0)
pi[i] = 0;
else
pi[i] = pi[st] + 1;
}
}
void pattern_match(char pat[], int pi[], char tar[], const int len1, int gi[]) {
if (pat[0] == tar[0]) gi[0] = 1;
for (int i = 1; i < len1; i++) {
int st = gi[i - 1];
while (pat[st] != tar[i]) {
if (st == 0) {
st = -1;
break;
}
st = pi[st - 1];
}
if (st == -1)
gi[i] = 0;
else
gi[i] = st + 1;
}
}
struct myArray {
int mat[10][10];
};
myArray matrix_mul(myArray mat1, myArray mat2, const int sz) {
int tmp[sz][sz];
memset((tmp), 0, sizeof((tmp)));
for (int r = 0; r < sz; r++)
for (int c = 0; c < sz; c++)
for (int cr = 0; cr < sz; cr++)
tmp[r][c] += mat1.mat[r][cr] * mat2.mat[c][cr];
myArray res;
for (int r = 0; r < sz; r++)
for (int c = 0; c < sz; c++) res.mat[r][c] = tmp[r][c];
return res;
}
myArray unit_matrix(const int sz) {
myArray ma;
memset((ma.mat), 0, sizeof((ma.mat)));
for (int i = 0; i < sz; i++) ma.mat[i][i] = 1;
return ma;
}
myArray matrix_expo(int p, myArray mat, const int sz) {
if (p == 0) {
return unit_matrix(sz);
}
if (p & 1) return matrix_mul(mat, matrix_expo(p - 1, mat, sz), sz);
myArray tmp = matrix_expo(p >> 1, mat, sz);
return matrix_mul(tmp, tmp, sz);
}
int X[] = {0, 0, 1, -1};
int Y[] = {1, -1, 0, 0};
map<string, int> msi;
void cal_state(string s, int tran[][30]) {
int ln = s.length();
string s1 = s;
for (int i = 0; i < ln; i++) {
msi[s1] = ln - i;
s1 = s1.substr(0, ln - i - 1);
}
s1 = "";
for (int i = 0; i <= ln; i++) {
string ts = s1;
for (int j = 0; j < 26; j++) {
s1 = ts + (char)('a' + j);
int tln = i + 1;
while (msi[s1] == 0) {
s1 = s1.substr(1);
tln--;
if (tln == 0) break;
}
if (tln == 0) s1 = "";
tran[i][j] = msi[s1];
}
if (i < ln) s1 = s.substr(0, i + 1);
}
}
string s, b;
int tran[105][30];
int n, k;
bool col[105];
bool dp[105][105][105];
int c[105][105][105], ps[105][105][105];
int prp[105][105][105];
void print(int ln, int cs, int rp) {
if (ln == 0) return;
print(ln - 1, ps[ln][cs][rp], prp[ln][cs][rp]);
printf("%c", 'a' + c[ln][cs][rp]);
}
int main() {
cin >> n >> k;
cin >> s;
cal_state(s, tran);
cin >> b;
int ln = b.length();
int cnt = 0;
for (int i = (0); i < (ln); ++i)
if (b[i] == '1') col[i] = true, cnt++;
dp[0][0][0] = true;
ln = s.length();
for (int i = 0; i < n; i++)
for (int j = 0; j <= n; j++)
for (int rp = 0; rp <= cnt; rp++)
if (dp[i][j][rp]) {
for (int ne = 0; ne < k; ne++) {
int ns = tran[j][ne];
if (ns == ln) {
if (col[i - ln + 1] && rp + 1 <= cnt) {
dp[i + 1][ns][rp + 1] = true;
c[i + 1][ns][rp + 1] = ne;
ps[i + 1][ns][rp + 1] = j;
prp[i + 1][ns][rp + 1] = rp;
}
} else {
dp[i + 1][ns][rp] = true;
c[i + 1][ns][rp] = ne;
ps[i + 1][ns][rp] = j;
prp[i + 1][ns][rp] = rp;
}
}
}
for (int i = 0; i <= n; i++)
if (dp[n][i][cnt] == true) {
print(n, i, cnt);
printf("\n");
return 0;
}
printf("No solution\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
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 << "]";
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
bool sortm(pair<int, int> &a, pair<int, int> &b) {
int x = abs(a.first) + abs(a.second);
int y = abs(b.first) + abs(b.second);
return x < y;
}
void init() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int n, k;
int dp[2011][2011];
int a[2011];
int calc(int i, int j) {
if (j < 0) {
return -1e8;
}
if (i == -1) {
if (j == 0) return 0;
return -1e8;
}
int &ans = dp[i][j];
if (ans != -1) {
return ans;
}
ans = (j == a[i]) + calc(i - 1, j);
ans = max(ans, calc(i - 1, j - 1));
return ans;
}
void solve() {
cin >> n >> k;
for (int i = 0; i < n + 10; i++) {
for (int j = 0; j < n + 10; j++) {
dp[i][j] = -1;
}
}
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] = i - a[i] + 1;
}
for (int i = 0; i <= n; i++) {
if (calc(n - 1, i) >= k) {
cout << i << "\n";
return;
}
}
cout << -1 << "\n";
}
int main() {
init();
int t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void add(const string& s, vector<vector<int>>& trie, int depth = 0,
int curr = 0) {
if (s.size() == depth) {
++trie[curr].back();
return;
}
if (trie[curr][s[depth] - 'a'] == -1) {
trie.push_back(vector<int>(27, -1));
trie.back().back() = 0;
trie[curr][s[depth] - 'a'] = (int)trie.size() - 1;
}
add(s, trie, depth + 1, trie[curr][s[depth] - 'a']);
}
void dfs(int curr, const vector<vector<int>>& trie, vector<int>& dp,
vector<set<pair<int, int>>>& vert, int depth = 0) {
int max_s = 0;
int ind = -1;
for (int i = 0; i < 26; ++i) {
if (trie[curr][i] != -1) {
dfs(trie[curr][i], trie, dp, vert, depth + 1);
dp[curr] += dp[trie[curr][i]];
if (vert[trie[curr][i]].size() > max_s) {
ind = trie[curr][i];
max_s = vert[trie[curr][i]].size();
}
}
}
if (ind != -1) {
swap(vert[curr], vert[ind]);
}
if (trie[curr].back() > 0) {
vert[curr].insert({-depth, curr});
}
for (int i = 0; i < 26; ++i) {
if (trie[curr][i] != -1 && trie[curr][i] != ind) {
for (const auto& a : vert[trie[curr][i]]) {
vert[curr].insert(a);
}
}
}
if (trie[curr].back() > 0) {
dp[curr] += depth;
} else if (curr != 0 && !vert[curr].empty()) {
dp[curr] -= -vert[curr].begin()->first - depth;
auto cc = *vert[curr].begin();
vert[curr].erase(vert[curr].begin());
vert[curr].insert({-depth, cc.second});
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<vector<int>> trie;
trie.push_back(vector<int>(27, -1));
trie.back().back() = 0;
string buff;
for (int i = 0; i < n; ++i) {
cin >> buff;
add(buff, trie);
}
vector<int> dp(trie.size(), 0);
vector<set<pair<int, int>>> vert(trie.size());
dfs(0, trie, dp, vert);
cout << dp[0] << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
const int maxn = 500005;
const int maxm = 1000005;
long long dp[40][40];
void solve() {
int n, h;
scanf("%d %d", &n, &h);
memset(dp, 0, sizeof(dp));
for (int i = 0; i <= n; i++) dp[0][i] = 0;
for (int i = 0; i <= n; i++) dp[i][0] = 1;
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
dp[k][i] = 0;
for (int j = 0; j < i; j++) {
dp[k][i] += dp[k - 1][j] * dp[k - 1][i - j - 1];
}
}
}
printf("%I64d\n", dp[n][n] - dp[h - 1][n]);
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
long long int n, m, a[N], l[N], r[N];
bool ok(long long int x) {
for (int i = 0; i < n; i++) {
l[i] = a[i];
r[i] = (a[i] + x) % m;
}
long long int prev = 0;
for (int i = 0; i < n; i++) {
if (r[i] >= l[i]) {
if (prev > r[i]) {
return false;
}
prev = max(prev, l[i]);
} else {
if (prev > r[i]) {
prev = max(prev, l[i]);
}
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long int ans = 0, low = 0, high = m - 1;
while (low < high) {
long long int mid = (low + high) / 2;
if (ok(mid)) {
high = mid;
} else {
low = mid + 1;
}
}
ans = low;
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
long long ans = 0;
long long a[501][501] = {0};
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
ans += a[i][j];
}
}
for (int i = n - 1; i >= 2; i--) {
for (int j = m - 1; j >= 2; j--) {
if (a[i][j] == 0) {
a[i][j] = min(a[i + 1][j], a[i][j + 1]) - 1;
ans += a[i][j];
}
}
}
for (int i = 1; i <= n - 1; i++) {
for (int j = 1; j <= m - 1; j++) {
if (a[i][j] >= a[i + 1][j] || a[i][j] >= a[i][j + 1]) {
cout << -1;
return 0;
}
}
}
for (int i = 1; i < n; i++) {
if (a[i][m] >= a[i + 1][m]) {
cout << -1;
return 0;
}
}
for (int i = 1; i < m; i++) {
if (a[n][i] >= a[n][i + 1]) {
cout << -1;
return 0;
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(false);
int n;
std::string level;
std::cin >> n;
std::cin >> level;
bool hole_jump = false;
for (int i = 0; i < n && !hole_jump; i++) {
if ('.' == level[i]) {
continue;
}
const size_t next_space_index = level.find('.', i + 1);
if (std::string::npos == next_space_index) {
continue;
}
const size_t next_platform_index = level.find('*', next_space_index + 1);
if (std::string::npos == next_platform_index) {
break;
}
for (int p = next_platform_index; p < n && !hole_jump; p++) {
if ('.' == level[p]) {
continue;
}
int jump_counter = 0;
const size_t step = p - i;
for (int j = i; j < n; j += step) {
if (level[j] == '*') {
jump_counter++;
} else {
break;
}
if (jump_counter > 4) {
hole_jump = true;
break;
}
}
}
}
done:
bool full_level = level.find("*****") != std::string::npos;
if (hole_jump || full_level) {
std::cout << "yes" << std::endl;
} else {
std::cout << "no" << std::endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int a[1010][1010];
bool visited[1010][1010];
int d[1010][1010];
vector<pair<int, vector<pair<int, int> > > > connected_components;
void reset(int n, int m) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
visited[i][j] = false;
d[i][j] = -1;
}
}
void bfsgrid(pair<int, int> s, int n, int m) {
vector<pair<int, int> > temp;
visited[s.first][s.second] = true;
d[s.first][s.second] = 0;
queue<pair<int, int> > q;
q.push(s);
while (!q.empty()) {
pair<int, int> t = q.front();
temp.push_back(t);
q.pop();
for (int i = 0; i < 4; i++) {
pair<int, int> temp = {t.first + dx[i], t.second + dy[i]};
if (temp.first >= 0 && temp.second >= 0 && temp.first < n &&
temp.second < m && a[temp.first][temp.second] == 1 &&
!visited[temp.first][temp.second]) {
q.push(temp);
visited[temp.first][temp.second] = 1;
d[temp.first][temp.second] = d[t.first][t.second] + 1;
}
}
}
bool f = 1;
for (int i = 0; i < temp.size(); i++) {
if (temp[i].first == 0 || temp[i].second == 0 || temp[i].first == n - 1 ||
temp[i].second == m - 1) {
f = 0;
break;
}
}
if (f) connected_components.push_back({temp.size(), temp});
}
int main() {
int t = 1;
while (t--) {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char c;
cin >> c;
if (c == '.')
a[i][j] = 1;
else
a[i][j] = 0;
}
reset(n, m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j])
if (!visited[i][j]) bfsgrid({i, j}, n, m);
int nn = connected_components.size();
sort(connected_components.begin(), connected_components.end());
int ans = 0;
if (k < nn) {
for (int i = 0; i < nn - k; i++) {
vector<pair<int, int> > temp = connected_components[i].second;
ans += temp.size();
for (int j = 0; j < temp.size(); j++)
a[temp[j].first][temp[j].second] = 0;
}
}
cout << ans << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j])
cout << ".";
else
cout << "*";
}
cout << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool Max(T1& a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <typename T1, typename T2>
bool Min(T1& a, T2 b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T gcd_ext(T a, T b, T& x, T& y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
T g = gcd_ext(b, a % b, y, x);
y -= (a / b) * x;
return g;
}
const int N = 200001;
long long ans[N];
void solve() {
long long T, n;
cin >> T >> n;
long long per = 0;
map<long long, long long> m;
m[0] = 0;
cin >> per;
long long loc = 0;
for (int i = 1; i <= (n - 1); ++i) {
long long a;
cin >> a;
per += a;
loc = (loc + a) % T;
m.emplace(loc, i);
}
long long perinv, Tinv;
long long g = gcd_ext(per, T, perinv, Tinv);
per /= g;
T /= g;
map<long long, vector<pair<long long, long long>>> mv;
for (auto& e : m) {
mv[e.first % g].emplace_back(perinv * (e.first / g) % T, e.second);
}
for (auto& e : mv) {
auto& vec = e.second;
sort(vec.begin(), vec.end());
vec.emplace_back(vec[0].first + T, 0);
long long sz = vec.size() - 1;
for (int i = 0; i < (sz); ++i)
ans[vec[i].second] = vec[i + 1].first - vec[i].first;
}
for (int i = 0; i < (n); ++i) cout << ans[i] << ' ';
cout << '\n';
}
void init() {}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
init();
int TC = 1;
for (int TI = 1; TI <= (TC); ++TI) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005, INF = 2000000000000000000;
long long power(long long a, long long b, long long p) {
if (a == 0) return 0;
long long res = 1;
a %= p;
while (b > 0) {
if (b & 1) res = (res * a) % p;
b >>= 1;
a = (a * a) % p;
}
return res;
}
bool prime[N] = {true};
long long sum[N] = {0};
void pre() {
memset(prime, true, sizeof(prime));
for (long long i = 2; i <= N; i++) {
if (prime[i]) {
for (long long j = i * i; j <= N; j += i) {
prime[j] = false;
}
}
}
for (long long i = 2; i < N; i++) {
if (prime[i]) sum[i] += i;
sum[i + 1] = sum[i];
}
return;
}
class yup {
public:
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
};
long long minCoins(long long coins[], long long m, long long V) {
if (V == 0) return 0;
long long res = INT_MAX;
for (long long i = 0; i < m; i++) {
if (coins[i] <= V) {
long long sub_res = minCoins(coins, m, V - coins[i]);
if (sub_res != INT_MAX && sub_res + 1 < res) res = sub_res + 1;
}
}
return res;
}
double cotan(double i) { return (1 / tan(i)); }
int32_t main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, m;
cin >> n >> m;
char yo[n][m], yup[m][n];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> yo[i][j];
yup[j][i] = yo[i][j];
}
}
long long mar[m];
for (long long i = 0; i < m; i++) {
cin >> mar[i];
}
long long ans = 0;
for (long long i = 0; i < m; i++) {
long long fr[26];
memset(fr, 0, sizeof(fr));
for (long long j = 0; j < n; j++) {
fr[(long long)(yup[i][j]) - (long long)('A')]++;
}
sort(fr, fr + 26, greater<long long>());
ans += mar[i] * fr[0];
}
cout << ans << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)2e5 + 22;
const long long INF = (long long)1e9 + 47;
int to[MAXN];
int N;
bool used[MAXN];
int boy[MAXN], girl[MAXN];
int cc[MAXN];
void go(int v, int color = 0) {
used[v] = 1;
cc[v] = color;
int u = to[v];
if (!used[u])
go(u, color ^ 1);
else if (!used[v ^ 1])
go(v ^ 1, color ^ 1);
}
void solve() {
cin >> N;
for (int i = 0; i < N; i++) {
int x, y;
cin >> x >> y;
--x, --y;
to[x] = y;
to[y] = x;
boy[i] = x;
girl[i] = y;
}
for (int i = 0; i < 2 * N; i++) {
if (!used[i]) go(i, cc[(i - 1 + N) % N] ^ 1);
}
for (int i = 0; i < N; i++)
cout << cc[boy[i]] + 1 << " " << cc[girl[i]] + 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, -1, 1};
const int N = 100010;
vector<int> g[N];
int c[N];
int n;
pair<long long, long long> dfs(int x, int ult) {
long long pos, neg;
pos = neg = 0;
for (int i = 0; i < g[x].size(); ++i) {
int y = g[x][i];
if (y == ult) continue;
pair<long long, long long> foo = dfs(y, x);
pos = max(foo.first, pos);
neg = max(foo.second, neg);
}
c[x] -= (pos - neg);
if (c[x] < 0)
neg -= c[x];
else
pos += c[x];
return make_pair(pos, neg);
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 0; i < n; ++i) cin >> c[i];
pair<long long, long long> foo = dfs(0, -1);
cout << foo.first + foo.second << endl;
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.