solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 5000010, P = 1000000007;
int n, m, a[maxn], b[maxn], t[maxn];
ll sum[2], cnt, ans = 1;
namespace gen {
int seed, base;
int rnd() {
int t = seed;
seed = (1LL * seed * base + 233) % P;
return t;
}
void init() {
scanf("%d %d", &n, &m);
for (int _ = 1, p, k, $ = 0; _ <= m; _++) {
scanf("%d %d %d %d", &p, &k, &seed, &base);
while ($ < p) t[++$] = rnd() % 2, a[$] = rnd() % k + 1;
}
}
} // namespace gen
int main() {
gen::init();
for (int i = 1; i <= n; i++) {
sum[t[i]] += a[i];
}
if (sum[0] > sum[1]) {
for (int i = 1; i <= n; i++) {
t[i] ^= 1;
}
}
if (t[1]) a[1]--, b[1]++;
for (int i = 1; i <= n; i++) {
if (!t[i]) {
cnt += a[i], b[i] = a[i];
} else {
ll v = min((ll)a[i], cnt);
cnt -= v, a[i] -= v, b[i] += v;
}
}
for (int i = 1; i <= n; i++) if (t[i]) {
ll v = min(ll(a[i]), cnt);
cnt -= v, b[i] += v;
}
for (int i = 1; i <= n; i++) {
ll v = (b[i] ^ (1LL * i * i)) + 1;
(ans *= v % P) %= P;
}
printf("%lld\n", ans);
return 0;
}
| 12 |
#include<bits/stdc++.h>
#define ff(i, a, b) for(int i = (a); i <= (b); ++i)
using namespace std;
typedef long long ll;
const int N = 200000 + 10;
const int M = 1000000000 + 7;
int n;
int b[N];
ll sum[N], f[N];
int main() {
int t;
cin >> t;
while (t--) {
cin >> n;
ff(i, 1, n) {
cin >> b[i];
sum[i] = sum[i - 1] + b[i];
}
map<ll, ll> g;
f[0] = f[1] = 1;
ff(i, 0, n - 2) {
g[sum[i]] = f[i];
f[i + 2] = (f[i + 1] * 2 % M + M - g[sum[i + 1]]) % M;
}
cout << f[n] << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int m = 1000000007;
void print_list(string list_name, list<int> lst);
class UnionFind {
public:
vector<int> parent;
vector<int> rank;
UnionFind(int n) {
parent = vector<int>(n);
rank = vector<int>(n, 0);
for (int i = 0; i < n; i++) {
parent[i] = i;
}
}
int find(int x) {
if (x != parent[x]) {
parent[x] = find(parent[x]);
}
return parent[x];
}
void do_union(int u, int v) {
u = find(u);
v = find(v);
if (u != v) {
if (rank[u] > rank[v]) {
parent[v] = u;
} else if (rank[u] < rank[v]) {
parent[u] = v;
} else {
parent[v] = u;
rank[u] += 1;
}
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, m1, m2;
cin >> n >> m1 >> m2;
UnionFind dsds1(n + 1);
UnionFind dsds2(n + 1);
for (int i = 0; i < m1; i++) {
int u, v;
cin >> u >> v;
dsds1.do_union(u, v);
}
for (int i = 0; i < m2; i++) {
int u, v;
cin >> u >> v;
dsds2.do_union(u, v);
}
vector<pair<int, int>> added_edges;
int added = 0;
for (int u = 1; u < n; u++) {
for (int v = (u + 1); v <= n; v++) {
if (dsds1.find(u) != dsds1.find(v) && dsds2.find(u) != dsds2.find(v)) {
added_edges.push_back({u, v});
dsds1.do_union(u, v);
dsds2.do_union(u, v);
added += 1;
}
}
}
cout << added << endl;
for (pair<int, int>& p : added_edges) {
cout << p.first << " " << p.second << endl;
}
return 0;
}
void print_list(string list_name, list<int> lst) {
cout << list_name << " ";
for (int e : lst) {
cout << e << ", ";
}
cout << endl;
}
| 3 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#define LL long long
using namespace std;
bool vi[1000005];
LL k,l,r,t,x,y,sum,zong;
bool case1(){
if(k+y<=r)return 1;
if(k-x>=0)return 1;
return 0;
}
bool case2(){
if(k+y<=r)k+=y;
double b=(double)(k-x)/(x-y);
sum=(LL)(b)+1;
return sum>=t;
}
LL up(LL k){
if(k+y>r)return k;
double b=(double)(r-k-y)/(y-x);
LL a=(LL)(b);
sum+=a;
return k+(y-x)*a+y;
}
LL down(LL k){
double b=(double)k/x;
LL a=(LL)b;
sum+=a;
return k-a*x;
}
bool case3(){
while(1){
k=up(k);
k=down(k);
if(k>r-y)return sum>=t;
if(vi[k])return 1;
vi[k]=1;
}
}
bool check(){
if(k<0 || k>r)return 0;
if(x==y)return case1();
if(x>y)return case2();
return case3();
}
int main(){
cin>>k>>l>>r>>t>>x>>y;
k-=l;
r-=l;
printf(check()?"Yes":"No");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int v[100001];
set<int> its;
map<int, int> cc;
map<int, int> ivcc;
int rpa[100001];
int rpb[100001];
int aa[100001];
int ab[100001];
int ak[100001];
vector<pair<int, int> > pe[500001];
vector<pair<pair<int, int>, int> > ae[500001];
const int N = 500010;
int st[2 * N];
int f[2 * N];
vector<int> of[500001];
void add(int i, int ff) {
st[i + N]++;
f[i + N] = i;
of[i].push_back(ff);
for (i = (i + N) / 2; i; i /= 2) {
st[i] = st[i * 2] + st[i * 2 + 1];
if (st[i * 2] > 0)
f[i] = f[i * 2];
else
f[i] = f[i * 2 + 1];
}
}
int take(int i) {
int r = of[i].back();
of[i].pop_back();
st[i + N]--;
for (i = (i + N) / 2; i; i /= 2) {
st[i] = st[i * 2] + st[i * 2 + 1];
if (st[i * 2] > 0)
f[i] = f[i * 2];
else
f[i] = f[i * 2 + 1];
}
return r;
}
int get(int a, int b) {
a += N;
b += N;
int s = 0;
int fo = 1e9;
while (a <= b) {
if (a % 2) {
if (st[a]) {
fo = min(fo, f[a]);
s += st[a];
}
a++;
}
if (!(b % 2)) {
if (st[b]) {
fo = min(fo, f[b]);
s += st[b];
}
b--;
}
a /= 2;
b /= 2;
}
if (s == 0) return -1;
return fo;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> rpa[i] >> rpb[i];
its.insert(rpa[i]);
its.insert(rpb[i]);
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> aa[i] >> ab[i] >> ak[i];
its.insert(aa[i]);
its.insert(ab[i]);
}
int it = 1;
for (int i : its) {
cc[i] = it;
ivcc[it] = i;
it++;
}
for (int i = 0; i < n; i++) {
pe[cc[rpb[i]]].push_back({cc[rpa[i]], i});
}
for (int i = 0; i < m; i++) {
ae[cc[ab[i]]].push_back({{cc[aa[i]], i}, ak[i]});
}
int fo = 0;
for (int i = 0; i <= it; i++) {
for (auto lol : pe[i]) {
add(lol.first, lol.second);
}
for (auto lol : ae[i]) {
int tt = lol.second;
while (1) {
int a = get(lol.first.first, i);
if (a == -1) break;
fo++;
int tv = take(a);
v[tv] = lol.first.second;
tt--;
if (tt <= 0) break;
}
}
}
if (fo < n) {
cout << "NO" << endl;
return 0;
} else {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
cout << v[i] + 1 << " ";
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to, cost, id;
};
int n;
vector<Edge> G[200];
const int inf = 1e9;
int dist[2][200][200];
void calc(int dist[200][200], int s, int t) {
for (int i = (0); i < (200); i++)
for (int j = (0); j < (200); j++) dist[i][j] = inf;
priority_queue<tuple<int, int, int>, vector<tuple<int, int, int>>,
greater<tuple<int, int, int>>>
q;
dist[s][150] = 0;
q.emplace(0, s, 150);
while (!q.empty()) {
int v, id;
tie(ignore, v, id) = q.top();
q.pop();
for (auto e : G[v]) {
if (id != 150 && e.id != 150) continue;
if (((dist[v][id] + e.cost) < dist[e.to][min(id, e.id)] &&
(dist[e.to][min(id, e.id)] = (dist[v][id] + e.cost), true))) {
q.emplace(dist[e.to][min(id, e.id)], e.to, min(id, e.id));
}
}
}
}
int main() {
cin >> n;
for (int i = (0); i < (n - 1); i++) {
int c;
cin >> c;
G[i].push_back({i + 1, c, 150});
G[i + 1].push_back({i, c, 150});
}
for (int i = (0); i < (n - 1); i++) {
int c;
cin >> c;
G[i + n].push_back({i + 1 + n, c, 150});
G[i + n + 1].push_back({i + n, c, 150});
}
for (int i = (0); i < (n); i++) {
int c;
cin >> c;
G[i].push_back({i + n, c, i});
G[i + n].push_back({i, c, i});
}
calc(dist[0], 0, 2 * n - 1);
calc(dist[1], 2 * n - 1, 0);
int ans = inf;
for (int i = (0); i < (n); i++)
for (int j = (0); j < (n); j++)
if (i != j) {
((dist[0][2 * n - 1][i] + dist[1][0][j]) < ans &&
(ans = (dist[0][2 * n - 1][i] + dist[1][0][j]), true));
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char ch[501][501];
int dp_row[501][501], dp_col[501][501];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> ch[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
dp_row[i][j] =
dp_row[i][j - 1] + (ch[i][j] == '.' && ch[i][j - 1] == '.');
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
dp_col[i][j] =
dp_col[i - 1][j] + (ch[i][j] == '.' && ch[i - 1][j] == '.');
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int x, y, x1, y1, sum = 0;
cin >> x >> y >> x1 >> y1;
for (int i = x; i <= x1; i++) sum += (dp_row[i][y1] - dp_row[i][y]);
for (int i = y; i <= y1; i++) sum += (dp_col[x1][i] - dp_col[x][i]);
cout << sum << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 7;
const long long MOD = 1e9 + 7;
vector<vector<long long>> g(N), rg(N);
vector<long long> dist(N);
long long n, m;
void bfs(long long node) {
for (long long i = 0; i < n; i++) {
dist[i] = n;
}
queue<long long> q;
dist[node] = 0;
q.push(node);
while (!q.empty()) {
long long u = q.front();
q.pop();
for (auto it : rg[u]) {
if (dist[it] > dist[u] + 1) {
dist[it] = dist[u] + 1;
q.push(it);
}
}
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long u, v;
cin >> n >> m;
g.resize(n);
rg.resize(n);
dist.resize(n);
for (long long i = 0; i < m; i++) {
cin >> u >> v;
u--, v--;
g[u].push_back(v);
rg[v].push_back(u);
}
long long k;
cin >> k;
vector<long long> path(k);
for (long long i = 0; i < k; i++) {
cin >> path[i];
path[i]--;
}
bfs(path[k - 1]);
long long mn = 0, mx = 0;
for (long long i = 1; i < k - 1; i++) {
if (dist[path[i]] >= dist[path[i - 1]])
mn++, mx++;
else {
bool ok = false;
for (auto it : g[path[i - 1]]) {
ok |= (it != path[i] && dist[it] <= dist[path[i]]);
}
if (ok) mx++;
}
}
cout << mn << ' ' << mx;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long a[15][15];
pair<long long, long long> ds[3][104];
long long vis[3][104];
pair<long long, long long> pos[104];
pair<long long, long long> add(pair<long long, long long> x,
pair<long long, long long> y) {
pair<long long, long long> a1 = x;
a1.first += y.first;
a1.second += y.second;
return a1;
}
vector<pair<long long, long long> > find_min(long long x1, long long y1,
long long p1, long long cell) {
priority_queue<pair<pair<long long, long long>, vector<long long> > > pq;
vector<long long> temp1 = {x1, y1, p1};
pq.push(make_pair(make_pair(0, 0), temp1));
pair<long long, long long> dist[14][14][3];
for (int i = 0; i < 14; i++) {
for (int j = 0; j < 14; j++) {
for (int k = 0; k < 3; k++) {
dist[i][j][k] = {1e16, 1e16};
}
}
}
dist[x1][y1][p1] = {0, 0};
while (!pq.empty()) {
pair<long long, long long> d = pq.top().first;
long long x = pq.top().second[0];
long long y = pq.top().second[1];
long long p = pq.top().second[2];
pq.pop();
if (d > dist[x][y][p]) continue;
for (int i = 0; i < 3; i++) {
pair<long long, long long> t = d;
t.first++;
t.second++;
if (dist[x][y][i] > t) {
dist[x][y][i] = t;
vector<long long> temp = {x, y, i};
pq.push(make_pair(t, temp));
}
}
pair<long long, long long> t = d;
t.first++;
if (p == 0) {
for (int i = 1; i <= n; i++) {
if (dist[x][i][0] > t) {
dist[x][i][0] = t;
vector<long long> temp = {x, i, 0};
pq.push(make_pair(t, temp));
}
if (dist[i][y][0] > t) {
dist[i][y][0] = t;
vector<long long> temp = {i, y, 0};
pq.push(make_pair(t, temp));
}
}
} else if (p == 1) {
long long x1 = x;
long long y1 = y;
while (x1 > 0 && y1 > 0) {
if (dist[x1][y1][1] > t) {
dist[x1][y1][1] = t;
vector<long long> temp = {x1, y1, 1};
pq.push(make_pair(t, temp));
}
x1--;
y1--;
}
x1 = x;
y1 = y;
while (x1 <= n && y1 <= n) {
if (dist[x1][y1][1] > t) {
dist[x1][y1][1] = t;
vector<long long> temp = {x1, y1, 1};
pq.push(make_pair(t, temp));
}
x1++;
y1++;
}
x1 = x;
y1 = y;
while (x1 <= n && y1 > 0) {
if (dist[x1][y1][1] > t) {
dist[x1][y1][1] = t;
vector<long long> temp = {x1, y1, 1};
pq.push(make_pair(t, temp));
}
x1++;
y1--;
}
x1 = x;
y1 = y;
while (x1 > 0 && y1 <= n) {
if (dist[x1][y1][1] > t) {
dist[x1][y1][1] = t;
vector<long long> temp = {x1, y1, 1};
pq.push(make_pair(t, temp));
}
x1--;
y1++;
}
} else {
for (int i = -2; i <= 2; i++) {
for (int j = -2; j <= 2; j++) {
if (abs(i) + abs(j) != 3) continue;
if (i == 0 || j == 0) continue;
if (x + i <= 0 || x + i > n) continue;
if (y + j <= 0 || y + j > n) continue;
if (dist[x + i][y + j][2] > t) {
dist[x + i][y + j][2] = t;
vector<long long> temp = {x + i, y + j, 2};
pq.push(make_pair(t, temp));
}
}
}
}
}
vector<pair<long long, long long> > ans;
ans.push_back(dist[pos[cell].first][pos[cell].second][0]);
ans.push_back(dist[pos[cell].first][pos[cell].second][1]);
ans.push_back(dist[pos[cell].first][pos[cell].second][2]);
return ans;
}
pair<long long, long long> dp(int p, int cell) {
if (cell > n * n) {
return {0, 0};
}
if (vis[p][cell] == 1) {
return ds[p][cell];
}
vis[p][cell] = 1;
vector<pair<long long, long long> > x1 =
find_min(pos[cell - 1].first, pos[cell - 1].second, p, cell);
pair<long long, long long> ans = add(x1[0], dp(0, cell + 1));
ans = min(ans, add(x1[1], dp(1, cell + 1)));
ans = min(ans, add(x1[2], dp(2, cell + 1)));
return ds[p][cell] = ans;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
pair<long long, long long> ps;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
if (a[i][j] == 1) {
ps.first = i;
ps.second = j;
}
pos[a[i][j]] = {i, j};
}
}
pair<long long, long long> ans = min(dp(0, 2), dp(1, 2));
ans = min(ans, dp(2, 2));
cout << ans.first << " " << ans.second << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N, M, Q;
int lg[60000];
struct tri {
int a, b, c;
} q[100];
long long dp[1 << 13][13];
vector<int> pp[13];
unordered_map<int, long long> br[1 << 13][13];
long long dfs(int mask, int root);
int edge[100];
long long brute(int mask, int tot, int root) {
if (mask == 0) return 1;
if (br[tot][root].count(mask)) return br[tot][root][mask];
long long res = 0;
int tmp = mask;
mask &= (mask - 1);
for (int nxt = mask;; nxt = (nxt - 1) & mask) {
int cur = tmp ^ nxt;
int flag = 1;
for (int c : pp[root])
if ((c & cur) == c) continue;
for (int i = 0; i < N; i++)
if (1 & cur >> i) {
if ((edge[i] & cur) != (edge[i] & tot)) flag = 0;
}
if (!flag) continue;
int r = edge[root] & cur;
if (r == 0) {
for (int i = 0; i < N; i++)
if (1 & cur >> i) {
res += dfs(cur, i) * brute(nxt, tot, root);
}
} else if (__builtin_popcount(r) == 1)
res += dfs(cur, lg[r]) * brute(nxt, tot, root);
if (nxt == 0) break;
}
return br[tot][root][tmp] = res;
}
long long dfs(int mask, int root) {
if (dp[mask][root] >= 0) return dp[mask][root];
dp[mask][root] = 0;
int tmask = mask ^ (1 << root);
for (int i = 0; i < Q; i++) {
if (1 & tmask >> q[i].c) continue;
if (q[i].c == root) {
if (!(1 & mask >> q[i].a) || !(1 & mask >> q[i].b)) return 0;
} else if ((1 & mask >> q[i].a) && (1 & mask >> q[i].b))
return 0;
}
return dp[mask][root] = brute(tmask, tmask, root);
}
int main() {
cin >> N >> M >> Q;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < M; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
edge[u] |= 1 << v;
edge[v] |= 1 << u;
}
for (int i = 0; i < 15; i++) lg[1 << i] = i;
for (int i = 0; i < Q; i++) {
cin >> q[i].a >> q[i].b >> q[i].c;
q[i].a--;
q[i].b--;
q[i].c--;
pp[q[i].c].push_back((1 << q[i].a) || (1 << q[i].b));
}
cout << dfs((1 << N) - 1, 0) << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int b[100001];
int c[100001][2];
long long dp[100001][2];
int main(int argc, char **argv) {
int n;
memset(b, 0, sizeof(b));
memset(dp, 0, sizeof(dp));
memset(c, 0, sizeof(c));
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int ai;
scanf("%d", &ai);
b[ai]++;
}
int m = 0;
for (int i = 0; i < 100001; i++) {
if (b[i]) {
c[m][0] = i;
c[m][1] = b[i];
m++;
}
}
for (int i = 0; i < m; i++) {
long long points = (long long)c[i][0] * c[i][1];
if ((i != 0) && (c[i][0] == c[i - 1][0] + 1)) {
dp[i][0] = dp[i - 1][1];
if ((i > 2) && (c[i - 2][0] == c[i - 3][0] + 1) &&
(c[i - 1][0] == c[i - 2][0] + 1)) {
dp[i][1] = max(dp[i - 1][0], dp[i - 2][0]) + points;
} else {
dp[i][1] = dp[i - 1][0] + points;
}
} else {
if (i == 0) {
dp[i][0] = 0;
dp[i][1] = points;
} else {
long long last = max(dp[i - 1][0], dp[i - 1][1]);
dp[i][0] = last;
dp[i][1] = last + points;
}
}
}
printf("%" PRId64 "\n", max(dp[m - 1][0], dp[m - 1][1]));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long int binomial(long long int n, long long int k) {
long long int C[k + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (long long int i = 1; i <= n; i++) {
for (int j = min(i, k); j > 0; j--) C[j] = C[j] + C[j - 1];
}
return C[k];
}
vector<int> pr;
bool prime[10000000];
void Sieve(long long int n) {
memset(prime, true, sizeof(prime));
prime[1] = false;
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
pr.push_back(p);
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
}
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int find(int arr[], int n) {
int result = arr[0];
for (int i = 1; i < n; i++) {
result = gcd(arr[i], result);
if (result == 1) {
return 1;
}
}
return result;
}
pair<int, int> fib(int n) {
if (n == 0) return {0, 1};
auto p = fib(n >> 1);
int c = p.first * (2 * p.second - p.first);
int d = p.first * p.first + p.second * p.second;
if (n & 1)
return {d, c + d};
else
return {c, d};
}
void reverse(string& str) {
int n = str.length();
for (int i = 0; i < n / 2; i++) swap(str[i], str[n - i - 1]);
}
string fun(string s) {
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'O' || s[i] == 'o') {
s[i] = '0';
} else if (s[i] == 'l' || s[i] == 'I' || s[i] == 'L' || s[i] == 'i') {
s[i] = '1';
} else if (isupper(s[i])) {
s[i] = tolower(s[i]);
}
}
return s;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n;
cin >> n;
int a[n];
int l = 0;
int k = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) {
l++;
} else {
k++;
}
}
if (l < k) {
cout << l << endl;
} else {
l -= k;
int p = l / 3;
cout << k + p << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using LL = long long;
const int N = 626 * 26;
const int M = 6e3 * 26;
const LL INF = 1e17;
const int IINF = 1e9;
int Val[(int)1e2 + 5], n;
char Str[(int)1e2 + 5];
int Cnt[26 + 5];
namespace G {
int Head[N + 5], tot = 1;
struct Edge {
int nxt, to, c, w;
} E[M * 2 + 5];
void Add(int u, int v, int c, int w) {
E[++tot] = (Edge){Head[u], v, c, w};
Head[u] = tot;
}
} // namespace G
namespace EK {
int s, t;
LL Dis[N + 5], F[N + 5];
int Pre[N + 5], Ed[N + 5];
bool Vis[N + 5];
bool SPFA() {
memset(Dis, 127, sizeof(Dis));
memset(Pre, 0, sizeof(Pre));
std::queue<int> Q;
Q.push(s);
Dis[s] = 0, F[s] = INF;
while (Q.size()) {
int p = Q.front();
Q.pop();
Vis[p] = false;
for (int i = G::Head[p]; i; i = G::E[i].nxt) {
int q = G::E[i].to;
LL flow = std::min(F[p], 1LL * G::E[i].c);
if (!flow) continue;
LL dis = Dis[p] + G::E[i].w;
if (dis < Dis[q]) {
Dis[q] = dis, F[q] = flow;
Pre[q] = p, Ed[q] = i;
if (!Vis[q]) Vis[q] = true, Q.push(q);
}
}
}
return Pre[t] > 0;
}
LL Run() {
LL cost = 0;
while (SPFA()) {
cost += F[t] * Dis[t];
int p = t;
while (p != s) {
G::E[Ed[p]].c -= F[t];
G::E[Ed[p] ^ 1].c += F[t];
p = Pre[p];
}
}
return cost;
}
} // namespace EK
int main() {
scanf("%d%s", &n, Str + 1);
for (int i = 1; i <= n; ++i) scanf("%d", &Val[i]), ++Cnt[Str[i] - 'a' + 1];
EK::s = 26 + 26 * n / 2 + n + 1, EK::t = EK::s + 1;
for (int i = 1; i <= 26; ++i)
G::Add(EK::s, i, Cnt[i], 0), G::Add(i, EK::s, 0, 0);
for (int i = 1; i <= 26; ++i)
for (int j = 1; j <= n / 2; ++j) {
int tap, tbp;
tap = (Str[j] - 'a' + 1 == i) ? Val[j] : 0;
tbp = (Str[n - j + 1] - 'a' + 1 == i) ? Val[n - j + 1] : 0;
int v = 26 + (i - 1) * n / 2 + j;
G::Add(i, v, 1, 0), G::Add(v, i, 0, 0);
G::Add(v, 26 + 26 * n / 2 + j, 1, -tap);
G::Add(26 + 26 * n / 2 + j, v, 0, tap);
G::Add(v, 26 + 26 * n / 2 + n - j + 1, 1, -tbp);
G::Add(26 + 26 * n / 2 + n - j + 1, v, 0, tbp);
}
for (int i = 1; i <= n; ++i) {
G::Add(26 + 26 * n / 2 + i, EK::t, 1, 0);
G::Add(EK::t, 26 + 26 * n / 2 + i, 0, 0);
}
printf("%lld\n", -EK::Run());
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int ar[3];
int main() {
int a, b;
cin >> a;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < a - i; j++) {
cin >> b;
ar[i] += b;
}
}
cout << ar[0] - ar[1] << endl << ar[1] - ar[2];
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const long long mod = 1e9 + 7;
long long dy[4] = {1, 0, -1, 0};
long long dx[4] = {0, 1, 0, -1};
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class A, class B>
ostream& operator<<(ostream& ost, const pair<A, B>& p) {
ost << "{" << p.first << ", " << p.second << "} ";
return ost;
}
template <class T>
ostream& operator<<(ostream& ost, const vector<T>& v) {
ost << "{";
for (int i = 0; i < v.size(); i++) {
if (i) ost << ", ";
ost << v[i];
}
ost << "} ";
return ost;
}
template <class A, class B>
ostream& operator<<(ostream& ost, const map<A, B>& v) {
ost << "{";
for (auto p : v) {
ost << "{" << p.first << ", " << p.second << "} ";
}
ost << "} ";
return ost;
}
bool out_check(long long a, long long b) { return (0 <= a && a < b); }
void addmod(long long& a, long long& b) { a = (a + b) % mod; }
double pitagoras(long long a, long long b, long long c, long long d) {
double dx = a - b, dy = c - d;
return pow(dx * dx + dy * dy, 0.5);
}
long long powmod(long long a, long long b) {
long long c = 1;
while (b > 0) {
if (b & 1) {
c = a * c % mod;
}
a = a * a % mod;
b >>= 1;
}
return c;
}
void Yes(bool x) { cout << ((x) ? "Yes\n" : "No\n"); }
void YES(bool x) { cout << ((x) ? "YES\n" : "NO\n"); }
void yes(bool x) { cout << ((x) ? "yes\n" : "no\n"); }
void Yay(bool x) { cout << ((x) ? "Yay!\n" : ":(\n"); }
vector<string> DAY = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
long long n, m, d, e, r, l, k, h, Q, ans, ret = LLONG_MAX;
bool flag = false, flag2 = false, flag3 = false;
string s, t, u;
vector<long long> divisor(long long n) {
vector<long long> w;
for (long long i = 1; i * i <= n; ++i) {
if (n % i == 0) {
w.push_back(i);
if (i * i != n) {
w.push_back(n / i);
}
}
}
sort(w.begin(), w.end());
return w;
}
vector<long long> rec;
map<long long, long long> ma;
vector<vector<long long> > num;
void calc(long long v, long long k) {
if (k == 0) {
if (rec.size() < 1e5) rec.emplace_back(v);
return;
}
long long x = ma[v];
for (auto N : num[x]) {
if (rec.size() >= 1e5) return;
if (N == 1)
rec.emplace_back(1);
else
calc(N, k - 1);
}
}
int main() {
long long x;
cin >> x >> k;
if (x == 1) {
puts("1");
return 0;
}
if (k >= 1e5) {
for (int i = 0; i < 1e5; ++i) cout << "1 ";
puts("");
return 0;
}
auto v = divisor(x);
num.resize(v.size());
for (int i = 0; i < v.size(); ++i) {
ma[v[i]] = i;
num[i] = divisor(v[i]);
}
calc(x, k);
for (int i = 0; i < min((size_t)1e5, rec.size()); ++i) cout << rec[i] << " ";
puts("");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<string> vs;
char c;
bool quote = 0;
string com = "";
while (cin >> noskipws >> c) {
if (c == '"') {
if (quote) {
vs.push_back(com);
com = "";
quote = 0;
} else {
quote = 1;
}
} else {
if (quote) {
com += c;
} else {
if (c == ' ') {
if (com != "") {
vs.push_back(com);
com = "";
}
} else {
com += c;
}
}
}
}
if (com != "") {
string tmp = "";
for (int i = 0; i < com.size() - 1; i++) {
tmp += com[i];
}
if (tmp != "") vs.push_back(tmp);
}
for (int i = 0, _n = (vs.size()); i < _n; i++) {
cout << "<" << vs[i] << ">" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int t;
cin >> t;
while (t--) {
cin >> n;
if (n == 1 || n == 2)
cout << '0' << endl;
else
cout << n - 2 << endl;
}
}
| 4 |
#include <bits/stdc++.h>
const long long mod = (long long)1e9 + 7;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
cout << (n / 2) * ((n + 1) / 2) * (m / 2) * ((m + 1) / 2) << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
vector<vector<pair<long long, long long> > > nodes;
vector<long long> bad;
int main() {
cin >> n >> k;
nodes.resize(n);
bad.resize(n);
vector<long long> ins(n);
for (int i = 0; i < n - 1; i++) {
long long u, v, x;
cin >> u >> v >> x;
u--;
v--;
nodes[u].push_back({v, x});
nodes[v].push_back({u, x});
}
queue<long long> q;
for (int i = 0; i < n; i++) {
if (nodes[i].size() == 1) {
q.push(i);
}
ins[i] = nodes[i].size();
}
vector<bool> used(n);
while (q.size() > 0) {
long long cur = q.front();
q.pop();
used[cur] = 1;
bad[cur]++;
if (ins[cur] == 0) {
q.push(cur);
break;
}
for (int i = 0; i < nodes[cur].size(); i++) {
if (used[nodes[cur][i].first]) continue;
ins[nodes[cur][i].first]--;
if (nodes[cur][i].second == 0) bad[nodes[cur][i].first] += bad[cur];
if (ins[nodes[cur][i].first] <= 1) q.push(nodes[cur][i].first);
}
}
used.resize(0);
used.resize(n);
while (q.size() > 0) {
long long cur = q.front();
q.pop();
used[cur] = 1;
for (int i = 0; i < nodes[cur].size(); i++) {
if (used[nodes[cur][i].first]) continue;
if (nodes[cur][i].second == 0)
bad[nodes[cur][i].first] += bad[cur] - bad[nodes[cur][i].first];
q.push(nodes[cur][i].first);
}
}
long long allAnsw = 0;
for (int i = 0; i < n; i++) {
long long answ = 1;
answ %= (long long)(1e9 + 7);
long long wrong = 1;
for (int j = 1; j < k; j++) {
answ *= n;
answ %= (long long)(1e9 + 7);
wrong *= bad[i];
wrong %= (long long)(1e9 + 7);
}
answ = (answ - wrong + (long long)(1e9 + 7)) % (long long)(1e9 + 7);
allAnsw += answ;
allAnsw %= (long long)(1e9 + 7);
}
cout << allAnsw << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x, max = 0, expected, stolen = 0;
array<int, 101> a;
a.fill(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> x;
a[x] = a[x] + 1;
if (a[x] > max) max = a[x];
}
expected = k * (max / k + (max % k != 0));
for (int i = 0; i < a.size(); i++)
if (a[i] > 0) stolen += expected - a[i];
cout << stolen;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e4 + 5;
int s[MAXN + 5];
int n, m;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &s[i]);
for (int i = 1; i <= m; i++) {
int l, r, x;
scanf("%d %d %d", &l, &r, &x);
int tot = s[x], sum = 0;
for (int j = l; j <= r; j++)
if (s[j] < tot) sum++;
if (sum == x - l)
printf("Yes\n");
else
printf("No\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int a, b, n, ans = 0;
cin >> a >> b >> n;
while (a <= n && b <= n) {
if (a > b) swap(a, b);
a += b;
++ans;
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define FasterIO ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define bug(a,b) cout<<a<<"\t"<<b<<"\n";
#define Case(a,b) cout<<"Case "<<a<<": "<<b<<"\n";
#define precision(a,b) fixed<<setprecision(a)<<b
#define lp(i,a,b) for(int i=a;i<b;i++)
#define Endl "\n"
#define tab "\t"
#define reset(a,b) memset(a,b,sizeof(a));
#define sf(a) scanf(" %d", &a);
#define sfl(a) scanf(" %lld", &a);
#define srt(a) sort(a.begin(),a.end());
#define ALL(a) a.begin(),a.end()
#define pb(a) push_back(a)
#define pi 2*acos(0.0)
#define yes cout<<"YES\n";
#define no cout<<"NO\n";
#define print2d(a,b,c) for(int i =0; i <a; i++){for (int j = 0; j < b; j++){cout << c[i][j] << " ";}cout << "\n";}
#define printAr(a,b) for(int i =0; i <a; i++){cout<<b[i]<<" ";}cout << "\n";
typedef long long int ll;
typedef unsigned long long int ull;
const int sz = 1e5 + 9 , LOG = 20, infP = INT_MAX , infN = INT_MIN , mod = 1e9 + 7, eps = 1e-9;
ll gcd(ll a, ll b) {
while (b != 0) {
ll temp = a;
a = b, b = temp % b;
}
return a;
}
void solve() {
ll n , m = 1, k, l, r, ans = 0, sum = 0;
cin >> n;
int a[n], b[101], c[101];
reset(b, 0);
int ind = 1;
for (auto &i : a) {
cin >> i;
b[i]++;
c[i] = ind++;
}
for (int i = 1; i <= 100 ; i++) {
if (b[i] == 1) {
cout << c[i] << Endl;
return;
}
}
}
int main() {
FasterIO;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
// ini();
int t = 1;
cin >> t;
while (t--)
solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> edge[2050];
int n;
int x[2050];
int dp[2050];
int val[2050];
int sub[2050];
void dfs(int v) {
int maxv = 0;
int sum = 0;
sub[v] = 1;
for (int i = 0; i < edge[v].size(); i++) {
dfs(edge[v][i]);
maxv = max(maxv, val[edge[v][i]] + x[edge[v][i]]);
}
for (int i = 0; i < edge[v].size(); i++) {
sum += dp[edge[v][i]] + (maxv - val[edge[v][i]] - x[edge[v][i]]);
}
dp[v] = sum;
val[v] = maxv;
return;
}
int main() {
cin >> n;
for (int i = 0; i < (1 << n) * 2 - 2; i++) {
cin >> x[i + 2];
}
for (int i = 2; i <= (1 << n) * 2 - 1; i++) {
edge[i / 2].push_back(i);
}
dfs(1);
cout << dp[1] << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(m);
map<int, int> mp;
for (int i = 0; i < m; i++) {
cin >> a[i];
mp[a[i]]++;
}
auto property = [&](int mid) -> bool {
map<int, int> m2;
for (auto i : a) m2[i]++;
for (int i = 1; i <= n; i++) {
bool fl = 0;
for (auto j : m2) {
if (j.second >= mid) {
m2[j.first] -= mid;
fl = 1;
break;
}
}
if (fl == 0) {
return false;
}
}
return true;
};
int l = 0, r = 1e6;
while (l <= r) {
int mid = (l + r) / 2;
if (property(mid) == true) {
l = mid + 1;
} else {
r = mid - 1;
}
}
cout << l - 1 << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000001], fr[1000001], sum[1000001];
int main() {
long long n, i, x, nr1, nr2, p, ans = 0, lg, v1, v2;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
x = a[i];
lg = 0;
while (x != 0) {
lg++;
x /= 10;
}
fr[lg]++;
}
for (i = 20; i >= 1; i--) sum[i] = sum[i + 1] + fr[i];
for (i = 1; i <= n; i++) {
x = a[i];
nr1 = 0;
nr2 = 0;
p = 1;
lg = 0;
while (x != 0) {
nr1 += (x % 10) * p;
nr2 = nr1 * 10;
lg++;
x /= 10;
p *= 100;
p %= 998244353;
nr1 %= 998244353;
nr2 %= 998244353;
v2 = (nr2 + x * p) % 998244353;
if (x != 0)
v2 = (v2 * fr[lg]) % 998244353;
else
v2 = (v2 * sum[lg]) % 998244353;
v1 = (nr1 + x * p) % 998244353;
if (x != 0)
v1 = (v1 * fr[lg]) % 998244353;
else
v1 = (v1 * sum[lg]) % 998244353;
ans = (ans + v1 + v2) % 998244353;
}
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1005], b[1005], c[1005], p[1005];
bool check(int k) {
memset(p, 0, sizeof(p));
for (int i = 0; i < n; ++i)
if (i != k) {
c[i] = a[i];
++p[a[i]];
}
int v, d1 = 0, d2 = 0;
for (int i = 1; i <= n; ++i)
if (p[i] > 1)
return 0;
else if (!p[i])
v = i;
c[k] = v;
for (int i = 0; i < n; ++i) {
if (c[i] != a[i]) ++d1;
if (c[i] != b[i]) ++d2;
}
if (d1 != 1 || d2 != 1) return 0;
return 1;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
for (int i = 0; i < n; ++i)
if (check(i)) break;
for (int i = 0; i < n; ++i) cout << c[i] << ' ';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, val, ans;
bool operator<(const node &a) const { return val < a.val; }
} p[1000010];
int r[1000010], l[1000010], rr[1000010], ll[1000010];
int n, m;
int fa[1000010], A[1000010];
int cmp(node a, node b) { return a.x * m + a.y < b.x * m + b.y; }
int find(int x) {
if (fa[x] != x) fa[x] = find(fa[x]);
return fa[x];
}
int main(int argc, char const *argv[]) {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
p[i * m + j].x = i;
p[i * m + j].y = j;
scanf("%d", &p[i * m + j].val);
}
sort(p, p + n * m);
p[n * m].val = -1;
for (int i = 0; i < n * m; i++) fa[i] = i;
memset(r, 0, sizeof(r));
memset(l, 0, sizeof(l));
memset(A, 0, sizeof(A));
memset(rr, 0, sizeof(rr));
memset(ll, 0, sizeof(ll));
int last = 0;
for (int i = 1; i <= n * m; i++)
if (p[i].val != p[i - 1].val) {
for (int j = last; j < i; j++) {
int x = p[j].x, y = p[j].y;
if (rr[x] == 0)
rr[x] = j;
else
fa[find(j)] = find(rr[x]);
if (ll[y] == 0)
ll[y] = j;
else
fa[find(j)] = find(ll[y]);
}
for (int j = last; j < i; j++)
A[find(j)] = max(A[find(j)], max(r[p[j].x], l[p[j].y]) + 1);
for (int j = last; j < i; j++) {
int x = p[j].x, y = p[j].y;
p[j].ans = A[find(j)];
r[x] = l[y] = p[j].ans;
rr[x] = 0;
ll[y] = 0;
}
last = i;
}
sort(p, p + n * m, cmp);
for (int i = 0; i < n; i++) {
int tmp = i * m;
for (int j = 0; j < m; j++) printf("%d ", p[tmp + j].ans);
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, a[305] = {0};
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
if (a[i]) {
putchar('P');
a[i]--;
if (i != 1) {
while (a[i]) putchar('L'), putchar('R'), putchar('P'), a[i]--;
} else {
while (a[i]) putchar('R'), putchar('L'), putchar('P'), a[i]--;
}
}
putchar(i == n ? '\n' : 'R');
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int MAXN = 220000;
const int MAXX = 1100000;
const int P = 1E9 + 7;
int n, k, q, ans;
bool mark[MAXX];
int pri[MAXX], phi[MAXX];
int fac[MAXN], ifac[MAXN];
int c[MAXX], f[MAXX];
int qpow(int n, int k) {
int r = 1;
while (k) {
if (k & 1) r = 1ll * r * n % P;
n = 1ll * n * n % P;
k >>= 1;
}
return r;
}
inline int C(int n, int m) {
if (m < 0 || m > n) return 0;
return 1ll * fac[n] * ifac[m] % P * ifac[n - m] % P;
}
void prework(int lim) {
phi[1] = 1;
for (int i = 2, cp = 0; i <= lim; i++) {
if (!mark[i]) pri[++cp] = i, phi[i] = i - 1;
for (int j = 1; j <= cp && i * pri[j] <= lim; j++) {
mark[i * pri[j]] = 1;
if (i % pri[j] == 0) {
phi[i * pri[j]] = 1ll * phi[i] * pri[j] % P;
break;
}
phi[i * pri[j]] = 1ll * phi[i] * (pri[j] - 1) % P;
}
}
fac[0] = 1;
for (int i = 1; i <= n + q; i++) fac[i] = 1ll * fac[i - 1] * i % P;
ifac[n + q] = qpow(fac[n + q], P - 2);
for (int i = n + q; i >= 1; i--) ifac[i - 1] = 1ll * ifac[i] * i % P;
for (int i = 1; i <= lim; i++) {
f[i] = 0;
for (int j = 1; i * j <= lim; j++) f[i] += c[i * j];
ans = (ans + 1ll * C(f[i], k) * phi[i]) % P;
}
}
inline void inc(int x) {
f[x]++;
ans = (ans + 1ll * (C(f[x], k) - C(f[x] - 1, k) + P) * phi[x]) % P;
}
void insert(int x) {
for (int i = 1; i * i <= x; i++)
if (x % i == 0) {
inc(i);
if (i * i != x) inc(x / i);
}
}
int main() {
scanf("%d%d%d", &n, &k, &q);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
c[x]++;
}
ans = 0;
prework(1E6);
for (int i = 1; i <= q; i++) {
int x;
scanf("%d", &x);
insert(x);
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
static const int INF = std::numeric_limits<int>::max();
struct Node {
int len, prob;
};
struct comp {
bool operator()(const Node& lhs, const Node& rhs) const {
double lp = lhs.prob / 100.0, rp = rhs.prob / 100.0;
double a = lhs.len + rhs.len + lhs.len * lp * (1 - rp);
double b = rhs.len + lhs.len + rhs.len * rp * (1 - lp);
return a > b;
}
};
int main() {
int n;
std::cin >> n;
std::vector<Node> v(n);
for (int i = 0; i < n; ++i) {
std::cin >> v[i].len >> v[i].prob;
}
std::sort(v.begin(), v.end(), comp());
double res = 0, acc = 0;
for (int i = 0; i < n; ++i) {
double p = v[i].prob / 100.0;
res += v[i].len + acc * (1 - p);
acc += v[i].len * p;
}
std::cout << std::fixed << std::setprecision(9) << res << std::endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int S[45][45], a[45][45];
int ans[45][45][45][45], n, m, k;
int Sum(int x, int y, int p, int q) {
return S[p][q] - S[p][y - 1] - S[x - 1][q] + S[x - 1][y - 1];
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
int u, v, p, q;
char P;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> P;
a[i][j] = P - '0';
S[i][j] = S[i - 1][j] + S[i][j - 1] - S[i - 1][j - 1] + a[i][j];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int p = i; p <= n; p++)
for (int q = j; q <= m; q++) {
ans[i][j][p][q] = ans[i][j][p - 1][q] + ans[i][j][p][q - 1] -
ans[i][j][p - 1][q - 1];
for (int u = i; u <= p; u++)
for (int v = j; v <= q; v++)
if (Sum(u, v, p, q) == 0) ans[i][j][p][q]++;
}
for (int i = 1; i <= k; i++) {
cin >> u >> v >> p >> q;
cout << ans[u][v][p][q] << endl;
}
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
long long a[1000005], par[1000005];
long long find(long long n) {
if (n != par[n]) {
par[n] = find(par[n]);
}
return par[n];
}
void solve() {
long long n, m;
cin >> n >> m;
long long cc = LLONG_MAX;
long long id = -1;
for (int i = 1; i < n + 1; i++) {
cin >> a[i];
if (cc > a[i]) {
cc = a[i];
id = i;
}
}
set<pair<long long, pair<long long, long long> > > put;
for (int i = 0; i < m; i++) {
long long x, y, w;
cin >> x >> y >> w;
put.insert({w, {x, y}});
put.insert({a[x] + a[y], {x, y}});
}
for (int i = 1; i < n + 1; i++) {
put.insert({a[id] + a[i], {id, i}});
}
for (int i = 1; i < 1000005; i++) {
par[i] = i;
}
long long ans = 0;
while (!put.empty()) {
auto ele = *put.begin();
put.erase(put.begin());
long long c = ele.first;
long long x = ele.second.first;
long long y = ele.second.second;
long long p1 = find(x);
long long p2 = find(y);
if (p1 == p2) continue;
par[p1] = p2;
ans += c;
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tc = 1;
while (tc--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300030;
const int INF = 0x7f7f7f7f;
int cases;
set<int> notice;
vector<int> app[MAXN];
int now;
void add(int type) {
++now;
app[type].push_back(now);
notice.insert(now);
}
void del_by_app(int type) {
while (!app[type].empty()) {
notice.erase(app[type].back());
app[type].pop_back();
}
}
void del_kth(int k) {
while (!notice.empty()) {
auto it = notice.begin();
if (*it > k) return;
notice.erase(it);
}
}
int main() {
int n, q, op, x;
scanf("%d%d", &n, &q);
while (q--) {
scanf("%d%d", &op, &x);
if (op == 1) {
add(x);
} else if (op == 2) {
del_by_app(x);
} else {
del_kth(x);
}
printf("%lu\n", notice.size());
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, summ = 0;
cin >> n >> x;
for (int i = 0; i < n; i++) {
int tmp;
cin >> tmp;
summ += tmp;
}
int result = abs(summ) / x;
if (abs(summ) % x != 0) result++;
cout << result << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
void functie(int nivel, unsigned long long cant, int afis) {
if (nivel == 1)
printf("%d ", afis);
else {
unsigned long long int a = 1;
a = a << (nivel - 2);
if (cant <= a) {
printf("%d ", afis);
functie(nivel - 1, cant, afis + 1);
} else {
functie(nivel - 1, cant - a, afis + 1);
printf("%d ", afis);
}
}
}
int main() {
cin >> n >> m;
functie(n, m, 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
long long N = 1e9 + 7, dpl;
long long a[1000000], lp[1000000];
using namespace std;
class matrix {
public:
long long a[2][2];
void mod() {
a[0][0] = a[0][0] % N;
a[0][1] = a[0][1] % N;
a[1][0] = a[1][0] % N;
a[1][1] = a[1][1] % N;
}
matrix() {
a[0][0] = 0;
a[0][1] = 0;
a[1][0] = 0;
a[1][1] = 0;
}
matrix operator+(matrix x) {
matrix t;
t.a[0][0] = a[0][0] + x.a[0][0];
t.a[1][0] = a[1][0] + x.a[1][0];
t.a[0][1] = a[0][1] + x.a[0][1];
t.a[1][1] = a[1][1] + x.a[1][1];
t.mod();
return t;
}
matrix operator*(matrix x) {
matrix t;
t.a[0][0] = a[0][0] * x.a[0][0] + a[0][1] * x.a[1][0];
t.a[0][1] = a[0][0] * x.a[0][1] + a[0][1] * x.a[1][1];
t.a[1][0] = a[1][0] * x.a[0][0] + a[1][1] * x.a[1][0];
t.a[1][1] = a[1][0] * x.a[0][1] + a[1][1] * x.a[1][1];
t.mod();
return t;
}
pair<long long, long long> operator*(pair<long long, long long> x) {
pair<long long, long long> t;
t.first = (a[0][0] * x.first + a[0][1] * x.second) % N;
t.second = (a[1][0] * x.first + a[1][1] * x.second) % N;
return t;
}
} I, F, pwr[1000000];
pair<long long, long long> seg_tree[1000000];
matrix power(long long x) {
if (x == 0) return I;
if (x < dpl) return pwr[x];
matrix t = power(x / 2);
t = t * t;
if (x & 1) t = t * F;
return t;
}
void build(long long l, long long r, long long p) {
if (l > r) return;
if (l == r) {
seg_tree[p] = power(a[l]) * make_pair(0, 1);
return;
}
long long mid = (l + r) / 2;
build(l, mid, 2 * p);
build(mid + 1, r, 2 * p + 1);
seg_tree[p].first = (seg_tree[2 * p].first + seg_tree[2 * p + 1].first) % N;
seg_tree[p].second =
(seg_tree[2 * p].second + seg_tree[2 * p + 1].second) % N;
}
void update(long long l, long long r, long long p, long long i, long long j,
long long x) {
if (i > j) return;
if (lp[p]) {
seg_tree[p] = power(lp[p]) * seg_tree[p];
if (i < j)
lp[2 * p] = (lp[2 * p] + lp[p]), lp[2 * p + 1] = (lp[2 * p + 1] + lp[p]);
lp[p] = 0;
}
if (l > j or r < i) return;
if (l <= i and j <= r) {
seg_tree[p] = power(x) * seg_tree[p];
if (i < j) lp[2 * p] = (lp[2 * p] + x), lp[2 * p + 1] = (lp[2 * p + 1] + x);
return;
}
long long mid = (i + j) / 2;
update(l, r, 2 * p, i, mid, x);
update(l, r, 2 * p + 1, mid + 1, j, x);
seg_tree[p].first = (seg_tree[2 * p].first + seg_tree[2 * p + 1].first) % N;
seg_tree[p].second =
(seg_tree[2 * p].second + seg_tree[2 * p + 1].second) % N;
}
long long query(long long l, long long r, long long p, long long i,
long long j) {
if (i > j) return 0;
if (lp[p]) {
seg_tree[p] = power(lp[p]) * seg_tree[p];
if (i < j)
lp[2 * p] = (lp[2 * p] + lp[p]), lp[2 * p + 1] = (lp[2 * p + 1] + lp[p]);
lp[p] = 0;
}
if (l > j or r < i) return 0;
if (l <= i and j <= r) return seg_tree[p].first;
long long mid = (i + j) / 2, ans = 0;
ans = query(l, r, 2 * p, i, mid);
ans += query(l, r, 2 * p + 1, mid + 1, j);
ans = ans % N;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
I.a[0][0] = 1;
I.a[1][1] = 1;
F.a[0][0] = 1;
F.a[0][1] = 1;
F.a[1][0] = 1;
dpl = 1;
while (dpl < 1000000) {
pwr[dpl] = power(dpl);
dpl++;
}
long long n, m, i, t, l, r, x;
cin >> n >> m;
for (i = 1; i <= n; i++) cin >> a[i];
build(1, n, 1);
while (m--) {
cin >> t >> l >> r;
if (t == 1) {
cin >> x;
update(l, r, 1, 1, n, x);
} else
cout << query(l, r, 1, 1, n) << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int max(long long int a, long long int b) {
if (a >= b)
return a;
else
return b;
}
long long int min(long long int a, long long int b) {
if (a <= b)
return a;
else
return b;
}
long long int kabs(long long int a) {
if (a >= 0)
return a;
else
return -a;
}
long long int num(vector<long long int> mono, vector<long long int> jun,
long long int n) {
long long int tmp = 0;
for (long long int i = 0; i < ((long long int)(n)); i++) {
tmp = tmp * 10 + mono[jun[i]];
}
return tmp;
}
int main() {
long long int a, b, x1, y1, x2, y2;
long long int wa1, wa2, sa1, sa2;
long long int mod1, mod2, m1, m2, res = 0;
cin >> a >> b >> x1 >> y1 >> x2 >> y2;
wa1 = x1 + y1;
wa2 = x2 + y2;
sa1 = x1 - y1;
sa2 = x2 - y2;
mod1 = wa1 / (a * 2);
mod2 = wa2 / (a * 2);
if (wa1 < 0) mod1--;
if (wa2 < 0) mod2--;
res += kabs(mod1 - mod2);
m1 = sa1 / (b * 2);
m2 = sa2 / (b * 2);
if (sa1 < 0) m1--;
if (sa2 < 0) m2--;
res += kabs(m1 - m2);
if (wa1 % (a * 2) == 0 || sa1 % (b * 2) == 0) res++;
if (wa2 % (a * 2) == 0 || sa2 % (b * 2) == 0) res++;
res -= min(kabs(m1 - m2), kabs(mod1 - mod2));
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x, y, z;
cin >> x >> y;
bool b = 0;
int n = x.size(), c = 0;
for (int i = 0; i < n; i++) {
if (x[i] != y[i]) {
if (b) {
z += x[i];
b = 0;
} else {
z += y[i];
b = 1;
}
c++;
} else
z += x[i];
}
int c1 = 0, c2 = 0;
for (int i = 0; i < n; i++) {
if (z[i] != x[i]) c1++;
if (z[i] != y[i]) c2++;
}
if (c1 != c2)
cout << "impossible" << endl;
else
cout << z << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
long long powfi(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
a = (a * a) % m;
b = b / 2;
}
return ans;
}
long long dp[5005];
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long val = 1;
vector<long long> a, b;
long long inv = powfi(m, 998244353 - 2, 998244353);
a = {1};
for (long long i = 1; i <= k; i++) {
b.assign(a.size() + 1, 0LL);
for (long long j = 0; j < a.size(); j++) {
long long val = (a[j] * max(0LL, n - j)) % 998244353;
val = (val * inv) % 998244353;
b[j + 1] = (b[j + 1] + val) % 998244353;
val = (j * a[j]) % 998244353;
b[j] = (b[j] + val) % 998244353;
}
a = b;
}
long long ans = 0;
for (long long x : a) ans = (ans + x) % 998244353;
cout << ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1e9 + 7;
int n, s;
char opt[100], ans[1000000], *p = ans;
void check() {
if (scanf("%s", p) == EOF) {
puts("Error occurred");
exit(0);
}
if (*p == 'i') {
for (; *p; p++)
;
return;
}
for (; *p; p++)
;
*p++ = '<';
check();
*p++ = ',';
check();
*p++ = '>';
}
int main() {
scanf("%d", &n);
check();
if (scanf("%s", p) != EOF) {
puts("Error occurred");
exit(0);
}
puts(ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, c, i, j, k, p = 0, f = 0;
cin >> r >> c;
char cake[r][c];
for (i = 0; i < r; i++)
for (j = 0; j < c; j++) cin >> cake[i][j];
for (i = 0; i < r; i++) {
f = 0;
for (j = 0; j < c; j++) {
if (cake[i][j] == 'S') {
f = 1;
break;
}
}
if (f == 0) {
for (k = 0; k < c; k++) {
if (cake[i][k] == '.') {
p++;
cake[i][k] = 'e';
}
}
}
}
for (j = 0; j < c; j++) {
f = 0;
for (i = 0; i < r; i++) {
if (cake[i][j] == 'S') {
f = 1;
break;
}
}
if (f == 0) {
for (k = 0; k < r; k++) {
if (cake[k][j] == '.') {
p++;
cake[k][j] = 'e';
}
}
}
}
cout << p << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[17];
vector<long long> vc;
void sinh(int k, bool zero) {
if (k > 9) {
long long res = 0;
for (int i = (1); i <= (9); ++i) res = 10 * res + a[i];
vc.push_back(res);
return;
}
if (!zero) {
a[k] = 0;
sinh(k + 1, 0);
}
a[k] = 4;
sinh(k + 1, 1);
a[k] = 7;
sinh(k + 1, 1);
return;
}
int main() {
long long l, r;
scanf("%lld%lld", &l, &r);
sinh(1, 0);
vc.push_back(4444444444LL);
long long cur = l;
long long ans = 0LL;
for (int i = (1); i <= ((int)vc.size() - 1); ++i) {
if (vc[i] >= r) {
ans += (r - cur + 1) * vc[i];
printf("%lld", ans);
return 0;
}
if (vc[i] >= cur) {
ans += (vc[i] - cur + 1) * vc[i];
cur = vc[i] + 1;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char ch[6] = {' ', 'a', 'e', 'i', 'o', 'u'};
queue<char> con;
int freq[200];
int temp[200];
int main() {
int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q;
string A, B, C;
ios::sync_with_stdio(false);
cin.tie(0);
cin >> A;
b = c = 0;
memset(freq, 0, sizeof(freq));
for (i = 0; i < A.length(); i++) {
bool flag = true;
for (j = 1; j <= 5; j++) {
if (A[i] == ch[j]) {
flag = false;
break;
}
}
if (!flag) {
b = c = 0;
memset(freq, 0, sizeof(freq));
while (!con.empty()) {
printf("%c", con.front());
con.pop();
}
printf("%c", A[i]);
} else {
if (freq[A[i]] == 0) c++;
b++;
freq[A[i]]++;
con.push(A[i]);
if (!(b >= 3 && c > 1)) continue;
bool ins = false;
d = e = 0;
memset(temp, 0, sizeof(temp));
while (!con.empty()) {
char X = con.front();
if (temp[X] == 0) e++;
d++;
temp[X]++;
if (d >= 3 && e > 1) break;
printf("%c", X);
b--;
freq[X]--;
if (freq[X] == 0) c--;
con.pop();
ins = true;
}
if (ins) printf(" ");
}
}
while (!con.empty()) {
printf("%c", con.front());
con.pop();
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
bool mn(ll& a, const ll& b) { return a == -1 || b < a ? a = b, 1 : 0; }
int N, C, D, R;
vi t[2];
vl d[2];
int a[2], m[2];
void dodp(bool c, int x) {
ll p = 0LL;
d[c].push_back(static_cast<ll>(a[0] + a[1]) * D);
for (int i = a[!c]; i >= m[c]; i--) {
if (i < a[!c]) p += (x - t[!c][i]) * C;
if (a[c]) {
if (m[c] < i)
mn(d[c].back(), d[!c][m[c]] + p + (x - t[!c][m[c]]) * C +
static_cast<ll>(i - m[c] - 1) * D);
if (i < a[!c]) mn(d[c].back(), d[!c][i] + p);
}
mn(d[c].back(), p + static_cast<ll>(i + a[c]) * D);
}
m[c] = a[!c];
t[c].push_back(x);
a[c]++;
}
int x;
char w;
int main(void) {
scanf("%d%d%d", &N, &C, &D);
R = D / C;
for (int i = 0; i < N; i++) {
scanf("%d %c", &x, &w);
dodp(w == 'W', x);
}
scanf("%d", &x);
dodp(w != 'W', x);
printf("%lld\n", d[w != 'W'].back());
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
const int MAXN = 200000 + 10;
int num[MAXN];
long long sum[MAXN], sumK[MAXN];
int k, n;
typedef struct Node {
int start, end;
long long sumKK;
} Node;
Node tree[4 * MAXN];
long long max(long long x, long long y) { return x > y ? x : y; }
void build(int now, int s, int e) {
tree[now].start = s;
tree[now].end = e;
int mid = (e - s) >> 1;
if (e == s)
tree[now].sumKK = sumK[s];
else {
build(now * 2 + 1, s, (s + e) >> 1);
build(now * 2 + 2, ((s + e) >> 1) + 1, e);
tree[now].sumKK = max(tree[now * 2 + 1].sumKK, tree[now * 2 + 2].sumKK);
}
}
long long query(int now, int s, int e) {
int start = tree[now].start, end = tree[now].end;
int mid = (start + end) >> 1;
if (start == s && end == e) return tree[now].sumKK;
if (e <= mid)
return query(now * 2 + 1, s, e);
else if (s > mid)
return query(now * 2 + 2, s, e);
else
return max(query(now * 2 + 1, s, mid), query(now * 2 + 2, mid + 1, e));
}
int main() {
n = 0;
k = 0;
scanf("%d%d", &n, &k);
sum[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
sum[i] += (sum[i - 1] + num[i]);
}
for (int i = 1; i <= n - k + 1; i++) sumK[i] = sum[i + k - 1] - sum[i - 1];
build(0, 1, n - k + 1);
long long ans = 0;
long long ansTmp = 0;
int index = 0;
for (int i = 1; i <= n - k + 1 - k; i++) {
long long x = sumK[i];
long long tmp = 0;
tmp = x + query(0, i + k, n - k + 1);
if (tmp > ans) {
ans = tmp;
index = i;
ansTmp = x;
}
}
int index2 = 0;
for (int i = index + k; i <= n - k + 1; i++) {
if (sum[i + k - 1] - sum[i - 1] == ans - ansTmp) {
index2 = i;
break;
}
}
printf("%d %d\n", index, index2);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
long long maxi = a > b ? a : b;
long long mini = a < b ? a : b;
long long ans = 0;
while (maxi > mini) {
if ((maxi % 8) == 0 && (maxi / 8) >= mini) {
maxi /= (long long)8;
ans++;
} else if (maxi % 4 == 0 && (maxi / 4) >= mini) {
maxi /= (long long)4;
ans++;
} else if (maxi % 2 == 0 && (maxi / 2) >= mini) {
maxi /= (long long)2;
ans++;
} else {
break;
}
}
if (maxi == mini) {
cout << ans << endl;
} else {
cout << -1 << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> vi(n + 1);
for (int i = 1; i <= n; i++) {
cin >> vi[i];
}
for (int i = 0; i < m; i++) {
int l, r, x;
cin >> l >> r >> x;
int pos = l;
for (int i = l; i <= r; i++) {
if (vi[i] < vi[x]) pos++;
}
if (pos == x)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int MAX = 100005, INF = (1 << 30) - 1;
struct segtree {
int a[MAX << 2], o[MAX << 2], ql, qr, qv;
void pushDown(int x) {
if (o[x]) {
a[x << 1] |= o[x];
a[x << 1 | 1] |= o[x];
o[x << 1] |= o[x];
o[x << 1 | 1] |= o[x];
o[x] = 0;
}
}
int query(int x, int l, int r) {
if (l >= ql && r <= qr) return a[x];
pushDown(x);
int mid = (l + r) >> 1, ret = INF;
if (ql <= mid) ret &= query(x << 1, l, mid);
if (qr > mid) ret &= query(x << 1 | 1, mid + 1, r);
return ret;
}
void update(int x, int l, int r) {
if (l >= ql && r <= qr) {
o[x] |= qv;
a[x] |= qv;
return;
}
pushDown(x);
int mid = (l + r) >> 1;
if (ql <= mid) update(x << 1, l, mid);
if (qr > mid) update(x << 1 | 1, mid + 1, r);
a[x] = a[x << 1] & a[x << 1 | 1];
}
} sgt;
struct query {
int l, r, v;
} q[MAX];
int n, m;
int main() {
int i;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; ++i) {
scanf("%d%d%d", &q[i].l, &q[i].r, &q[i].v);
sgt.ql = q[i].l, sgt.qr = q[i].r, sgt.qv = q[i].v;
sgt.update(1, 1, n);
}
for (i = 1; i <= m; ++i) {
sgt.ql = q[i].l, sgt.qr = q[i].r;
if (sgt.query(1, 1, n) != q[i].v) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
for (i = 1; i <= n; ++i) {
sgt.ql = sgt.qr = i;
printf("%d%c", sgt.query(1, 1, n), i == n ? '\n' : ' ');
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, ar[14][14];
long long power(long long a, long long e, long long mod) {
if (e == 0) return 1ll;
if (e == 1) return a % mod;
if (e & 1)
return ((a % mod) * power(a, e - 1, mod)) % mod;
else {
long long tmp = power(a, e / 2, mod);
return (tmp * tmp) % mod;
}
}
int main() {
cin >> n >> m >> k;
if ((n % 2 ^ m % 2) && k == -1) return puts("0");
long long zbr = power(2, (m - 1), 1e9 + 7);
zbr = power(zbr, (n - 1), 1e9 + 7);
cout << zbr << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, m, usb[300007], ps[300007], all[300007], dem1 = 0, dem2 = 0,
val;
long long use1 = 0, use2 = 0, ans = 0, dem = 0, use = 0;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin >> a >> b >> c >> m;
for (int i = 1; i <= m; i++) {
cin >> val >> s;
if (s == "USB") {
dem1++;
usb[dem1] = val;
} else if (s == "PS/2") {
dem2++;
ps[dem2] = val;
}
}
sort(usb + 1, usb + 1 + dem1);
sort(ps + 1, ps + 1 + dem2);
while (a > 0 && use1 < dem1) {
a--;
use1++;
ans += usb[use1];
}
while (b > 0 && use2 < dem2) {
b--;
use2++;
ans += ps[use2];
}
for (int i = use1 + 1; i <= dem1; i++) {
dem++;
all[dem] = usb[i];
}
for (int i = use2 + 1; i <= dem2; i++) {
dem++;
all[dem] = ps[i];
}
sort(all + 1, all + 1 + dem);
while (c > 0 && use < dem) {
use++;
c--;
ans += all[use];
}
cout << use + use1 + use2 << " " << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int sieveSPF[100005] = {0};
vector<int> pfactor;
void Sieve() {
for (int i = 2; i * i <= 100005; i++) {
if (sieveSPF[i] == 0) {
for (int j = i; j * i <= 100005; j++) {
sieveSPF[i * j] = i;
}
}
}
}
void getPf(int n) {
while (sieveSPF[n] > 1) {
pfactor.push_back(sieveSPF[n]);
n /= sieveSPF[n];
}
if (n != 1) {
pfactor.push_back(n);
}
}
void solve() {
int n, m;
cin >> n >> m;
vector<bool> collider(n + 1, false);
vector<int> isActive(n + 1, false);
for (int i = 0; i < m; i++) {
pfactor.clear();
char ch;
int k;
cin >> ch >> k;
if (sieveSPF[k] == 0) {
pfactor.push_back(k);
} else
getPf(k);
if (ch == '+') {
if (collider[k] == true) {
cout << "Already on" << endl;
} else {
bool flag = false;
for (int i = 0; i < pfactor.size(); i++) {
if (isActive[pfactor[i]]) {
cout << "Conflict with " << isActive[pfactor[i]] << endl;
flag = true;
break;
}
}
if (!flag) {
cout << "Success" << endl;
collider[k] = true;
for (int i = 0; i < pfactor.size(); i++) {
isActive[pfactor[i]] = k;
}
}
}
} else if (ch == '-') {
if (collider[k] == true) {
cout << "Success" << endl;
collider[k] = false;
for (int i = 0; i < pfactor.size(); i++) {
isActive[pfactor[i]] = false;
}
} else {
cout << "Already off" << endl;
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
Sieve();
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (int)1e8;
int nn1, nn2, kk1, kk2;
long long dp[105][105][15][15][2];
long long func(int n1, int n2, int k1, int k2, int last) {
if (n1 == nn1 && n2 == nn2) {
if (k1 <= kk1 && k2 <= kk2) return 1;
return 0;
}
if (n1 > nn1 || n2 > nn2 || k1 > kk1 || k2 > kk2) return 0;
if (dp[n1][n2][k1][k2][last] != -1) return dp[n1][n2][k1][k2][last];
long long ret = 0;
if (last == 1) {
if (k1 + 1 <= kk1) ret = (ret + func(n1 + 1, n2, k1 + 1, 0, 1)) % MOD;
if (k2 + 1 <= kk2) ret = (ret + func(n1, n2 + 1, 0, k2 + 1, 2)) % MOD;
} else if (last == 2) {
if (k1 + 1 <= kk1) ret = (ret + func(n1 + 1, n2, k1 + 1, 0, 1)) % MOD;
if (k2 + 1 <= kk2) ret = (ret + func(n1, n2 + 1, 0, k2 + 1, 2)) % MOD;
}
return dp[n1][n2][k1][k2][last] = ret;
}
int main() {
scanf("%d %d %d %d", &nn1, &nn2, &kk1, &kk2);
for (int i = 0; i < 105; i++)
for (int j = 0; j < 105; j++)
for (int k = 0; k < 15; k++)
for (int kk = 0; kk < 15; kk++)
dp[i][j][k][kk][0] = dp[i][j][k][kk][1] = -1;
long long ans = (func(1, 0, 1, 0, 1) + func(0, 1, 0, 1, 2)) % MOD;
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
const int M = 60;
struct path {
int id, x, y;
path() {}
path(int a, int b, int c) {
id = a;
x = b;
y = c;
}
} p[N];
int n, k, tot;
int m[5][M];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= 4; i++)
for (int j = 1; j <= n; j++) scanf("%d", &m[i][j]);
int sx = 2, sy = 1, sum = 0, cnt = 0;
while (cnt <= 20000 && sum != k) {
int tx = sx, ty, x, y;
if (sx == 2)
ty = sy + 1;
else
ty = sy - 1;
if (ty > n) tx++, ty--;
if (ty < 1) tx--, ty++;
y = ty;
if (tx == 2)
x = 1;
else
x = 4;
if (m[tx][ty] != 0) {
if (m[tx][ty] == m[x][y])
p[++tot] = path(m[tx][ty], x, y), sum++, m[tx][ty] = 0;
else if (!m[sx][sy])
p[++tot] = path(m[tx][ty], sx, sy), swap(m[tx][ty], m[sx][sy]);
}
sx = tx;
sy = ty;
cnt++;
}
if (sum == k) {
printf("%d\n", tot);
for (int i = 1; i <= tot; i++)
printf("%d %d %d\n", p[i].id, p[i].x, p[i].y);
puts("");
} else
puts("-1");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxx = 1000010;
const double pi = acos(-1.0);
const double eps = 1e-15;
long long t, n, m;
long long ans = 0, total = 0, sum = 0, sum1 = 0, sum2 = 0, cnt = 0, pos = 0,
res = 0, l1 = 0, l2 = 0;
long long h[maxx], rk[maxx], sa[maxx], ta[maxx], tp[maxx], lg[maxx];
long long st[maxx][21];
char c[maxx], s[maxx];
void Qsort() {
for (int i = 0; i <= m; i++) ta[i] = 0;
for (int i = 1; i <= n; i++) ta[rk[i]]++;
for (int i = 1; i <= m; i++) ta[i] += ta[i - 1];
for (int i = n; i >= 1; i--) sa[ta[rk[tp[i]]]--] = tp[i];
}
void f() {
m = 100;
for (int i = 1; i <= n; i++) rk[i] = s[i] - 'a' + 1, tp[i] = i;
Qsort();
for (int w = 1, p = 0; p < n; m = p, w <<= 1) {
p = 0;
for (int i = 1; i <= w; i++) tp[++p] = n - w + i;
for (int i = 1; i <= n; i++)
if (sa[i] > w) tp[++p] = sa[i] - w;
Qsort();
swap(tp, rk);
rk[sa[1]] = p = 1;
for (int i = 2; i <= n; i++)
rk[sa[i]] =
(tp[sa[i]] == tp[sa[i - 1]] && tp[sa[i] + w] == tp[sa[i - 1] + w])
? p
: ++p;
}
}
void get() {
long long k = 0;
for (int i = 1; i <= n; i++) {
if (k) k--;
int j = sa[rk[i] - 1];
while (s[i + k] == s[j + k]) k++;
st[rk[i]][0] = h[rk[i]] = k;
}
lg[0] = -1;
for (int i = 1; i <= n; i++) lg[i] = lg[i / 2] + 1;
for (int i = 1; i <= lg[n]; i++)
for (int j = 1; j + (1 << i) - 1 <= n; j++)
st[j][i] = min(st[j][i - 1], st[j + (1 << (i - 1))][i - 1]);
}
long long query(long long l, long long r) {
if (l == r) return n;
if (l > r) swap(l, r);
l++;
long long le = lg[r - l + 1];
return min(st[l][le], st[r - (1 << (le)) + 1][le]);
}
int main() {
scanf("%s", c + 1);
scanf("%s", s + 1);
long long len = strlen(c + 1);
if (c[1] == '1') {
for (int i = 1; i <= len; i++)
if (c[i] == '1')
c[i] = '0';
else
c[i] = '1';
}
n = strlen(s + 1);
for (int i = 1; i <= len; i++)
if (c[i] == '0')
sum1++;
else {
sum2++;
if (!res) res = i - 1;
}
f(), get();
for (long long i = 1; i <= n; i++) {
l1 = i, sum = sum1 * i;
if (sum >= n) break;
if ((n - sum) % sum2) continue;
pos = res * l1 + 1, l2 = (n - sum) / sum2;
long long u = 0;
for (long long i = 1, p = 1; i <= n; p++) {
if (c[p] == '0') {
if (query(rk[1], rk[i]) < l1) {
u = 1;
break;
}
i += l1;
} else {
if (query(rk[pos], rk[i]) < l2) {
u = 1;
break;
}
i += l2;
}
}
if (!u) {
if (l1 != l2 || query(rk[1], rk[pos]) < l1) ans++;
}
}
printf("%lld", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
long long n, m = (1 << 15) - 1, a[N];
map<vector<long long>, long long> mp;
long long solve(long long x) {
long long res = 0;
while (x) {
x &= (x - 1);
res++;
}
return res;
}
signed main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 0; i < (1 << 15); i++) {
vector<long long> v;
long long x = solve((a[1] & m) ^ (long long)i);
for (int j = 2; j <= n; j++)
v.push_back(x - solve((a[j] & m) ^ (long long)i));
mp[v] = (long long)i;
}
for (int i = 0; i < (1 << 15); i++) {
vector<long long> v;
long long x = solve((a[1] >> 15) ^ (long long)i);
for (int j = 2; j <= n; j++)
v.push_back(solve((a[j] >> 15) ^ (long long)i) - x);
if (mp.count(v)) {
printf("%lld", ((long long)i << 15) + mp[v]);
return 0;
}
}
puts("-1");
return 0;
}
| 8 |
#include <bits/stdc++.h>
inline int in() {
int k = 0;
char ch = getchar();
bool p = 1;
while (ch < '-') ch = getchar();
if (ch == '-') ch = getchar(), p = 0;
while (ch > '-') k = k * 10 + ch - '0', ch = getchar();
return p ? k : -k;
}
const int N = 5e5 + 5;
std::vector<int> G[N << 1];
int tot, o[N];
char s[N];
inline void add(int u, int v) { G[u].push_back(v), G[v].push_back(u); }
void work() {
for (int i = 1; i <= tot; ++i) G[i].clear();
int n = tot = in(), le = 0;
for (int i = 2; i <= n; ++i) add(in(), in());
scanf("%s", s + 1);
for (int i = 1; i <= n; ++i)
if (s[i] == 'W')
add(i, tot + 1), add(tot + 1, tot + 2), add(tot + 1, tot + 3), tot += 3;
for (int i = 1; i <= tot; ++i)
if (G[i].size() >= 4)
return puts("White"), void();
else if (G[i].size() == 1)
++le;
for (int i = 1; i <= tot; ++i)
if (G[i].size() == 3) {
int cnt = 0;
for (int j = 0; j < 3; ++j) cnt += G[G[i][j]].size() >= 2;
if (cnt >= 2) return puts("White"), void();
}
if (le <= 3) return puts("Draw"), void();
puts(tot & 1 ? "White" : "Draw");
}
int main() {
for (int t = in(); t; --t) work();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int ans = 0;
int p = 1;
int diff;
if (a > b)
diff = a - b;
else
diff = b - a;
for (int i = 0; i < diff / 2; i++) {
ans += 2 * p;
p++;
}
ans += diff % 2 * p;
cout << ans << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
long long x, y;
cin >> x >> y;
long long dp[n + 1];
dp[1] = x;
for (long long i = 2; i <= n; i++) {
if (i % 2 == 0)
dp[i] = min(dp[i - 1] + x, dp[i / 2] + y);
else {
dp[i] = min(dp[i - 1] + x, dp[i / 2] + y + x);
dp[i] = min(dp[i], dp[(i + 1) / 2] + y + x);
}
}
cout << dp[n];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
pair<int, int> a[5002];
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
sort(a, a + n);
int flag = 0;
int m = a[0].second;
for (int i = 1; i < n; i++) {
if (a[i].second >= m)
m = a[i].second;
else
m = a[i].first;
}
cout << m << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h, t;
int adj[100005];
struct e {
int u, v, pre;
e(int U = 0, int V = 0, int P = 0) {
u = U;
v = V;
pre = P;
}
} edge[200005];
int dex;
int vis[100005], chuo, vis2[1000005], chuo2;
int a1[100005], a2[100005], a3[100005], deg[100005];
inline void add(int x, int y) {
edge[++dex] = e(x, y, adj[x]);
adj[x] = dex;
}
int main() {
scanf("%d%d%d%d", &n, &m, &h, &t);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
deg[u]++;
deg[v]++;
}
for (int p = 1; p <= dex; p++) {
int ux = edge[p].u, vx = edge[p].v;
if (deg[ux] - 1 < h || deg[vx] - 1 < t) continue;
++chuo;
for (int i = adj[ux]; i; i = edge[i].pre) {
int v = edge[i].v;
if (v == vx) continue;
vis[v] = chuo;
}
++chuo2;
*a1 = *a2 = *a3 = 0;
for (int i = adj[vx]; i; i = edge[i].pre) {
int v = edge[i].v;
if (v == ux) continue;
if (vis[v] == chuo) {
a3[++*a3] = v;
vis2[v] = chuo2;
} else {
a2[++*a2] = v;
}
}
for (int i = adj[ux]; i; i = edge[i].pre) {
int v = edge[i].v;
if (v == vx) continue;
if (vis2[v] != chuo2) a1[++*a1] = v;
}
if ((*a1 + *a3 >= h) && (*a3 - max(0, h - *a1) + *a2 >= t)) {
puts("YES");
printf("%d %d\n", ux, vx);
int cnt = h;
for (; *a1 && cnt;) {
cnt--;
printf("%d ", a1[*a1]);
--*a1;
}
for (; *a3 && cnt;) {
cnt--;
printf("%d ", a3[*a3]);
--*a3;
}
puts("");
cnt = t;
for (; *a2 && cnt;) {
cnt--;
printf("%d ", a2[*a2]);
--*a2;
}
for (; *a3 && cnt;) {
--cnt;
printf("%d ", a3[*a3]);
--*a3;
}
return 0;
}
}
puts("NO");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int t;
cin >> t;
bool pr[26];
char nxt[26];
for (int i = 0; i < 26; i++) {
nxt[i] = '0';
pr[i] = false;
}
string s;
for (int i = 0; i < t; i++) {
cin >> s;
char prev = s[0];
int j = 1;
for (; j < s.length(); j++) {
pr[s[j] - 'a'] = true;
nxt[prev - 'a'] = s[j];
prev = s[j];
}
--j;
if (nxt[s[j] - 'a'] == '0') nxt[s[j] - 'a'] = '1';
}
for (int i = 0; i < 26; i++) {
if (pr[i] == false && nxt[i] != '0') {
char j = 'a' + i;
while (j >= 'a' && j <= 'z' && nxt[j - 'a'] != '0') {
cout << j;
j = nxt[j - 'a'];
}
}
}
cout << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using min_pq = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using max_pq = priority_queue<T>;
const int inf = 2e9 + 5;
const long long l_inf = 2e18 + 5;
const int mod_v = 1e9 + 7;
const int max_n = 2e5 + 5;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
template <typename T>
T gcd(T a, T b) {
while (b) {
T temp = a % b;
a = b;
b = temp;
}
return a;
}
template <typename T>
tuple<T, T, T> egcd(T a, T b) {
T x1 = 1, x2 = 0, y1 = 0, y2 = 1;
while (b) {
T q = a / b, r = a % b;
T new_x = x1 - q * x2, new_y = y1 - q * y2;
x1 = x2, y1 = y2, x2 = new_x, y2 = new_y;
a = b, b = r;
}
return make_tuple(a, x1, y1);
}
inline long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
template <typename T>
inline T mod(T a, T b = mod_v) {
return (a % b + b) % b;
}
template <typename T>
inline T mod_inv(T a, T b = mod_v) {
return mod(get<1>(egcd(a, b)), b);
}
template <typename T>
inline T sum(T a, T b, T m = mod_v) {
return mod(mod(a, m) + mod(b, m), m);
}
template <typename T>
inline T difference(T a, T b, T m = mod_v) {
return mod(mod(a, m) - mod(b, m), m);
}
inline long long product(long long a, long long b, long long m = mod_v) {
return mod(mod(a, m) * mod(b, m), m);
}
inline long long quotient(long long a, long long b, long long m = mod_v) {
return mod(mod(a, m) * mod_inv(b, m), m);
}
template <typename T, typename T2>
ostream &operator<<(ostream &s, const pair<T, T2> &p) {
return s << p.first << ' ' << p.second << ' ';
}
template <typename T, typename T2>
istream &operator>>(istream &s, pair<T, T2> &p) {
return s >> p.first >> p.second;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<T> &v) {
for (auto it : v) s << it << ' ';
return s;
}
template <typename T>
istream &operator>>(istream &s, vector<T> &v) {
for (auto it = (v).begin(), it_ = (v).end(); it != it_; ++it) s >> *it;
return s;
}
template <typename T>
void read_range(T beg, T end) {
while (beg != end) cin >> *beg++;
}
template <typename T>
void print_range(T beg, T end) {
while (beg != end) cout << *beg++ << ' ';
}
struct reader {
template <typename T>
reader &operator,(T &v) {
cin >> v;
return *this;
}
} rdr;
struct debugger {
template <typename T>
debugger &operator,(const T &v) {
cerr << v << ", ";
return *this;
}
} dbg;
int ar[max_n], n;
int len[2][max_n];
int st[4 * max_n], lazy[4 * max_n];
stack<pair<int, int>> s;
void add_p(pair<int, int> val, int i) {
while (s.size() and s.top().first > val.first) {
len[i][s.top().second] = abs(val.second - s.top().second);
s.pop();
}
s.push(val);
}
void assign_lazy(int i, int v) { lazy[i] = max(lazy[i], v); }
int propagate(int i, int l, int r) {
if (lazy[i]) st[i] = max(lazy[i], st[i]);
if (l != r)
assign_lazy((2 * (i)), lazy[i]), assign_lazy((2 * (i) + 1), lazy[i]);
lazy[i] = 0;
return st[i];
}
int query(int pos, int i = 1, int l = 1, int r = n) {
if (pos < l or pos > r) return 0;
propagate(i, l, r);
if (pos == l and l == r) return st[i];
return max(query(pos, (2 * (i)), l, (l + r) / 2),
query(pos, (2 * (i) + 1), (l + r) / 2 + 1, r));
}
int update(int l, int r, int v, int i = 1, int cur_l = 1, int cur_r = n) {
propagate(i, cur_l, cur_r);
if (cur_l > r or cur_r < l) return st[i];
if (l <= cur_l and cur_r <= r) {
assign_lazy(i, v);
return propagate(i, cur_l, cur_r);
}
return st[i] = max(
update(l, r, v, (2 * (i)), cur_l, (cur_l + cur_r) / 2),
update(l, r, v, (2 * (i) + 1), (cur_l + cur_r) / 2 + 1, cur_r));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
read_range(ar, ar + n);
for (int i = 0, i_ = (n); i < i_; ++i) add_p(make_pair(ar[i], i + 1), 0);
add_p(make_pair(0, n + 1), 0);
while (s.size()) s.pop();
for (int i = n; i > 0; --i) add_p(make_pair(ar[i - 1], i), 1);
add_p(make_pair(0, 0), 1);
for (int i = 0, i_ = (n); i < i_; ++i)
update(1, len[0][i + 1] + len[1][i + 1] - 1, ar[i]);
for (int i = 1; i <= n; ++i) cout << query(i) << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int p[4];
int main() {
int mn = 100500, a, b;
for (int i = 0; i < 4; i++) {
scanf("%d", &p[i]);
if (mn > p[i]) mn = p[i];
}
scanf("%d%d", &a, &b);
int kol = 0;
if (b < mn)
kol = b - a + 1;
else
kol = mn - a;
if (kol > 0)
printf("%d\n", kol);
else
printf("0\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int l, r;
cin >> l >> r;
int ans = (r / 2 + 1);
if (ans < l) {
ans = r % l;
} else {
ans = r - ans;
}
cout << ans << endl;
}
}
| 0 |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
using namespace std;
#define speed ios_base::sync_with_stdio(false),cout.tie(0),cin.tie(0)
#define fre freopen("in.txt","r",stdin),freopen("out.txt","w",stdout)
#define N 2*1000005
#define M 2002
#define st first
#define nd second
#define endl "\n"
#define pii pair<ll,ll>
#define pb push_back
#define mp make_pair
#define inf 1e9+7
#define mid (start+end)/2
#define sp " "
#define Endl endl
#define mod 1000000007
typedef long long int ll;
ll n,m,k,ans;
string s;
void solve(){
cin>>s;
n=s.length();
ll k=0;
for (int i = 0; i < s.length(); ++i)
{
if(s[i]!='a')
k=1;
}
if(k==0)
cout<<"NO\n";
else{
cout<<"YES\n";
ll p=-1;
for (int i = n-1; i >= 0; --i)
{
if(s[i]!='a'){
p=i;
break;
}
}
ll pp=n-p-1;
for (int i = 0; i < pp; ++i)
{
cout<<s[i];
}
cout<<'a';
for (int i = pp; i < n; ++i)
{
cout<<s[i];
}
cout<<endl;
}
}
int main()
{
speed;
//fre;
int TT=1;
cin>>TT;
while(TT--)solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, count = 0, temp;
bool flag = false;
cin >> a >> b;
while (a != b && a != 0 && b != 0) {
count += a / b;
a = a % b;
if (a == 1 || b == 1) {
flag = true;
break;
}
if (a < b) {
temp = a;
a = b;
b = temp;
}
}
if (flag == true) {
cout << count + ((a == 1) ? b : a);
return 0;
}
if (a != 0 && b != 0)
cout << count + 1;
else
cout << count;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[3509];
int n, t, m, k;
deque<int> d;
vector<int> v;
int main() {
scanf("%d", &t);
for (int i = 0; i < t; i++) {
scanf("%d%d%d", &n, &m, &k);
for (int j = 0; j < n; j++) scanf("%d", &a[j]);
int g = n - m + 1;
v.clear();
for (int j = g - 1; j < n; j++) v.push_back(max(a[j - g + 1], a[j]));
int vlen = v.size();
int g2 = vlen - k;
g2 = max(1, g2);
d.clear();
for (int i = 0; i < g2; i++) {
if (!d.empty()) {
while (!d.empty() && d.back() > v[i]) d.pop_back();
}
d.push_back(v[i]);
}
int ans = d.front();
for (int i = g2; i < vlen; i++) {
if (!d.empty() && d.front() == v[i - g2]) {
d.pop_front();
}
while (!d.empty() && d.back() > v[i]) d.pop_back();
d.push_back(v[i]);
ans = max(ans, d.front());
}
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int Maxn = 2005;
const int Maxk = 11;
int n, k;
int a[Maxn];
int dp[Maxn][1 << Maxk];
int res;
int getMask(int mask, int add) {
if (add == 4 && mask & 1) return (mask & 1 << k - 1) | 1 << 1;
int tims = add == 2 ? 0 : 1;
while (tims + 1 < k)
if (!(mask & 1 << tims))
return mask | 1 << tims;
else {
mask ^= 1 << tims;
tims++;
}
return mask | 1 << tims;
}
int main() {
scanf("%d %d", &n, &k);
dp[0][0] = 1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
for (int j = 0; j < 1 << k; j++)
if (dp[i][j]) {
int nj;
if (a[i] == 0 || a[i] == 2) {
nj = getMask(j, 2);
dp[i + 1][nj] = (dp[i + 1][nj] + dp[i][j]) % mod;
}
if (a[i] == 0 || a[i] == 4) {
nj = getMask(j, 4);
dp[i + 1][nj] = (dp[i + 1][nj] + dp[i][j]) % mod;
}
}
}
for (int j = 0; j < 1 << k; j++)
if (j & 1 << k - 1) res = (res + dp[n][j]) % mod;
printf("%d\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int N = 1000000;
int upper[N], lower[N], p[N][3][3];
char s[N + 1], t[N + 1];
int f(char ch) {
if (ch == 'R') return 0;
if (ch == 'G') return 1;
return 2;
}
int main() {
scanf("%s%s", s, t);
int x, y;
x = y = 0;
do {
if (!t[y + 1])
++x;
else {
if (s[x] == t[y]) ++x;
++y;
}
upper[x] = y;
} while (t[y + 1] || s[x + 1]);
x = y = 0;
do {
if (s[x] == t[y]) ++y;
++x;
lower[x] = y;
} while (s[x + 1]);
for (int i = 1; t[i]; ++i) {
++p[i][f(t[i])][f(t[i - 1])];
for (int j = 0; j < 3; ++j)
for (int k = 0; k < 3; ++k) p[i][j][k] += p[i - 1][j][k];
}
long long ans = upper[0] - lower[0] + 1;
for (int i = 1; s[i] && (upper[i - 1] != lower[i - 1] ||
t[upper[i - 1] + 1] || s[i - 1] != t[upper[i - 1]]);
++i) {
ans += upper[i] - lower[i] + 1;
if (s[i] != s[i - 1])
ans -=
p[upper[i]][f(s[i - 1])][f(s[i])] - p[lower[i]][f(s[i - 1])][f(s[i])];
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, C, col[100100], ord[100100], ft;
bool vis[100100];
vector<int> g[100100], rg[100100];
vector<int> f[100100];
void init() {
for (int i = 1; i <= n; i++) g[i].clear(), rg[i].clear(), col[i] = 0;
}
void dfs(int x) {
vis[x] = 1;
for (int i = 0; i < g[x].size(); i++)
if (!vis[g[x][i]]) dfs(g[x][i]);
ord[ft--] = x;
}
void rdfs(int x) {
col[x] = C;
f[C].push_back(x);
for (int i = 0; i < rg[x].size(); i++)
if (!col[rg[x][i]]) rdfs(rg[x][i]);
}
int u[100100], v[100100];
int deg[100100];
stack<int> in;
int ans;
int func(vector<int> &fi, vector<int> &se) {
assert(!fi.empty());
assert(!se.empty());
assert(fi.back() == ans);
while (1) {
if (fi.empty()) return 2;
if (se.empty()) return 1;
printf("? %d %d\n", fi.back(), se.back());
fflush(stdout);
int cur;
scanf("%d", &cur);
if (cur) {
ans = fi.back();
se.pop_back();
} else {
ans = se.back();
fi.pop_back();
}
}
}
void del(int x) {
for (int y : g[x]) {
deg[y]--;
if (!deg[y]) in.push(y);
}
}
int main() {
int m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u[i], &v[i]);
g[u[i]].push_back(v[i]);
rg[v[i]].push_back(u[i]);
}
ft = n;
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
C = 0;
for (int i = 1; i <= n; i++)
if (!col[ord[i]]) C++, rdfs(ord[i]);
for (int i = 1; i <= n; i++) g[i].clear();
for (int i = 1; i <= m; i++) {
if (col[u[i]] != col[v[i]]) g[col[u[i]]].push_back(col[v[i]]);
}
for (int i = 1; i <= C; i++) {
sort(g[i].begin(), g[i].end());
int sz = unique(g[i].begin(), g[i].end()) - g[i].begin();
g[i].resize(sz);
}
for (int i = 1; i <= C; i++) {
for (int j : g[i]) deg[j]++;
}
for (int i = 1; i <= C; i++)
if (!deg[i]) in.push(i);
assert(!in.empty());
int x = in.top();
ans = f[x].back();
while (in.size() > 1) {
int x = in.top();
in.pop();
int y = in.top();
in.pop();
int cur = func(f[x], f[y]);
if (cur == 1)
del(y), in.push(x);
else
del(x), in.push(y);
}
printf("! %d\n", ans);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char str[1000];
while (scanf("%s", str) != EOF) {
int len = strlen(str);
for (int i = 0; i < len; i++) {
if (str[i] == '/') {
i++;
while (i < len && str[i] == '/') {
str[i] = '.';
i++;
}
i--;
}
}
int k = 0;
char ts[1000];
for (int i = 0; i < len; i++)
if (str[i] != '.') ts[k++] = str[i];
while (k > 0 && ts[k - 1] == '/') k--;
ts[k] = '\0';
if (k == 0)
printf("/\n");
else
printf("%s\n", ts);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
unordered_set<int> b;
cin >> n;
int prev = n;
int x;
while (n--) {
cin >> x;
b.insert(x);
while (b.find(prev) != b.end()) {
cout << prev << " ";
prev--;
}
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n, r, par[N], c[N], leaf1[N], leaf2[N], m, x[10 * N], y[10 * N], d[10 * N];
vector<pair<int, int> > ke[N];
void dfs(int u) {
for (auto e : ke[u])
if (e.second != par[u]) {
int v = e.second;
c[v] = e.first;
par[v] = u;
dfs(v);
leaf2[u] = leaf1[u];
leaf1[u] = leaf1[v];
}
if (leaf1[u] == 0) leaf1[u] = u;
}
void leaf_leaf(int u, int v, int c) {
m += 1;
x[m] = u;
y[m] = v;
d[m] = c;
}
void leaf_node(int v, int u, int c) {
if (u == r) leaf_leaf(v, r, c);
if (u == r || u == v) return;
int z = v != leaf1[u] ? leaf1[u] : leaf2[u];
leaf_leaf(v, z, c / 2);
leaf_leaf(v, r, c / 2);
leaf_leaf(r, z, -c / 2);
}
void node_node(int u, int v, int c) {
leaf_node(leaf1[v], u, c);
leaf_node(leaf1[v], v, -c);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
ke[u].push_back(pair<int, int>(c, v));
ke[v].push_back(pair<int, int>(c, u));
}
for (int i = 1; i <= n; ++i) {
if (ke[i].size() == 2) {
puts("NO");
return 0;
}
if (ke[i].size() == 1) r = i;
}
dfs(r);
for (int i = 1; i <= n; ++i)
if (i != r) node_node(par[i], i, c[i]);
printf("YES\n%d\n", m);
for (int i = 1; i <= m; ++i) printf("%d %d %d\n", x[i], y[i], d[i]);
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
string up, dn;
vector<vector<vector<long long int>>> dp;
vector<long long int> waysUp = {3, 3, 1, 2};
vector<long long int> waysDn = {2, 1, 3, 3};
long long int getSubUp(long long int i) {
string s = up.substr(i - 1, 2);
long long int mask = 0;
if (s[0] == 'X') mask |= (1 << 1);
if (s[1] == 'X') mask |= (1 << 0);
return mask;
}
long long int getSubDn(long long int i) {
string s = dn.substr(i - 1, 2);
long long int mask = 0;
if (s[0] == 'X') mask |= (1 << 1);
if (s[1] == 'X') mask |= (1 << 0);
return mask;
}
void recalc_1(long long int i) {
long long int maskUp = getSubUp(i);
long long int maskDn = getSubDn(i);
for (long long int b11 = 0; b11 < 2; b11++) {
for (long long int b21 = 0; b21 < 2; b21++) {
if ((up[i - 1] == '0' || (b11 == 1)) &&
(dn[i - 1] == '0' || (b21 == 1))) {
long long int nmaskUp = (b11 << 1) | maskUp;
long long int nmaskDn = (b21 << 1) | maskDn;
for (long long int b12 = 0; b12 < 2; b12++) {
for (long long int b22 = 0; b22 < 2; b22++) {
long long int updMaskUp = (b12 << 1) | b11;
long long int updMaskDn = (b22 << 1) | b21;
dp[i][nmaskUp][nmaskDn] =
max(dp[i][nmaskUp][nmaskDn], dp[i - 1][updMaskUp][updMaskDn]);
}
}
}
}
}
}
void recalc_2(long long int i) {
long long int BaseMaskUp = getSubUp(i);
long long int BaseMaskDn = getSubDn(i);
for (long long int j = 0; j < 4; j++) {
long long int wup = waysUp[j];
long long int wdn = waysDn[j];
if ((BaseMaskUp & wup) == 0 && (BaseMaskDn & wdn) == 0) {
long long int maskUp = BaseMaskUp | wup;
long long int maskDn = BaseMaskDn | wdn;
for (long long int b11 = 0; b11 < 2; b11++) {
for (long long int b21 = 0; b21 < 2; b21++) {
if ((((BaseMaskUp >> 1) & 1) == 0 || (b11 == 1)) &&
(((BaseMaskDn >> 1) & 1) == 0 || (b21 == 1)) &&
(((wup >> 1) & 1) == 0 || b11 == 0) &&
(((wdn >> 1) & 1) == 0 || b21 == 0)) {
long long int nmaskUp = (b11 << 1) | maskUp;
long long int nmaskDn = (b21 << 1) | maskDn;
for (long long int b12 = 0; b12 < 2; b12++) {
for (long long int b22 = 0; b22 < 2; b22++) {
long long int updMaskUp = (b12 << 1) | b11;
long long int updMaskDn = (b22 << 1) | b21;
dp[i][nmaskUp][nmaskDn] =
max(dp[i][nmaskUp][nmaskDn],
dp[i - 1][updMaskUp][updMaskDn] + 1);
}
}
}
}
}
}
}
}
signed main() {
cin >> up >> dn;
long long int n = up.size();
if (n <= 1) {
cout << 0 << "\n";
return 0;
}
dp.resize(n,
vector<vector<long long int>>(4, vector<long long int>(4, -1e15)));
long long int baseMaskUp = getSubUp(1);
long long int baseMaskDn = getSubDn(1);
dp[1][baseMaskUp][baseMaskDn] = 0;
for (long long int i = 0; i < 4; i++) {
long long int wup = waysUp[i];
long long int wdn = waysDn[i];
if ((baseMaskUp & wup) == 0 && (baseMaskDn & wdn) == 0) {
long long int maskUp = baseMaskUp | wup;
long long int maskDn = baseMaskDn | wdn;
dp[1][maskUp][maskDn] = 1;
}
}
for (long long int i = 2; i < n; i++) {
recalc_1(i);
recalc_2(i);
}
long long int ans = 0;
for (long long int mask1 = 0; mask1 < 4; mask1++) {
for (long long int mask2 = 0; mask2 < 4; mask2++) {
ans = max(ans, dp[n - 1][mask1][mask2]);
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool comp(string a, string b) { return a.length() < b.length(); }
int main() {
int n;
cin >> n;
vector<string> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end(), comp);
vector<string> res;
while (!v.empty()) {
string ans = v.back();
v.pop_back();
int counter = v.size();
int cur = v.size() - 1;
while (counter) {
if (v[cur].find(ans[0]) != string::npos) {
ans.insert(ans.begin(), v[cur].begin(), v[cur].end());
v.erase(v.begin() + cur);
counter = v.size();
cur = v.size() - 1;
continue;
}
if (v[cur].find(ans[ans.length() - 1]) != string::npos) {
ans.insert(ans.end(), v[cur].begin(), v[cur].end());
v.erase(v.begin() + cur);
counter = v.size();
cur = v.size() - 1;
continue;
}
counter--;
cur--;
}
res.push_back(ans);
}
string big = "";
for (int i = 0; i < res.size(); i++) {
big += res[i];
}
int cur = 0;
while (cur < big.length()) {
while (cur + 1 < big.length() &&
big.find(big[cur], cur + 1) != string::npos) {
big.erase(big.begin() + big.find(big[cur], cur + 1));
}
cur++;
}
cout << big << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int _front;
int m[100010];
bool s[100010];
vector<int> v[100010];
void solve() {
int _now = 0;
for (int i = 0; i < v[_front].size(); i++) {
if (v[_front][i] == i + 1) {
_now = i + 1;
continue;
}
}
cout << (n - _now) * 2 - k + 1 << endl;
}
int main() {
cin >> n >> k;
int tmp;
for (int i = 0; i < k; i++) {
scanf("%d", &m[i]);
v[i].clear();
for (int j = 0; j < m[i]; j++) {
scanf("%d", &tmp);
v[i].push_back(tmp);
}
}
for (int i = 0; i < k; i++) {
if (v[i].size() && v[i][0] == 1) {
_front = i;
}
}
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int a[100005];
int n;
int main() {
int i;
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
mp[a[i]]++;
}
bool ok = 1;
if (mp[0] >= 2) ok = 0;
int cnt = 0;
for (auto &k : mp) {
if (k.second >= 3) ok = 0;
if (k.second >= 2) cnt++;
if (k.second >= 2 && mp[k.first - 1] > 0) ok = 0;
}
if (cnt >= 2) ok = 0;
if (ok == 0) {
cout << "cslnb";
return 0;
}
sort(a + 1, a + n + 1);
long long s = 0;
for (i = 1; i <= n; i++) {
s += a[i] - (i - 1);
}
if (s % 2)
cout << "sjfnb";
else
cout << "cslnb";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 1e3;
vector<pair<char, int> > ans;
int a[MAXN];
int main() {
string s;
cin >> s;
int n = s.size();
for (int i = n - 1; i >= 0; i--) a[n - i - 1] = s[i] - '0';
for (int i = 0; i < n; i++) {
while (a[i] == 0 && i + 1 < n) i++;
if (a[i + 1] == 0)
ans.push_back(make_pair('-', i));
else {
ans.push_back(make_pair('+', i));
while (a[i] == 1) i++;
while (a[i + 1] == 1) {
ans.push_back(make_pair('+', i));
i++;
while (a[i] == 1) i++;
}
ans.push_back(make_pair('-', i));
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
if (ans[i].first == '-')
ans[i].first = '+';
else
ans[i].first = '-';
for (int i = ans.size() - 1; i >= 0; i--)
cout << ans[i].first << "2^" << ans[i].second << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<double, int> Freq;
int main() {
double N;
double W;
scanf("%lf%lf", &N, &W);
vector<double> vec;
for (int i = 0; i < N * 2; i++) {
double a;
scanf("%lf", &a);
vec.push_back(a);
}
sort((vec).begin(), (vec).end());
double ans = min(vec[0] * 1.0, vec[(int)(N + 1e-9)] / 2.0);
ans = min(ans, W * 1.0 / (N * 3.0));
printf("%.9lf\n", 3 * N * ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
vector<pair<long long, long long> > vec;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
vec.push_back(make_pair(x, i));
}
sort(vec.begin(), vec.end());
long long sum = 0;
vector<long long> v;
for (long long i = 0; i < vec.size(); i++) {
sum += vec[i].first;
if (sum <= k) {
v.push_back(vec[i].second);
}
}
cout << v.size() << endl;
long long p = v.size();
for (long long i = 0; i < v.size(); i++) {
if (i == p - 1) {
cout << v[i] << endl;
break;
}
cout << v[i] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, i = 0, N;
cin >> n >> a >> b;
N = n;
int p = a >= b ? b : a;
int q = a >= b ? a : b;
while (n > 2) {
if (p <= (n / 2) && q > (n / 2))
break;
else {
p %= (n / 2);
q %= (n / 2);
n /= 2;
i++;
if (p == 0) p += n;
if (q == 0) q += n;
int x = p >= q ? q : p;
int y = p >= q ? p : q;
p = x;
q = y;
}
}
int x = log2(N);
if (i == 0)
cout << "Final!" << endl;
else
cout << x - i << endl;
}
| 2 |
#include<iostream>
#include<stdio.h>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<string>
#include<stack>
#include<set>
#include<map>
#include<bitset>
#include<unordered_map>
#include<time.h>
#include<cstdlib>
typedef long long ll;
typedef unsigned long long ull;
//#pragma comment(linker, "/STACK:1024000000,1024000000")
//#pragma comment(linker, "/STACK:36777216") //hdu 扩栈
#define mm(a) memset(a,0,sizeof(a))
#define lr rt<<1
#define rr rt<<1|1
#define sync std::ios::sync_with_stdio(false);std::cin.tie(0);
#define inf 0x3f3f3f3f
//#define eqs 1e-8
#define lb(x) (x&(-x))
#define ch(a) (int(a-'a')+1)
#define rep(i, a, b) for(int i=a;i<=b;i++)
#define mkp(a, b) make_pair(a,b)
using namespace std;
typedef pair<int,int> pii;
//const double pi=acos(-1);
const int maxn=500010; // 要开大！！！
//const ll Mod=1000000007;
const ll Mod = 998244353;
int vis[maxn];
int a[maxn],ans[maxn];
int t[maxn<<2];
void pushup(int rt)
{
t[rt]=min(t[lr],t[rr]);
}
void build(int rt,int l,int r)
{
t[rt]=9999999;
if(l==r)
{
t[rt]=a[l];
return;
}
int mid=(l+r)/2;
build(lr,l,mid);
build(rr,mid+1,r);
pushup(rt);
return;
}
int query(int rt,int l,int r,int L,int R)
{
if(l>=L&&r<=R)
return t[rt];
int mid=(l+r)/2;
if(mid<L)
return query(rr,mid+1,r,L,R);
else if(mid+1>R)
return query(lr,l,mid,L,R);
return min(query(rr,mid+1,r,L,R),query(lr,l,mid,L,R));
}
int main()
{
sync;
int T;
cin>>T;
int n;
while(T--)
{
cin>>n;
for(int i=1;i<=n;i++)
{
vis[i]=0;
ans[i]=0;
}
for(int i=1;i<=n;i++)
{
cin>>a[i];
vis[a[i]]++;
}
int f=0;
for(int i=1;i<=n;i++)
{
if(vis[i]==0)
f=1;
}
if(f==0)
ans[1]=1;
build(1,1,n);
int L=1,R=n;
for(int i=1;i<=n;i++)
{
if(query(1,1,n,L,R)!=i)
{
break;
}
if(a[L]==i&&a[R]>i)
{
L++;
ans[n-i+1]=1;
continue;
}
if(a[R]==i&&a[L]>i)
{
R--;
ans[n-i+1]=1;
continue;
}
// cout<<i<<' '<<L<<' '<<R<<' '<<query(1,1,n,L,R)<<endl;
ans[n-i+1]=1;
break;
}
for(int i=1;i<=n;i++)
{
cout<<ans[i];
}
cout<<endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char c[] = {'A', 'E', 'I', 'O', 'U', 'Y', 'a', 'e', 'i', 'o', 'u', 'y'};
bool isAlpha(char c) {
if (c >= 'a' && c <= 'z') return true;
if (c >= 'A' && c <= 'Z') return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
string s, t;
getline(cin, s);
char cc;
for (int i = 0; i < s.length(); i++) {
if (isAlpha(s[i])) {
cc = s[i];
}
}
bool flag = false;
for (int i = 0; i < 12; i++) {
if (cc == c[i]) {
flag = true;
break;
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace A {
int sgn(int64_t val) { return val ? val < 0 ? -1 : 1 : 0; }
void solve() {
int n, k;
int64_t x;
scanf("%d%d%" PRId64, &n, &k, &x);
vector<int64_t> v(n);
for (int64_t& it : v) scanf("%" PRId64, &it);
int zer = 0;
for (int64_t& it : v) zer += !it;
if (zer > k) {
for (int64_t& it : v) printf("%" PRId64 " ", it);
printf("\n");
return;
}
if (zer) {
for (int i = 0; i < n; ++i)
if (v[i] == 0) {
if (zer == 1) {
zer = i;
break;
}
v[i] += x, --k, --zer;
}
} else
zer = -1;
bool neg = false;
for (int64_t& it : v) neg ^= (it < 0);
if (zer != -1) {
--k;
v[zer] += x * (neg ? 1 : -1);
neg = true;
}
if (!neg) {
int ansi = 0;
for (int i = 1; i < n; ++i)
if (abs(v[i]) < abs(v[ansi])) ansi = i;
int sign = sgn(v[ansi]);
while (k && sgn(v[ansi]) * sign != -1) v[ansi] -= sign * x, --k;
if (sgn(v[ansi]) * sign == -1) neg ^= true;
}
if (neg) {
set<pair<int64_t, int> > vs;
for (int i = 0; i < n; ++i) vs.insert({abs(v[i]), i});
while (k) {
int it = vs.begin()->second;
vs.erase(vs.begin());
v[it] += sgn(v[it]) * x;
vs.insert({abs(v[it]), it});
--k;
}
}
for (int64_t& it : v) printf("%" PRId64 " ", it);
printf("\n");
}
} // namespace A
int main() {
A::solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct p {
int l, r;
};
p P[101];
bool can_move(int x, int y) {
int qw = x;
while (1) {
if (x == y) return true;
if (P[x - 1].r == 0) return false;
x = P[x - 1].r;
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
p w;
w.l = l;
w.r = r;
P[i] = w;
}
for (int i = 0; i < n; i++) {
if (P[i].r == 0) {
for (int j = 0; j < n; j++) {
if (P[j].l == 0 && j + 1 != P[i].l && !can_move(j + 1, i + 1)) {
P[i].r = j + 1;
P[j].l = i + 1;
break;
}
}
}
}
for (int i = 0; i < n; i++) {
cout << P[i].l << " " << P[i].r << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
struct Matrix {
int n;
vector<vector<long long>> v;
Matrix() {}
Matrix(vector<vector<long long>> &_v) : n(_v.size()) { v = move(_v); }
Matrix(int _n, long long _x) : n(_n), v(n, vector<long long>(n, _x)) {}
Matrix(int _n) : n(_n), v(n, vector<long long>(n, 0)) {
for (int i = 0; i < _n; i++) {
v[i][i] = 1;
}
}
vector<long long> &operator[](int idx) { return v[idx]; }
Matrix operator*(Matrix &rhs) {
Matrix res(n, 0);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
res[i][j] = (res[i][j] + v[i][k] * rhs[k][j]) % mod;
return move(res);
}
Matrix operator^(long long x) {
Matrix res(n), a(v);
for (; x; x >>= 1, a = a * a)
if (x & 1) {
res = res * a;
}
return move(res);
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
long long n, b, k, x;
cin >> n >> b >> k >> x;
vector<vector<long long>> v(x, vector<long long>(x, 0));
vector<int> a(n);
for (auto &x : a) {
cin >> x;
}
for (int i = 0; i < x; i++) {
for (int k = 0; k < n; k++) {
int nxt = (i * 10 + a[k]) % x;
v[i][nxt]++;
}
}
Matrix M(v);
M = M ^ b;
cout << M[0][k] << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
inline long long read() {
int X = 0;
bool flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
X = (X << 1) + (X << 3) + ch - '0';
ch = getchar();
}
if (flag) return X;
return ~(X - 1);
}
inline void write(long long x) {
if (x < 0) x = ~x + 1, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
int n, m, k;
int main() {
cin >> n >> m >> k;
m -= n;
int tmp = 1;
int l = k, r = k;
while (m > 0) {
if (r - l + 1 <= m) {
m -= r - l + 1;
tmp++;
}
if (l > 1) l--;
if (r < n) r++;
if (r == n && l == 1) {
tmp += m / n;
break;
}
}
cout << tmp << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double squrt(int64_t num) {
double high = num, low = 0, mid;
while (high - low > 0.00001) {
mid = low + (high - low) / 2;
if (mid * mid > num) {
high = mid;
} else {
low = mid;
}
}
return mid;
}
void solve() {
int64_t num;
cin >> num;
for (int64_t i = 2; i * i < num; i++) {
if (num % i != 0) continue;
for (int64_t j = i + 1; j * j <= (num / i); j++) {
int64_t x;
if (num % (i * j) == 0) {
int64_t x = num / (i * j);
if (x != i && i != j && x != j) {
cout << "YES"
<< "\n";
cout << i << " " << j << " " << x << "\n";
return;
}
}
}
}
cout << "NO"
<< "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
cout.precision(10);
cout << fixed;
;
int64_t test;
cin >> test;
while (test--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200005];
bool vis[200005];
int col[200005];
vector<int> ans[3];
void dfs(int x, int p) {
vis[x] = 1;
col[x] = 3 - col[p];
ans[col[x]].push_back(x);
for (auto i : v[x]) {
if (vis[i] && col[i] == col[x]) {
cout << -1;
exit(0);
}
if (!vis[i]) dfs(i, x);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int n, m;
cin >> n >> m;
for (int i = 1; i < m + 1; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
col[0] = 1;
for (int i = 1; i < n + 1; i++) {
if (!vis[i]) {
dfs(i, 0);
}
}
cout << ans[1].size() << '\n';
for (auto i : ans[1]) cout << i << " ";
cout << '\n';
cout << ans[2].size() << '\n';
for (auto i : ans[2]) cout << i << " ";
cout << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, d1, d2;
float prx1, pry1, prx2, pry2;
float trx1, try1, trx2, try2;
int broj;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> d1 >> d2;
cin >> prx1 >> pry1 >> prx2 >> pry2;
bool moze = true;
broj = 0;
for (int i = 1; i < n; ++i) {
cin >> trx1 >> try1 >> trx2 >> try2;
float dltx1 = (trx1 - prx1) / 2155.0, dlty1 = (try1 - pry1) / 2155.0,
dltx2 = (trx2 - prx2) / 2155.0, dlty2 = (try2 - pry2) / 2155.0;
for (float j = 0.0; j < 2155.0; ++j) {
float dist = (prx1 + j * dltx1 - prx2 - j * dltx2) *
(prx1 + j * dltx1 - prx2 - j * dltx2) +
(pry1 + j * dlty1 - pry2 - j * dlty2) *
(pry1 + j * dlty1 - pry2 - j * dlty2);
if (dist - d1 * d1 <= 0.0011 && moze) {
++broj;
moze = false;
}
if (d2 * d2 - dist <= 0.0011) moze = true;
}
prx1 = trx1, pry1 = try1, prx2 = trx2, pry2 = try2;
}
cout << broj;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool issq(long long x) {
long long y = sqrtl(x);
y -= 2;
y = max(y, 1LL);
for (int i = 0; i < 4; i++) {
if ((y + i) * (y + i) == x) return true;
}
return false;
}
long long modexp(long long a, long long b) {
long long ans = 1;
while (b) {
if ((b & 1)) {
ans *= a;
ans %= 1000000007;
}
a *= a;
a %= 1000000007;
b >>= 1;
}
return ans;
}
void mult(long long *ans, long long by) {
(*ans) *= by;
(*ans) %= 1000000007;
}
void div(long long *ans, long long by) {
(*ans) *= modexp(by, 1000000007 - 2);
(*ans) %= 1000000007;
}
long long nCr[1000][1000];
vector<int> compsz;
vector<int> pre;
long long dp[301][301];
long long getans(int pos, int num_edges) {
if (pos == 1) {
return num_edges + 1 == compsz[pos] ? 1 : 0;
}
long long &ans = dp[pos][num_edges];
if (ans != -1) return ans;
ans = 0;
for (int prv = 0; prv < pre[pos - 1]; prv++) {
int y = pre[pos - 1] - prv + 1;
if (y < 0) break;
long long all = getans(pos - 1, prv);
for (int br = 0; br <= prv; br++) {
int edges_to_add = num_edges - (prv - br);
int num_non_edges = compsz[pos] - edges_to_add - br;
int use = num_non_edges + br;
if (edges_to_add < 0 || num_non_edges < 0 || use < 0) {
continue;
}
long long cans = 1;
mult(&cans, nCr[prv][br]);
mult(&cans, nCr[y][num_non_edges]);
if (use == 0) {
if (edges_to_add != 0) {
cans = 0;
}
} else {
mult(&cans, nCr[edges_to_add + use - 1][use - 1]);
}
mult(&cans, all);
ans += cans;
ans %= 1000000007;
}
}
return ans;
}
long long fact[1000];
int main() {
int n;
memset(dp, -1, sizeof(dp));
scanf("%d", &n);
vector<long long> a(n);
for (int i = 0; i < n; i++) {
scanf("%Ld", &a[i]);
}
vector<int> used(n, 0);
nCr[0][0] = 1;
fact[0] = 1;
for (int i = 1; i < 1000; i++) {
nCr[i][0] = 1;
fact[i] = (fact[i - 1] * i) % 1000000007;
for (int j = 1; j <= i; j++) {
nCr[i][j] = (nCr[i - 1][j] + nCr[i - 1][j - 1]) % 1000000007;
}
}
long long ans = 1;
compsz.push_back(0);
for (int i = 0; i < n; i++) {
map<int, int> ccomp;
int sz = 0;
if (used[i]) continue;
for (int j = i; j < n; j++) {
if (issq(a[i] * a[j])) {
ccomp[a[j]]++;
sz++;
used[j] = 1;
}
}
compsz.push_back(sz);
mult(&ans, fact[sz]);
for (const auto &it : ccomp) {
}
}
pre.resize(n + 1);
for (int i = 1; i < (int)compsz.size(); i++) {
pre[i] = pre[i - 1];
pre[i] += compsz[i];
}
mult(&ans, getans((int)compsz.size() - 1, 0));
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long k;
unsigned long long tmp, mx, my, mz, x, y, z;
cin >> mx >> my >> mz >> k;
mx--;
my--;
mz--;
if (my < mz) {
tmp = mz;
mz = my;
my = tmp;
}
if (mx < my) {
tmp = mx;
mx = my;
my = tmp;
}
if (my < mz) {
tmp = mz;
mz = my;
my = tmp;
}
x = y = z = k / 3;
k -= (x + y + z);
if (k != 0) {
x++;
k--;
}
if (k != 0) {
y++;
k--;
}
if (mz < z) {
int tmp = (z - mz);
x += tmp / 2;
y += tmp - tmp / 2;
z = mz;
}
if (my < y) {
x += (y - my);
y = my;
}
if (mx < x) x = mx;
cout << (x + 1) * (y + 1) * (z + 1) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const double eps = 1e-12;
const double PI = acos(-1.0);
const long long mod = 998244353;
const int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1},
dy[8] = {1, 0, -1, 0, 1, -1, 1, -1};
void debug() { cerr << '\n'; }
template <typename T, typename... Args>
void debug(T x, Args... args) {
cerr << "[ " << x << " ] , ";
debug(args...);
}
mt19937 mt19937random(
std::chrono::system_clock::now().time_since_epoch().count());
long long getRandom(long long l, long long r) {
return uniform_int_distribution<long long>(l, r)(mt19937random);
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long qmul(long long a, long long b) {
long long r = 0;
while (b) {
if (b & 1) r = (r + a) % mod;
b >>= 1;
a = (a + a) % mod;
}
return r;
}
long long qpow(long long a, long long n) {
long long r = 1;
while (n) {
if (n & 1) r = (r * a) % mod;
n >>= 1;
a = (a * a) % mod;
}
return r;
}
long long qpow(long long a, long long n, long long p) {
long long r = 1;
while (n) {
if (n & 1) r = (r * a) % p;
n >>= 1;
a = (a * a) % p;
}
return r;
}
const int maxn = 200050;
struct BIT {
int a[maxn];
void update(int p, int v) {
for (; p < maxn; p += p & -p) a[p] += v;
}
int query(int p) {
int r = 0;
for (; p; p -= p & -p) r += a[p];
return r;
}
int query(int l, int r) { return query(r) - query(l - 1); }
} tree;
int a[200050], b[200050];
void solve() {
int n;
cin >> n;
for (int i = (1); i <= (n); i++) cin >> a[i], b[i] = a[i];
sort(b + 1, b + n + 1);
int m = unique(b + 1, b + n + 1) - (b + 1);
for (int i = (1); i <= (n); i++)
a[i] = lower_bound(b + 1, b + m + 1, a[i]) - b;
for (int i = (1); i <= (m); i++) tree.a[i] = 0;
long long r = 0;
for (int i = (1); i <= (n); i++) {
r += min(tree.query(a[i] - 1), tree.query(m) - tree.query(a[i]));
tree.update(a[i], 1);
}
cout << r << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
for (int t = 1; t <= T; t++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)(2e9);
const long long linf = (long long)(2e18);
void solve();
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(20);
solve();
return 0;
}
void solve() {
int n;
cin >> n;
int answer = 0, cost = 10000000;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
cost = min(cost, b);
answer += a * cost;
}
cout << answer << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
inline long long int fast_pow(long long int a, long long int b,
long long int mod) {
long long int res = 1;
a %= mod;
while (b > 0) {
if (b & 1) res = res * a % mod;
b >>= 1;
a = a * a % mod;
}
return res;
}
inline bool isPrime(long long int a) {
for (long long int i = 2; i * i <= a; i++)
if (a % i == 0) return 0;
return 1;
}
int n, a, b, c, ans, cnt, anss = INT_MAX;
string person1, likes, person2, temp;
pair<string, string> arr[42];
map<string, int> nametoidx;
vector<string> per;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
nametoidx["Anka"] = 0;
nametoidx["Chapay"] = 1;
nametoidx["Cleo"] = 2;
nametoidx["Troll"] = 3;
nametoidx["Dracul"] = 4;
nametoidx["Snowy"] = 5;
nametoidx["Hexadecimal"] = 6;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> person1 >> likes >> person2;
arr[i] = make_pair(person1, person2);
}
cin >> a >> b >> c;
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5 - i; j++) {
int t = max(a / (i + 1), max(b / (j + 1), c / (5 - i - j))) -
min(a / (i + 1), min(b / (j + 1), c / (5 - i - j)));
temp = "";
if (anss > t) {
per.clear();
anss = t;
for (int k = 0; k < i + 1; k++) temp += "0";
for (int k = 0; k < j + 1; k++) temp += "1";
for (int k = 0; k < 5 - i - j; k++) temp += "2";
per.push_back(temp);
} else if (anss == t) {
for (int k = 0; k < i + 1; k++) temp += "0";
for (int k = 0; k < j + 1; k++) temp += "1";
for (int k = 0; k < 5 - i - j; k++) temp += "2";
per.push_back(temp);
}
}
}
cout << anss << ' ';
for (int j = 0; j < per.size(); j++) {
temp = per[j];
do {
cnt = 0;
for (int i = 0; i < n; i++) {
if (temp[nametoidx[arr[i].first]] == temp[nametoidx[arr[i].second]])
cnt++;
}
ans = max(ans, cnt);
} while (next_permutation(temp.begin(), temp.end()));
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
puts("");
}
inline unsigned long long rnd() {
return ((unsigned long long)rand() << 30 ^ rand()) << 4 | rand() % 4;
}
const int N = 600005;
const long long P = 1e18;
int q[N], Q[N], nxt[N], S, top;
char ch[N];
unsigned long long sum, ans;
long long a, b;
map<int, int> M;
char s[3];
vector<int> v[N];
int ask(int pos) { return Q[lower_bound(q + 1, q + top + 1, pos) - q]; }
int main() {
int n = read();
for (int i = (int)(0); i <= (int)(n - 1); i++) {
scanf("%s", s);
ch[i] = (s[0] - 'a' + S) % 26 + 'a';
int w = read() ^ (ans & ((1 << 30) - 1));
nxt[i] = i ? nxt[i - 1] : 0;
if (i) {
while (ch[nxt[i]] != ch[i] && nxt[i]) {
v[i].push_back(nxt[i]);
nxt[i] = nxt[nxt[i] - 1];
}
if (ch[nxt[i]] == ch[i]) {
for (auto j : v[nxt[i]]) v[i].push_back(j);
nxt[i]++;
}
for (auto j : v[i]) {
int t = ask(i - j);
M[t]--;
sum -= t;
}
}
if (ch[0] == ch[i]) {
M[w]++;
sum += w;
}
if (i) {
M[w] += 0;
auto it = M.find(w), j = it;
for (j++; j != M.end(); M.erase(j++)) {
sum -= ((long long)j->first - w) * j->second;
it->second += j->second;
}
}
while (top && Q[top] >= w) top--;
q[++top] = i;
Q[top] = w;
ans += sum;
S = (S + sum) % 26;
b += sum;
if (b >= P) {
a++;
b -= P;
}
if (a) {
write(a);
for (long long j = P / 10; j > 1; j /= 10)
if (b < j) putchar('0');
writeln(b);
} else
writeln(b);
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50050, mod = 998244353;
inline long long read() {
char ch = getchar();
long long x = 0, f = 0;
while (ch < '0' || ch > '9') f |= ch == '-', ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
struct matrix {
int a[16][16];
matrix() { memset(a, 0, sizeof(a)); }
matrix operator*(const matrix &t) const {
matrix ans;
for (int i = (0); i <= (15); i++)
for (int k = (0); k <= (15); k++)
for (int j = (0); j <= (15); j++)
ans.a[i][j] = (ans.a[i][j] + 1ll * a[i][k] * t.a[k][j]) % mod;
return ans;
}
};
int n, f[maxn][2][2][2][2][2], g[maxn][2][2][2][2][2];
void work(int f[][2][2][2][2][2]) {
for (int i = (0); i <= (n - 2); i++)
for (int a = (0); a <= (1); a++)
for (int b = (0); b <= (1); b++)
for (int c = (0); c <= (1); c++)
for (int d = (0); d <= (1); d++)
for (int e = (0); e <= (1); e++) {
if (b) {
if (!a) {
for (int x = (c); x <= (1); x++)
for (int y = (d); y <= (1); y++)
for (int z = (e); z <= (1); z++)
f[i + 1][1][1][x][y][z] =
(f[i + 1][1][1][x][y][z] + f[i][a][b][c][d][e]) %
mod;
}
for (int x = (c); x <= (1); x++)
for (int y = (d); y <= (1); y++)
for (int z = (e); z <= (1); z++)
f[i + 1][0][a][x][y][z] =
(f[i + 1][0][a][x][y][z] + f[i][a][b][c][d][e]) % mod;
if (c && d && !e)
f[i + 1][1][a][0][0][0] =
(f[i + 1][1][a][0][0][0] + f[i][a][b][c][d][e]) % mod;
} else {
for (int x = (c); x <= (1); x++)
for (int y = (d); y <= (1); y++)
for (int z = (e); z <= (1); z++)
f[i + 1][1][a][x][y][z] =
(f[i + 1][1][a][x][y][z] + f[i][a][b][c][d][e]) % mod;
}
}
}
int main() {
n = read();
f[0][1][1][0][0][0] = 1;
work(f);
g[0][1][0][0][0][0] = 1;
work(g);
int fs = (f[n - 1][1][1][1][1][0] + f[n - 1][1][1][1][1][1]) % mod;
int gs = (g[n - 1][0][1][1][1][0] + g[n - 1][0][1][1][1][1]) % mod;
printf("%d\n", (fs + gs) % mod);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 301010;
int n, m, i, v[N], a, b, vis[N], Vis[N];
vector<int> e[N], E[N];
queue<int> Q;
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &v[i]);
for (i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
e[a].push_back(b);
E[b].push_back(a);
}
for (i = 1; i <= n; i++)
if (v[i] == 1) Q.push(i), vis[i] = 1;
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = 0; i < e[x].size(); i++)
if ((vis[e[x][i]] == 0) && (v[e[x][i]] != 1)) {
vis[e[x][i]] = 1;
Q.push(e[x][i]);
}
}
for (i = 1; i <= n; i++)
if (v[i] == 2) Q.push(i), Vis[i] = 1;
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (int i = 0; i < E[x].size(); i++)
if (Vis[E[x][i]] == 0) {
Vis[E[x][i]] = 1;
if (v[E[x][i]] != 1) Q.push(E[x][i]);
}
}
for (i = 1; i <= n; i++)
if (vis[i] + Vis[i] == 2)
printf("1\n");
else
printf("0\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void __print(long long x) { cout << x; }
void __print(long x) { cout << x; }
void __print(unsigned x) { cout << x; }
void __print(unsigned long x) { cout << x; }
void __print(unsigned long long x) { cout << x; }
void __print(float x) { cout << x; }
void __print(double x) { cout << x; }
void __print(long double x) { cout << x; }
void __print(char x) { cout << '\'' << x << '\''; }
void __print(const char *x) { cout << '\"' << x << '\"'; }
void __print(const string &x) { cout << '\"' << x << '\"'; }
void __print(bool x) { cout << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cout << '{';
__print(x.first);
cout << ',';
__print(x.second);
cout << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cout << '{';
for (auto &i : x) cout << (f++ ? "," : ""), __print(i);
cout << "}";
}
void _print() { cout << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
const long long INF64 = 1e18;
const long long INF32 = 1e9;
const long long BIG = (long long)(1e9 + 239);
const long long MOD = 1000000007;
const double PI = 2.0 * acos(0.0);
const double EPS = static_cast<double>(1e-10);
const long long day[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const long long dx[4] = {0, 1, 0, -1};
const long long dy[4] = {1, 0, -1, 0};
mt19937 rnd(239);
typedef vector<vector<long long>> matrix;
void FILEIO() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
long long mostSignDigit(long long n) {
double k = log10(n);
return pow(10, k - floor(k));
}
long long numOfDigits(long long n) { return floor(log10(n)) + 1; }
bool isPowerOfTwo(long long x) { return x && (!(x & (x - 1))); }
bool allPositive(vector<long long> &a) {
return all_of(begin(a), end(a), [](long long x) { return x > 0; });
}
bool anyPositive(vector<long long> &a) {
return any_of(begin(a), end(a), [](long long x) { return x > 0; });
}
bool nonePositive(vector<long long> &a) {
return none_of(begin(a), end(a), [](long long x) { return x > 0; });
}
const long double INF = 1e100;
struct Point {
long double x, y;
Point() : x(0), y(0) {}
Point(long double x, long double y) : x(x), y(y) {}
Point(const Point &p) : x(p.x), y(p.y) {}
bool operator<(const Point &p) const {
return make_pair(x, y) < make_pair(p.x, p.y);
}
bool operator==(const Point &p) const {
return make_pair(x, y) == make_pair(p.x, p.y);
}
bool operator!=(const Point &p) const { return !(*this == p); }
Point operator=(const Point &p) {
x = p.x, y = p.y;
return *this;
}
Point operator+(const Point &p) const { return Point(x + p.x, y + p.y); }
Point operator-(const Point &p) const { return Point(x - p.x, y - p.y); }
Point operator*(long double c) const { return Point(x * c, y * c); }
Point operator/(long double c) const { return Point(x / c, y / c); }
};
long double cross(Point p, Point q) { return p.x * q.y - p.y * q.x; }
long double dot(Point p, Point q) { return p.x * q.x + p.y * q.y; }
long double Det(Point a, Point b, Point c) { return cross(b - a, c - a); }
long double dist(Point p, Point q) { return sqrt(dot(p - q, p - q)); }
long double dist2(Point p, Point q) { return dot(p - q, p - q); }
long double area(Point a, Point b, Point c) {
return fabs(cross(b - a, c - a) / 2.0);
}
long double area2(Point a, Point b, Point c) {
return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;
}
Point rotateCCW90(Point p) { return Point(-p.y, p.x); }
Point rotateCW90(Point p) { return Point(p.y, -p.x); }
Point rotateCCW(Point p, long double t) {
return Point(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));
}
long long sign(long double x) {
long long ans = x < -EPS ? -1 : (x > EPS);
return ans;
}
ostream &operator<<(ostream &os, const Point &p) {
os << "(" << p.x << "," << p.y << ")";
return os;
}
Point projectPointLine(Point a, Point b, Point c) {
return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
struct Circle {
Point c;
long double r;
};
struct Segment {
Point a, b;
};
Segment circleCircleIntersection(Circle c1, Circle c2) {
Segment s = {{INF, INF}, {INF, INF}};
long double d = dist(c1.c, c2.c);
if (d > c1.r + c2.r or d + min(c1.r, c2.r) < max(c1.r, c2.r)) return s;
long double x = (d * d - c2.r * c2.r + c1.r * c1.r) / (2.0 * d),
y = sqrt(c1.r * c1.r - x * x);
Point v = (c2.c - c1.c) / d;
s.a = c1.c + v * x + rotateCW90(v) * y;
if (y > 0) s.b = c1.c + v * x - rotateCW90(v) * y;
return s;
}
long double angle(Point a) {
if (a.x == 0)
if (a.y > 0)
return PI / 2.0;
else
return 3.0 * PI / 2.0;
if (a.y == 0)
if (a.x > 0)
return 0;
else
return PI;
long double res = atan(a.y / a.x);
if (a.x < 0) return res + PI;
if (a.y < 0) return res + 2.0 * PI;
return res;
}
long double angle(Point A, Point B) {
long double d = dot(A, B), c = fabs(cross(A, B));
return atan2(c, d);
}
void solve() {
Circle a, b;
cin >> a.c.x >> a.c.y >> a.r;
cin >> b.c.x >> b.c.y >> b.r;
long double d = dist(a.c, b.c);
if (d >= a.r + b.r) {
cout << setprecision(10) << fixed << 0 << endl;
return;
}
if (d + min(a.r, b.r) <= max(a.r, b.r)) {
cout << setprecision(10) << fixed << PI * min(a.r, b.r) * min(a.r, b.r)
<< endl;
return;
}
long double angA = acos((a.r * a.r + d * d - b.r * b.r) / (2.0 * a.r * d));
long double angB = acos((b.r * b.r + d * d - a.r * a.r) / (2.0 * b.r * d));
long double SA = a.r * a.r * sin(2.0 * angA) / 2.0;
long double SB = b.r * b.r * sin(2.0 * angB) / 2.0;
long double S1, S2;
S1 = angA * a.r * a.r - SA;
S2 = angB * b.r * b.r - SB;
cout << setprecision(10) << fixed << S1 + S2 << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie();
{ solve(); }
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.