solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int solve() {
double x1, y1, r1, x2, y2, r2, d;
cin >> x1 >> y1 >> r1 >> x2 >> y2 >> r2;
d = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
double ans;
if (d > r1 + r2) {
ans = (d - r1 - r2) / 2;
} else {
double xr = max(r1, r2);
double nr = min(r1, r2);
if (d + nr >= xr)
ans = 0;
else {
ans = (xr - d - nr) / 2;
}
}
cout << ans;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include<iostream>
#include<cstdio>
#include<map>
#include<algorithm>
using namespace std;
typedef long long ll;
map<ll,int> t;
int cnt;
const int N=2e5+5;
int n;ll k,a[N]={0},as[N];
int bit[N]={0};
void add(int x,int val) {
while(x<cnt) bit[x]+=val,x+=x&-x;
}
int sum(int x) {
int s=0;while(x) s+=bit[x],x-=x&-x;return s;
}
int main() {
scanf("%d%lld",&n,&k);
t.clear();
for(int i=1;i<=n;i++) scanf("%lld",a+i),a[i]-=k,a[i]+=a[i-1],as[i]=a[i];
ll ans=0;
sort(as+1,as+1+n);
cnt=1;
for(int i=1;i<=n;i++) if(!t.count(as[i])) t[as[i]]=cnt++;
for(int i=1;i<=n;i++) {
if(a[i]>=0) ans++;
ans+=sum(t[a[i]]);
add(t[a[i]],1);
}
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long maxN = 1e5 + 5;
const long long N = 1e6;
int n;
int a[8], b[maxN];
int d[maxN][8];
vector<int> v;
int id[maxN];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
p;
int main() {
ios_base::sync_with_stdio(0);
for (long long i = 1; i <= 6; i++) cin >> a[i];
sort(a + 1, a + 1 + 6, greater<int>());
cin >> n;
for (long long i = 1; i <= n; i++) cin >> b[i];
sort(b + 1, b + 1 + n);
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= 6; j++) {
d[i][j] = b[i] - a[j];
v.push_back(d[i][j]);
}
}
for (long long i = 1; i <= n; i++) id[i] = 1;
int cuoi = v[0];
for (long long i = 1; i <= n; i++)
p.push(pair<long long, long long>(d[i][1], i)), cuoi = max(cuoi, d[i][1]);
sort(v.begin(), v.end());
int res = 1e9 + 5;
int pret = -1;
for (auto t : v) {
if (t == pret) continue;
pret = t;
bool kt = 1;
while (1) {
pair<long long, long long> tmp = p.top();
if (tmp.first < t) {
p.pop();
long long i = tmp.second;
while (id[i] <= 6 && d[i][id[i]] < t) id[i]++;
if (id[i] > 6) {
kt = 0;
break;
}
cuoi = max(cuoi, d[i][id[i]]);
p.push(pair<long long, long long>(d[i][id[i]], i));
} else {
break;
}
}
if (kt == 1)
res = min(res, cuoi - t);
else
break;
}
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[1010], nxt[1010][10][1010];
int cnt[10], n, dp[260][10], num;
inline bool check(int len) {
num = 0;
if (len * 8 > n) return false;
for (int i = 0; i < 256; i++)
for (int j = 0; j <= 8; j++) dp[i][j] = 0x3f3f3f3f;
dp[0][0] = 1;
for (int mask = 0; mask < 256; ++mask) {
for (int num = 0; num <= 8; ++num) {
if (dp[mask][num] > n) continue;
for (int i = 1; i <= 8; ++i) {
if (mask & (1 << (i - 1))) continue;
dp[mask | (1 << (i - 1))][num] =
min(dp[mask | (1 << (i - 1))][num], nxt[dp[mask][num]][i][len] + 1);
dp[mask | (1 << (i - 1))][num + 1] =
min(dp[mask | (1 << (i - 1))][num + 1],
nxt[dp[mask][num]][i][len + 1] + 1);
}
}
}
for (int i = 8; i >= 0; --i)
if (dp[255][i] <= n + 1) {
num = i;
return true;
}
return false;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 8; j++)
for (int k = 1; k <= n; k++) nxt[i][j][k] = 0x3f3f3f3f;
for (int i = 1; i <= n; ++i) {
memset(cnt, 0, sizeof(cnt));
for (int j = i; j <= n; ++j) {
cnt[a[j]]++;
nxt[i][a[j]][cnt[a[j]]] = j;
}
}
int L = 0, R = n, ans = 0;
while (L <= R) {
int mid = ((L + R) >> 1);
if (check(mid)) {
ans = mid * 8 + num;
L = mid + 1;
} else
R = mid - 1;
}
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T getint() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * p;
}
template <typename T1, typename T2>
bool umin(T1 &x, const T2 &y) {
if (x > y) return x = y, true;
return false;
}
template <typename T1, typename T2>
bool umax(T1 &x, const T2 &y) {
if (x < y) return x = y, true;
return false;
}
const int maxn = (int)5e5 + 10;
const int inf = (int)1e9 + 5;
const int mod = 998244353;
const long long llinf = (long long)1e18 + 5;
const double pi = acos(-1.0);
int a[maxn];
int n, m;
int b[maxn];
int p[maxn];
long long dp[maxn];
vector<int> idx[maxn];
long long get(int l, int r, int val) {
long long ret = 0;
for (int i = l; i <= r; ++i) {
if (a[i] >= val) {
ret += p[i];
}
}
return ret;
}
long long get2(int l, int r, int val) {
long long ret = 0;
for (int i = l; i <= r; ++i) {
if (a[i] <= val && p[i] < 0) {
ret += p[i];
}
}
return ret;
}
long long fw[maxn];
long long fw2[maxn];
void addfw(long long fw[maxn], int x, long long val) {
for (; x < maxn; x |= x + 1) {
fw[x] += val;
}
}
long long get(long long fw[maxn], int r) {
long long ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) {
ret += fw[r];
}
return ret;
}
long long get(long long fw[maxn], int l, int r) {
if (l > r) return 0;
return get(fw, r) - get(fw, l - 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
cin >> p[i];
}
a[n + 1] = n + 1;
cin >> m;
for (int i = 1; i <= m; ++i) {
cin >> b[i];
}
b[++m] = n + 1;
for (int i = 0; i <= n + 1; ++i) {
idx[a[i]].push_back(i);
}
vector<int> order(n + 2);
for (int i = 0; i <= n + 1; ++i) {
order[i] = i;
}
sort(order.begin(), order.end(), [&](int x, int y) { return a[x] < a[y]; });
for (int i = 0; i <= n + 2; ++i) {
addfw(fw, i, p[i]);
}
int rev_ptr = 0;
int ptr = 0;
for (int i = 1; i <= m; ++i) {
while (rev_ptr < order.size() && a[order[rev_ptr]] < b[i - 1] + 1) {
int j = order[rev_ptr++];
addfw(fw, j, -p[j]);
}
while (ptr < order.size() && a[order[ptr]] <= b[i - 1]) {
int j = order[ptr++];
if (p[j] < 0) {
addfw(fw2, j, p[j]);
}
}
int prev_ptr = 0;
int prev_sz = (int)idx[b[i - 1]].size();
long long best = llinf;
for (int cur : idx[b[i]]) {
dp[cur] = llinf;
while (prev_ptr < prev_sz && idx[b[i - 1]][prev_ptr] < cur) {
int prv = idx[b[i - 1]][prev_ptr++];
long long val = dp[prv] - get(fw, prv) - get(fw2, prv);
if (dp[prv] != llinf) {
best = min(best, val);
}
}
if (best != llinf) {
dp[cur] = best + get(fw, cur - 1) + get(fw2, cur - 1);
}
}
}
long long ans = llinf;
for (int cur : idx[b[m]]) {
ans = min(ans, dp[cur]);
}
if (ans == llinf)
cout << "NO" << endl;
else
cout << "YES" << endl << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, arr[100005], i, c, arr2[100005];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
arr2[i] = arr[i];
}
c = 0;
sort(arr, arr + n);
for (i = 0; i < n; i++) {
if (arr[i] != arr2[i]) c++;
}
if (c <= 2)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
inline long long rd() {
long long x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * w;
}
int to[N << 1], nt[N << 1], hd[N], tot = 1;
inline void add(int x, int y) {
++tot, to[tot] = y, nt[tot] = hd[x], hd[x] = tot;
++tot, to[tot] = x, nt[tot] = hd[y], hd[y] = tot;
}
struct chn {
int to[N], nt[N], hd[N], tot;
void add(int x, int y) { ++tot, to[tot] = y, nt[tot] = hd[x], hd[x] = tot; }
} l1, l2;
struct node {
long long x;
int i;
bool operator<(const node &bb) const { return x > bb.x; }
};
set<int>::iterator it;
int w[N];
struct HEAP {
priority_queue<node> q1;
set<int> q2;
long long dt;
void del() {
while (q2.size() && q2.count(q1.top().i))
q2.erase(q2.find(q1.top().i)), q1.pop();
}
void push(int i) { q1.push((node){w[i] - dt, i}); }
void pop(int i) { q2.insert(i); }
int size() {
del();
return q1.size() - q2.size();
}
int top() {
del();
return q1.empty() ? 1 << 30 : q1.top().x + dt;
}
} hp[N];
int n, m, fa[N], de[N], s[N], ts, ff[N];
long long ans;
inline int findf(int x) { return ff[x] == x ? x : ff[x] = findf(ff[x]); }
void merge(int x, int y) {
x = findf(x), y = findf(y);
if (hp[x].size() < hp[y].size()) swap(x, y);
while (!hp[y].q1.empty())
hp[x].q1.push(
(node){hp[y].q1.top().x + hp[y].dt - hp[x].dt, hp[y].q1.top().i}),
hp[y].q1.pop();
for (it = hp[y].q2.begin(); it != hp[y].q2.end(); ++it) hp[x].pop(*it);
hp[y].q2.clear();
ff[y] = x;
}
int main() {
n = rd(), m = rd();
for (int i = 1; i < n; ++i) add(rd(), rd());
de[1] = 1;
queue<int> q;
q.push(1);
while (!q.empty()) {
int x = q.front();
q.pop();
s[++ts] = x;
for (int i = hd[x]; i; i = nt[i]) {
int y = to[i];
if (y == fa[x]) continue;
fa[y] = x, de[y] = de[x] + 1, q.push(y);
}
}
for (int i = 1; i <= m; ++i) {
int x = rd(), y = rd();
w[i] = rd();
l1.add(x, i), l2.add(y, i);
}
for (int i = 1; i <= n; ++i) ff[i] = i;
while (ts > 1) {
int x = s[ts--], xx = findf(x);
for (int i = l1.hd[x]; i; i = l1.nt[i]) hp[xx].push(l1.to[i]);
for (int i = l2.hd[x]; i; i = l2.nt[i]) hp[xx].pop(l2.to[i]);
if (hp[xx].size() == 0) {
puts("-1");
exit(0);
}
ans += hp[xx].top(), hp[xx].dt -= hp[xx].top();
if (ts) merge(x, fa[x]);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, res;
long long a[1507][1507], d[1507][1507], sum[1507][1507], maxprefix[1507][1507],
maxsuffix[1507][1507];
int main() {
scanf("%I64d %I64d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%I64d", &a[i][j]);
sum[i][j] = sum[i][j - 1] + a[i][j];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i % 2 == 1)
d[i][j] = sum[i][j] + maxprefix[i - 1][j - 1];
else
d[i][j] = sum[i][j] + maxsuffix[i - 1][j + 1];
}
maxprefix[i][0] = -1e12;
for (int j = 1; j <= m; j++)
maxprefix[i][j] = max(maxprefix[i][j - 1], d[i][j]);
maxsuffix[i][m + 1] = -1e12;
for (int j = m; j >= 1; j--)
maxsuffix[i][j] = max(maxsuffix[i][j + 1], d[i][j]);
}
res = d[n][1];
for (int j = 2; j <= m; j++) res = max(res, d[n][j]);
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 4e3 + 9;
int a[Maxn];
int iabs(int x) { return x > 0 ? x : -x; }
int main() {
int n;
cin >> n;
for (int i = 1; i <= (n << 1); ++i) {
int x, y;
scanf("%d.%d", &x, &y);
a[i] = y;
}
int c = 0;
int s = 0;
for (int i = 1; i <= n * 2; ++i) {
if (a[i] == 0) c++;
s += a[i];
}
int a, b;
if (c >= n)
a = 0, b = 2 * n - c;
else
a = n - c, b = n;
int ans = 0x7fffffff;
for (int i = a; i <= b; ++i) {
ans = min(ans, iabs(s - 1000 * i));
}
printf("%d.%03d", ans / 1000, ans % 1000);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int f = 1, sum = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
sum = (sum << 3) + (sum << 1) + ch - '0';
ch = getchar();
}
return f * sum;
}
const int N = 200010;
struct node {
int a, b, id;
} a[N];
bool cmp(node a, node b) { return a.b < b.b || (a.b == b.b && a.a > b.a); }
int n, p, k;
priority_queue<pair<pair<int, int>, int> > q;
int main() {
n = gi();
p = gi();
k = gi();
for (int i = 1; i <= n; i++) a[i].a = gi(), a[i].b = gi(), a[i].id = i;
sort(a + 1, a + n + 1, cmp);
for (int i = p - k + 1; i <= n; i++)
q.push(make_pair(make_pair(a[i].a, i), a[i].id));
int pos = n;
for (int i = 1; i <= k; i++) {
pair<pair<int, int>, int> now = q.top();
q.pop();
printf("%d ", now.second);
pos = min(pos, now.first.second);
}
p -= k;
while (p--) printf("%d ", a[--pos].id);
puts("");
return 0;
}
| 3 |
#include <iostream>
using namespace std;
int main(void){
int n;
int sum;
int max,min;
while(1){
max = 0;
min = 500;
cin >> n;
if( n == 0 ) break;
for( int i = 0 ; i < n ; i++ ){
sum = 0;
int s[5];
for( int j = 0 ; j < 5 ; j++ ){
cin >> s[j];
sum += s[j];
}
if( max < sum ) max = sum;
if( min > sum ) min = sum;
}
cout << max << " " << min << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct segmento {
int x0, y0, x1, y1;
segmento(int a, int b, int c, int d) {
x0 = min(a, c);
x1 = max(a, c);
y0 = max(b, d);
y1 = min(b, d);
}
};
struct Evento {
int x, y;
bool e;
Evento(int a, int b, bool c) { x = a, y = b, e = c; }
bool isEntrada() { return e; }
bool operator<(const Evento &other) const {
if (y > other.y) return true;
if (y < other.y) return false;
if (e && !other.e) return true;
if (!e && other.e) return false;
return x < other.x;
}
};
vector<segmento> horizontal, vertical;
map<int, int> cx, cy;
long long bit[100001];
bool orderX(const segmento &A, const segmento &B) {
if (A.x0 < B.x0) return true;
if (A.x0 > B.x0) return false;
return A.y0 > B.y0;
}
bool orderY(const segmento &A, const segmento &B) {
if (A.y0 > B.y0) return true;
if (A.y0 < B.y0) return false;
return A.x0 < B.x0;
}
long long _merge() {
vector<segmento> h, v;
sort(horizontal.begin(), horizontal.end(), orderY);
if (horizontal.size()) h.push_back(horizontal[0]);
for (int i = 1; i < horizontal.size(); i++)
if (horizontal[i].y0 == h[h.size() - 1].y0 &&
horizontal[i].x0 <= h[h.size() - 1].x1)
h[h.size() - 1].x1 = max(h[h.size() - 1].x1, horizontal[i].x1);
else
h.push_back(horizontal[i]);
horizontal = h;
sort(vertical.begin(), vertical.end(), orderX);
if (vertical.size()) v.push_back(vertical[0]);
for (int i = 1; i < vertical.size(); i++)
if (vertical[i].x0 == v[v.size() - 1].x0 &&
vertical[i].y0 >= v[v.size() - 1].y1)
v[v.size() - 1].y1 = min(v[v.size() - 1].y1, vertical[i].y1);
else
v.push_back(vertical[i]);
vertical = v;
long long sum = 0;
for (int i = 0; i < h.size(); i++) {
sum += h[i].x1 - h[i].x0 + 1;
}
for (int i = 0; i < v.size(); i++) {
sum += v[i].y0 - v[i].y1 + 1;
}
return sum;
}
void build(vector<segmento> &all) {
vector<segmento> v, h;
for (int i = 0; i < all.size(); i++)
if (all[i].x0 == all[i].x1)
v.push_back(all[i]);
else
h.push_back(all[i]);
vertical = v, horizontal = h;
}
void compress(vector<segmento> &all) {
set<int> xs;
for (int i = 0; i < all.size(); i++) {
xs.insert(all[i].x0);
xs.insert(all[i].x1);
}
int k = 1;
for (set<int>::iterator it = xs.begin(); it != xs.end(); it++) cx[*it] = k++;
}
void update(int x, int delta) {
while (x < 100001) {
bit[x] += delta;
x += x & -x;
}
}
long long query(int x) {
long long sum = 0;
while (x > 0) {
sum += bit[x];
x -= x & -x;
}
return sum;
}
long long process(vector<segmento> &all) {
compress(all);
build(all);
long long sum = _merge();
vector<Evento> eventos;
for (int i = 0; i < vertical.size(); i++) {
Evento e(vertical[i].x0, vertical[i].y0, true);
Evento e2(vertical[i].x0, vertical[i].y1, false);
eventos.push_back(e);
eventos.push_back(e2);
}
int e = 0;
sort(eventos.begin(), eventos.end());
for (int i = 0; i < horizontal.size(); i++) {
while (e < eventos.size() &&
(eventos[e].y > horizontal[i].y0 ||
(eventos[e].y == horizontal[i].y0 && eventos[e].isEntrada()))) {
Evento evento = eventos[e];
if (evento.isEntrada())
update(cx[evento.x], 1);
else
update(cx[evento.x], -1);
e++;
}
sum -= (query(cx[horizontal[i].x1]) - query(cx[horizontal[i].x0] - 1));
}
return sum;
}
int main() {
vector<segmento> all;
int n;
scanf("%d", &n);
while (n--) {
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
segmento s(a, b, c, d);
all.push_back(s);
}
printf("%lld", process(all));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
vector<int> d[MAXN];
set<pair<int, int> > S;
long long l, r, curl, curr, n, m;
void ins(int x) {
for (int dx : d[x]) S.insert({dx, x});
}
void del(int x) {
for (int dx : d[x]) S.erase({dx, x});
}
int main() {
for (int i = 1; i < MAXN; i++)
for (int j = i; j < MAXN; j += i) d[j].push_back(i);
cin >> n >> m >> l >> r;
curl = m + 1;
curr = m;
for (long long x1 = 1; x1 <= n; x1++) {
while (x1 * (curl - 1) >= l) curl--, ins(curl);
while (x1 * curr > r) del(curr), curr--;
bool F = 0;
for (int div : d[x1]) {
auto it = S.upper_bound({div + 1, 0});
if (it == S.end()) continue;
long long y1 = (*it).second;
long long x2 = x1 / div * (*it).first;
long long y2 = (*it).second / (*it).first * div;
if (x2 <= n) {
F = 1;
cout << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << '\n';
break;
}
}
if (!F) cout << -1 << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> l, c, m;
set<int> s;
int i, j, k, coun;
for (i = 0; i < 6; i++) {
cin >> k;
l.push_back(k);
s.insert(k);
}
for (i = 0; i < 6; i++) {
if (l[i] > 9) {
cout << "Alien\n";
return 0;
} else
continue;
}
set<int>::iterator it;
for (it = s.begin(); it != s.end(); it++) {
c.push_back(*it);
}
for (i = 0; i < c.size(); i++) {
coun = 0;
for (j = 0; j < 6; j++) {
if (l[j] == c[i]) {
coun++;
}
}
m.push_back(coun);
}
sort(m.begin(), m.end());
int sum = 0;
for (i = 0; i < m.size(); i++) {
sum += m[i];
}
int len = m.size() - 1;
if ((m[len] == 6 && len == 0) || (m[len] == 4 && len == 1)) {
cout << "Elephant\n";
return 0;
}
if ((m[len] == 4 && len == 2) || (m[len] == 5 && len == 1)) {
cout << "Bear\n";
return 0;
}
cout << "Alien\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p; cin >> n >> p;
string s; cin >> s;
long long ans = 0;
if (p == 2 or p == 5) {
for (int i = 0; i < n; i++)
if ((s[i] - '0') % p == 0) ans += i + 1;
} else {
map<int, int> mp;
mp[0] = 1;
int sum = 0, power = 1;
for (int i = n - 1; i >= 0; i--) {
sum = (sum + (s[i] - '0') * power) % p;
ans += mp[sum % p]++;
power = power * 10 % p;
}
}
cout << ans;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, n, k, count = 0, sum = 0;
cin >> n >> k;
long long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (i = 0; i < k; i++) {
if (a[i] < 0) sum += a[i];
}
cout << abs(sum);
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int a[n];
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int sum = 0;
int temp = 0;
for (int i = 0; i < n; i++) {
for (int j = temp; j < n; j++) {
if (a[j] == sum + 1) {
sum++;
temp = j;
}
}
}
printf("%d\n", sum);
int year[sum];
for (int i = 0; i < sum; i++) year[i] = 0;
temp = 0;
for (int i = 0; i < sum; i++) {
for (int j = temp; j < n; j++) {
if (a[j] == i + 1) {
printf("%d ", j + 2001);
temp = j;
break;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char** argv) {
int A[9] = {0}, B[9] = {0}, n, m, i, mi1, mi2, miravn;
cin >> n >> m;
mi1 = 10;
mi2 = 10;
miravn = 10;
for (i = 0; i < n; i++) {
cin >> A[i];
if (A[i] < mi1) mi1 = A[i];
}
for (i = 0; i < m; i++) {
cin >> B[i];
if (B[i] < mi2) mi2 = B[i];
for (int j = 0; j < n; j++)
if ((B[i] == A[j]) && (A[j] < miravn)) miravn = A[j];
}
if (mi1 == mi2)
cout << mi1;
else if (miravn < 10)
cout << miravn;
else
cout << min(mi1, mi2) << max(mi1, mi2);
return 0;
}
| 1 |
#include <cstdio>
int k,s,ans;
int main()
{
scanf("%d%d",&k,&s);
for(int i=0;i<=k;++i)
for(int j=0;j<=k;++j)
if(i+j<=s&&s<=i+j+k)
++ans;
printf("%d",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = 1;
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = (x << 1) + (x << 3) + ch - 48;
return f ? -x : x;
}
int a[7], b[7], m;
struct mat {
long long a[128][128];
mat() { memset(a, 0, sizeof a); }
friend mat operator*(mat a, mat b) {
mat c;
for (int i = 0; i <= m; i++)
for (int j = 0; j <= m; j++)
for (int k = 0; k <= m; k++)
c.a[i][j] =
(c.a[i][j] + a.a[i][k] * b.a[k][j] % 1000000007) % 1000000007;
return c;
}
} A, B;
inline long long solve(int l, int r, int x) {
if (!x) return l | r;
long long sum = 0;
for (int i = 0; i < 1 << x; i++) {
long long ans = 1;
for (int j = 0; j <= x; j++)
ans &= (j == 0 ? 0 : (i >> (j - 1) & 1)) || (j == x ? 0 : (i >> j & 1)) ||
(l >> j & 1) || (r >> j & 1);
sum += ans;
}
return sum;
}
int main() {
for (int i = 0; i <= 6; i++) a[i] = b[i] = read();
B.a[0][0] = 1;
for (int i = 0; i <= 6; i++)
if (a[i]) {
memset(A.a, 0, sizeof A.a);
m = (1 << (i + 1)) - 1;
for (int S = 0; S <= (1 << (i + 1)) - 1; S++)
for (int T = 0; T <= (1 << (i + 1)) - 1; T++)
A.a[S][T] = solve(S, T, i);
while (a[i]) {
if (a[i] & 1) B = B * A;
a[i] >>= 1;
if (a[i]) A = A * A;
}
}
cout << B.a[0][0] << endl;
return 0;
}
| 5 |
#include<iostream>
using namespace std;
int main(){
int a;
int coin[]={500,100,50,10,5,1};
cin>>a;
while(a!=0){
a=1000-a;
int total=0;
int sheet=0;
for(int i=0;i<6;i++){
sheet=a/coin[i];
a=a%coin[i];
total+=sheet;
}
cout<<total<<endl;
cin>>a;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct Box {
char g[6];
Box() {}
Box(char gem[6]) {
for (int i = 0; i < (int)(6); i++) g[i] = gem[i];
}
bool operator==(Box &r) const;
};
void rotX(char b[]) {
char tmp = b[1];
b[1] = b[5];
b[5] = b[4];
b[4] = b[2];
b[2] = tmp;
}
void rotY(char b[]) {
char tmp = b[0];
b[0] = b[4];
b[4] = b[3];
b[3] = b[1];
b[1] = tmp;
}
void rotZ(char b[]) {
char tmp = b[0];
b[0] = b[5];
b[5] = b[3];
b[3] = b[2];
b[2] = tmp;
}
bool Box::operator==(Box &r) const {
Box tmp(r.g);
for (int x = 0; x < (int)(4); x++) {
rotX(tmp.g);
for (int y = 0; y < (int)(4); y++) {
rotY(tmp.g);
for (int z = 0; z < (int)(4); z++) {
rotZ(tmp.g);
bool ok = true;
for (int i = 0; i < (int)(6); i++)
if (g[i] != tmp.g[i]) {
ok = false;
break;
}
if (ok) return true;
}
}
}
return false;
}
vector<Box> vb;
char gems[10];
void calc(int idx, char gem[], bool used[]) {
if (idx == 6) {
Box b(gem);
for (int i = 0; i < (int)(vb.size()); i++)
if (vb[i] == b) return;
vb.push_back(b);
return;
}
for (int i = 0; i < (int)(6); i++) {
if (!used[i]) {
used[i] = true;
gem[idx] = gems[i];
calc(idx + 1, gem, used);
used[i] = false;
}
}
}
int main() {
while (scanf("%s%*c", gems) != EOF) {
vb.clear();
char g[10];
bool used[10];
memset(used, 0, sizeof(used));
calc(0, g, used);
printf("%d\n", vb.size());
}
return 0;
}
| 1 |
#include <stdio.h>
const int N=1e3+10;
int main(){
int n,a,b,dp[N];
while(true){
scanf("%d",&n);
if(n==0)return 0;
dp[0]=1;
for(int i=1;i<N;i++)dp[i]=0;
while(n--){
scanf("%d%d",&a,&b);
for(int i=N-1;i>=0;i--)for(int j=1;j<=b;j++)if(j*a<=i)dp[i]+=dp[i-j*a];
}
scanf("%d",&n);
while(n--){
scanf("%d",&a);
printf("%d\n",dp[a]);
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
char a[200005], b[200005];
int main() {
cin >> n >> k;
getchar();
for (int i = 1; i <= n; ++i) {
a[i] = getchar();
if (i <= k) b[i] = a[i];
}
bool gg = 0, flag = 0;
b[0] = b[k];
for (int i = 1; i <= n; ++i) {
if (b[i % k] - a[i] > 0) gg = 1;
if (!gg and b[i % k] - a[i] < 0) {
flag = 1;
break;
}
}
if (!flag) {
cout << n << endl;
for (int i = 1; i <= n; ++i) {
cout << (i % k == 0 ? b[k] : b[i % k]);
}
} else {
b[k] += 1;
bool wil = 0;
if (b[k] - '0' == 10) {
wil = 1;
b[k] = '0';
}
if (wil) {
for (int i = k - 1; i; --i) {
if (wil) wil = 0, b[i] += 1;
if (b[i] - '0' == 10) {
wil = 1;
b[i] = '0';
} else
break;
}
}
cout << n << endl;
for (int i = 1; i <= n; ++i) {
cout << (i % k == 0 ? b[k] : b[i % k]);
}
}
}
| 1 |
#include <bits/stdc++.h>
int trie[100005][27];
char ch[100005];
int dfs(int n) {
if (n == -1) return 1;
int f1 = 0, f2 = 0, f3 = 0, f4 = 0;
int sum = 0;
for (int i = 1; i <= 26; i++) {
if (trie[n][i] == -1) continue;
sum++;
int res = dfs(trie[n][i]);
if (res == 1) {
f1 = 1;
} else if (res == 2)
f2 = 1;
else if (res == 3)
f3 = 1;
else if (res == 4)
f4 = 1;
}
if (sum == 0) return 2;
if (f4) return 3;
if (f1) {
if (f2)
return 3;
else
return 2;
} else if (f2)
return 1;
else
return 4;
}
int main() {
int n, k;
while (scanf("%d %d", &n, &k) != EOF) {
memset(trie, -1, sizeof(trie));
int tot = 0;
for (int i = 1; i <= n; i++) {
scanf("%s", ch + 1);
int len = strlen(ch + 1);
int tt = 0;
for (int j = 1; j <= len; j++) {
int k = ch[j] - 'a' + 1;
if (trie[tt][k] == -1) {
trie[tt][k] = ++tot;
tt = tot;
} else
tt = trie[tt][k];
}
}
int ans = dfs(0);
if (ans == 1) {
if (k & 1)
printf("First\n");
else
printf("Second\n");
} else if (ans == 2 || ans == 4)
printf("Second\n");
else if (ans == 3)
printf("First\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxv = 402, maxe = 2 * (5000 + 800);
struct Graph {
int head[maxv];
int next[maxe];
int to[maxe];
int cf[maxe];
int w[maxe];
int k;
int n;
Graph(int _n = 0) : n(_n) { clear(); }
void clear() {
memset(head, -1, sizeof(head));
k = 0;
}
void adde(int s, int t, int cc, int ww) {
next[k] = head[s], head[s] = k, to[k] = t, w[k] = ww, cf[k] = cc, k++;
next[k] = head[t], head[t] = k, to[k] = s, w[k] = -ww, cf[k] = 0, k++;
}
int dist[maxv], pr[maxv], maxpush[maxv];
int st[maxv * maxv];
bool used[maxv];
void mincost(int S, int T) {
while (1) {
for (int i = 0; i < n; i++)
dist[i] = ((int)1E9), pr[i] = -1, maxpush[i] = 0, used[i] = 0;
dist[S] = 0, maxpush[S] = ((int)1E9);
st[0] = S;
for (int l = 0, r = 1; l < r; l++) {
int v = st[l];
used[v] = 0;
for (int edge = head[v]; edge != -1; edge = next[edge]) {
int u = to[edge];
if (cf[edge] && dist[u] > dist[v] + w[edge]) {
if (!used[u]) st[r++] = u, used[u] = 1;
dist[u] = dist[v] + w[edge];
pr[u] = edge;
maxpush[u] = min(maxpush[v], cf[edge]);
}
}
}
if (pr[T] == -1) break;
for (int v = T; v != S; v = to[pr[v] ^ 1]) {
cf[pr[v]] -= maxpush[T], cf[pr[v] ^ 1] += maxpush[T];
}
}
}
};
Graph g;
int edges[maxe][2];
int degs[2][maxv];
int ans[maxe];
int main() {
int n, m, k, t;
while (scanf("%d%d%d%d", &n, &m, &k, &t) >= 4) {
memset(degs, 0, sizeof(degs));
for (int i = 0; i < k; i++)
for (int j = 0; j < 2; j++)
scanf("%d", &edges[i][j]), degs[j][--edges[i][j]]++;
int res = 0;
for (int i = 0; i < n; i++) res += !!(degs[0][i] % t);
for (int i = 0; i < m; i++) res += !!(degs[1][i] % t);
printf("%d\n", res);
memset(ans, 0, sizeof(ans));
g.n = n + m + 2;
for (int parts = t; parts; parts--) {
g.clear();
for (int i = 0; i < k; i++)
if (!ans[i]) g.adde(edges[i][0], n + edges[i][1], 1, 0);
int S = n + m, T = S + 1;
for (int i = 0; i < n; i++) {
g.adde(S, i, degs[0][i] / parts, 0);
if (degs[0][i] % parts) g.adde(S, i, 1, 1);
}
for (int i = 0; i < m; i++) {
g.adde(i + n, T, degs[1][i] / parts, 0);
if (degs[1][i] % parts) g.adde(i + n, T, 1, 1);
}
g.mincost(S, T);
for (int i = 0, id = 0; i < k; i++)
if (!ans[i]) {
if (!g.cf[id])
ans[i] = parts, degs[0][edges[i][0]]--, degs[1][edges[i][1]]--;
id += 2;
}
}
for (int i = 0; i < k; i++) printf("%d%c", ans[i], " \n"[i == k - 1]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct song {
double p;
int len;
};
struct Less {
bool operator()(const song& a, const song& b) {
return (a.len * a.p / (1 - a.p) > b.len * b.p / (1 - b.p));
}
};
int main() {
int n;
double ans = 0;
double added = 0;
song temp[50001];
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d %lf", &temp[i].len, &temp[i].p);
temp[i].p /= 100;
ans += temp[i].len;
}
sort(temp, temp + n, Less());
for (int i = 0; i < n; ++i) {
ans += added * (1. - (double)temp[i].p);
added += temp[i].p * temp[i].len;
}
printf("%.9lf", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class UnionFind {
private:
public:
vector<int> p, rank, setSize, minn;
int numSets;
UnionFind(int N) {
setSize.assign(N, 1);
numSets = N;
rank.assign(N, 0);
p.assign(N, 0);
minn.resize(N);
for (int i = 0; i < N; i++) {
p[i] = i;
minn[i] = i;
}
}
int findSet(int i) {
if (p[i] == i)
return i;
else {
p[i] = findSet(p[i]);
minn[p[i]] = min(minn[p[i]], i);
return p[i];
}
}
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
void unionSet(int i, int j) {
if (!isSameSet(i, j)) {
numSets--;
int x = findSet(i), y = findSet(j);
if (rank[x] > rank[y]) {
p[y] = x;
setSize[x] += setSize[y];
minn[x] = min(minn[x], minn[y]);
} else {
p[x] = y;
setSize[y] += setSize[x];
minn[y] = min(minn[x], minn[y]);
if (rank[x] == rank[y]) rank[y]++;
}
}
}
int numDisjointSets() { return numSets; }
int sizeOfSet(int i) { return setSize[findSet(i)]; }
};
class fenwick_tree {
vector<long> t;
long size;
public:
fenwick_tree(long n) {
t.assign(n + 1, 0);
size = n + 1;
}
long LSOne(long k) { return k & (-k); }
void update(long index, long val) {
for (; index < size; index += LSOne(index)) t[index] += val;
}
long query_full(long a, long b) {
return query(b) - ((a <= 1) ? 0 : query(a - 1));
}
long query(long b) {
if (b < 1) return 0;
long sum = 0;
for (; b; b -= LSOne(b)) sum += t[b];
return sum;
}
};
long long gcd(long long a, long long b) {
while (b != 0) {
long long t = b;
b = a % b;
a = t;
}
return a;
}
int prime[1050000];
int lp[3001002];
class prime_class {
public:
long top;
prime_class() {
int i, i2, j;
top = 0;
lp[0] = 0;
lp[1] = 1;
for (i = 2; i < 3001002; i++) lp[i] = 0;
top = 0;
for (i = 2; i < 3001002; ++i) {
if (lp[i] == 0) {
lp[i] = i;
prime[top++] = i;
}
for (j = 0; (j < top) && (prime[j] <= lp[i]) && (i * prime[j] < 3001002);
++j)
lp[i * prime[j]] = prime[j];
}
}
bool isprime(int key) {
if (key < 3001002)
return (lp[key] == key) && (key >= 2);
else {
int i;
for (i = 0; (i < top) && (prime[i] * prime[i] <= key); i++)
if (key % prime[i] == 0) return false;
return true;
}
}
unordered_map<int, int> factorize(int key) {
unordered_map<int, int> ans;
while (lp[key] != key) {
ans[lp[key]]++;
key /= lp[key];
}
if (key > 1) ans[key]++;
return ans;
}
vector<pair<long long, long long>> factorize_full(long long key) {
vector<pair<long long, long long>> ans;
long i, ct;
for (i = 0; (i < top) && (prime[i] <= key); i++)
if (key % prime[i] == 0) {
ct = 0;
while (key % prime[i] == 0) {
ct++;
key /= prime[i];
}
ans.push_back({prime[i], ct});
}
if (key > 1) {
ans.push_back({key, 1});
}
return ans;
}
void generate_divisors(int step, int v, vector<pair<int, int>>& fp,
vector<int>& ans) {
if (step < fp.size()) {
generate_divisors(step + 1, v, fp, ans);
for (int i = 1; i <= fp[step].second; i++) {
v *= fp[step].first;
generate_divisors(step + 1, v, fp, ans);
}
} else
ans.push_back(v);
}
void generate_divisors_full(long long step, long long v,
vector<pair<long long, long long>>& fp,
vector<long long>& ans) {
if (step < fp.size()) {
generate_divisors_full(step + 1, v, fp, ans);
for (int i = 1; i <= fp[step].second; i++) {
v *= fp[step].first;
generate_divisors_full(step + 1, v, fp, ans);
}
} else
ans.push_back(v);
}
vector<int> get_divisors(int key) {
unordered_map<int, int> f = factorize(key);
int n = f.size();
vector<pair<int, int>> fp;
for (auto p : f) fp.push_back(p);
vector<int> ans;
generate_divisors(0, 1, fp, ans);
return ans;
}
vector<long long> get_divisors_full(long long key) {
vector<pair<long long, long long>> f = factorize_full(key);
int n = f.size();
vector<pair<long long, long long>> fp;
for (auto p : f) fp.push_back(p);
vector<long long> ans;
generate_divisors_full(0, 1, fp, ans);
return ans;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, i, j, k, a, b, mm;
cin >> n >> m;
vector<pair<pair<int, int>, pair<int, int>>> e(m);
vector<int> d(n + 1, 0), f;
vector<bool> keep(m, true);
for (i = 0; i < m; i++) {
cin >> a >> b;
e[i].second = {a, b};
d[a]++;
d[b]++;
}
for (i = 0; i < m; i++) {
a = e[i].second.first;
b = e[i].second.second;
e[i].first = {max(d[a], d[b]), rand() % 1000};
}
sort(e.rbegin(), e.rend());
f = d;
mm = m;
for (i = 0; i < m; i++) {
a = e[i].second.first;
b = e[i].second.second;
if ((f[a] - 1 >= (d[a] + 1) / 2) && (f[b] - 1 >= (d[b] + 1) / 2)) {
keep[i] = false;
f[a]--;
f[b]--;
mm--;
}
}
cout << mm << "\n";
for (i = 0; i < m; i++) {
if (keep[i]) cout << e[i].second.first << " " << e[i].second.second << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char a[100][100];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
}
}
int r;
for (r = 0; r < n; ++r) {
int cnt = 0;
for (int c = 0; c < m; ++c) {
if (a[r][c] == '*') {
++cnt;
}
}
if (cnt == 1) {
break;
}
}
int c;
for (c = 0; c < m; ++c) {
int cnt = 0;
for (int r = 0; r < n; ++r) {
if (a[r][c] == '*') {
++cnt;
}
}
if (cnt == 1) {
break;
}
}
cout << r + 1 << " " << c + 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
long long gcd(long long a, long long b) {
if (b == 0) return abs(a);
return gcd(b, a % b);
}
int upcmpii(const void *a, const void *b) {
return (*(int *)a == *(int *)b ? 0 : (*(int *)a > *(int *)b ? 1 : -1));
}
void sort_ui(int *a, int n) { qsort(a, n, sizeof(int), upcmpii); }
int n;
int a[204040];
int cnt[202020] = {0}, flag[202020] = {0};
int solve() {
int ans = 0;
for (int i = 0; i < (int)(n); i++) {
cnt[a[i]]++;
flag[a[i]] = 1;
}
for (int i = 0; i < (int)(200000); i++) {
if (flag[i + 1] == 0) continue;
if (i >= 1 && cnt[i + 1] > 0 && cnt[i] == 0) {
cnt[i]++;
cnt[i + 1]--;
ans++;
}
if (cnt[i + 1] > 0) {
ans++;
if (cnt[i + 1] > 1) {
cnt[i + 2]++;
flag[i + 2] = 1;
}
}
}
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < (int)(n); i++) scanf("%d", &a[i]);
printf("%d\n", solve());
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char s[100010];
int main() {
scanf("%d%d%d", &n, &m, &k);
bitset<22500> a, b, e, c;
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++)
(s[j] == '#' ? b : a).set(i * m + j),
(s[j] == 'E' ? e.set(i * m + j) : 0);
}
scanf("%s", s);
c = a;
for (int i = 0; i < k; i++) {
if (c == e) {
printf("%d\n", i);
return 0;
}
if (s[i] == 'U')
c = ((c >> m) & a) | (c & (b << m));
else if (s[i] == 'L')
c = ((c >> 1) & a) | (c & (b << 1));
else if (s[i] == 'D')
c = ((c << m) & a) | (c & (b >> m));
else if (s[i] == 'R')
c = ((c << 1) & a) | (c & (b >> 1));
}
printf("%d\n", c == e ? k : -1);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200 * 1000 + 10;
int n, m, u, v, amoo[maxn][3];
bool mark[maxn], park[maxn];
vector<pair<int, int> > vec[maxn];
vector<pair<pair<int, int>, int> > ans;
void dfs(int x) {
park[x] = 1;
int hlp;
for (int i = ((int(vec[x].size()))) - 1; i >= 0; i--) {
if (!mark[vec[x][i].second]) {
mark[vec[x][i].second] = 1;
hlp = vec[x][i].first;
vec[x].pop_back();
dfs(hlp);
amoo[x][0]++;
amoo[x][amoo[x][0]] = hlp;
if (amoo[amoo[x][amoo[x][0]]][0] > 0) {
ans.push_back(
{{x, hlp},
amoo[amoo[x][amoo[x][0]]][amoo[amoo[x][amoo[x][0]]][0]]});
amoo[amoo[x][amoo[x][0]]][0]--;
amoo[x][0]--;
}
if (amoo[x][0] == 2) {
ans.push_back({{amoo[x][1], x}, amoo[x][2]});
amoo[x][0] = 0;
}
} else
vec[x].pop_back();
}
}
int main() {
ios::sync_with_stdio(0);
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
vec[u].push_back(make_pair(v, i));
vec[v].push_back(make_pair(u, i));
}
for (int i = 1; i <= n; i++) {
if (!park[i]) dfs(i);
}
cout << ((int(ans.size()))) << endl;
for (int i = 0; i < ((int(ans.size()))); i++)
cout << ans[i].first.first << " " << ans[i].first.second << " "
<< ans[i].second << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long board[1001][1001];
int lim = 500;
int size = 0;
int n, k;
bool good = true;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
board[lim][lim] = n;
while (good) {
good = false;
for (int i = lim - size; i <= lim + size; ++i) {
for (int j = lim - size; j <= lim + size; ++j) {
if (board[i][j] >= 4) {
good = true;
if (max(abs(i - lim), abs(j - lim)) == size) ++size;
int pass = board[i][j] / 4;
board[i - 1][j] += pass;
board[i + 1][j] += pass;
board[i][j - 1] += pass;
board[i][j + 1] += pass;
board[i][j] %= 4;
}
}
}
}
while (k--) {
int i, j;
cin >> i >> j;
i = abs(i), j = abs(j);
if (i > size || j > size) {
cout << 0 << '\n';
} else {
cout << board[lim + i][lim + j] << '\n';
}
}
}
| 4 |
#include<stdio.h>
int main(){
int n,i,j,sum=0;
scanf("%d",&n);
int a[n];
for(i=0;i<n;i++){
scanf("%d",&a[i]);
}
for(i=0;i<n;i++){
for(j=0;j<n;j++){
if(i!=j){
sum+=a[i]*a[j];
}
}
}
printf("%d",sum/2);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 200000 + 10;
struct Person {
int e, p;
} arr[MaxN];
bool cmpE(Person a, Person b) { return a.e < b.e; }
bool cmpP(Person a, Person b) { return a.p > b.p; }
int n, k, sl;
long long ans;
int sc;
bool exist() {
int v = 0;
for (int i = 1; i <= n; ++i)
if (arr[i].p > n) ++v;
if (v > k - 1) return false;
return true;
}
long long case1() {
long long ret = 0;
for (int i = 1; i <= sc + 2 && i <= n; ++i) ret += (long long)arr[i].e;
return ret;
}
bool vis[MaxN];
long long case2() {
long long ret = 0;
int tsl = sl, nsc = sc + 1;
for (int i = 1; i <= n; ++i) vis[i] = 0;
for (int i = 1; i <= n && tsl; ++i)
if (arr[i].p == sc || arr[i].p == sc + 1) {
--tsl;
--nsc;
ret += (long long)arr[i].e;
vis[i] = true;
}
for (int i = 1; i <= n && nsc > 0; ++i)
if (!vis[i]) {
ret += (long long)arr[i].e;
--nsc;
}
return ret;
}
long long case3() {
long long ret = 0;
int tsl = sl, t2l = 0, nsc = sc;
for (int i = 1; i <= n; ++i) {
vis[i] = 0;
if (arr[i].p == sc - 1) ++t2l;
}
for (int i = 1; i <= n && tsl; ++i)
if (arr[i].p == sc) {
--tsl;
--nsc;
ret += (long long)arr[i].e;
vis[i] = true;
}
for (int i = 1; i <= n && t2l; ++i)
if (!vis[i] && (arr[i].p == sc || arr[i].p == sc - 1)) {
--nsc;
--t2l;
ret += (long long)arr[i].e;
vis[i] = true;
}
for (int i = 1; i <= n && nsc > 0; ++i)
if (!vis[i]) {
ret += (long long)arr[i].e;
--nsc;
}
return ret;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d%d", &arr[i].p, &arr[i].e);
if (!exist()) {
printf("-1");
return 0;
}
sort(arr + 1, arr + n + 1, cmpP);
sc = arr[k].p;
sl = 1;
while (arr[k + sl].p == arr[k].p) ++sl;
sort(arr + 1, arr + n + 1, cmpE);
ans = min(case1(), min(case2(), case3()));
cout << ans << endl;
return 0;
}
| 3 |
#pragma GCC optimize( ofast )
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vi;
typedef long double ld;
typedef pair<ll,ll> ii;
typedef vector<ii> vii;
#define rep(i,a,b) for(ll i = a; i<b;i++)
#define per(i,a,b) for(ll i = a; i>=b; i--)
#define inf LLONG_MAX
#define all(x) x.begin(),x.end()
#define sz(x) (ll)(x).size()
#define trav(a,x) for(auto &a: x)
#define mp(x,y) make_pair(x,y)
ll chc(ll n, ll k){
ll ans = 1;
rep(i,1,k){ ans *= (n-i); }
return ans;
}
int main(){
ios::sync_with_stdio(0);
cin.tie(NULL); cout.tie(NULL);
cout << setprecision(15) << fixed;
ll n,m; cin >> n >> m;
ll ndf[4] = {0,-1,1,0};
vector<vi> dp;
vi _; _.assign(6*n+10,0);
dp.assign(4,_);
dp[2][3*n+1] = 1;
rep(k,1,3*n+1){
rep(df,-3*n,3*n+1){
dp[3][df+3*n+1] = 0;
rep(r,1,min(ll(4),k+1)){
dp[3][df+3*n+1] += (chc(k,r)*dp[3-r][df+ndf[r]+3*n+1])%m;
}
}
rep(r,0,3) rep(i,0,6*n+10) dp[r][i] = dp[r+1][i];
}
/*
rep(i,0,3*n+1) {
rep(j,-3*n,3*n+1) cout << dp[i+3*n+1][j+3*n+1] << " ";
cout << endl;
}*/
ll ans = 0;
rep(i,0,3*n+1) { ans += dp[2][i+3*n+1]; ans = ans%m; }
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, m;
cin >> n >> m;
long long x = 0, y = 0, c = 0, d = 0;
vector<vector<long long>> a(n, vector<long long>(m)),
b(n, vector<long long>(m));
for (vector<long long>& i : a)
for (long long& j : i) {
cin >> j;
}
for (vector<long long>& i : b)
for (long long& j : i) {
cin >> j;
}
for (long long i = 0; i < n; i++) {
long long f = 0, s = 0;
for (long long j = 0; j < m; j++) {
if (a[i][j]) f++;
if (b[i][j]) s++;
}
if (f % 2 != s % 2) {
cout << "No";
return 0;
}
}
for (long long j = 0; j < m; j++) {
long long f = 0, s = 0;
for (long long i = 0; i < n; i++) {
if (a[i][j]) f++;
if (b[i][j]) s++;
}
if (f % 2 != s % 2) {
cout << "No";
return 0;
}
}
cout << "Yes";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int test;
cin >> test;
long long d, m;
while (test--) {
cin >> d >> m;
long long ans = 1;
for (int i = 0; i < 30; i++) {
if (d < (1LL << i)) break;
ans = ans * (min(d, (1LL << (i + 1)) - 1) - (1LL << i) + 2) % m;
}
ans--;
if (ans < 0) ans += m;
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100010], n, b[100010];
int main() {
cin >> n;
for (int i = 0; i <= n - 1; i++) {
scanf("%d", &a[i]);
a[i]++;
}
if (n == 1) {
printf("0\n");
return 0;
}
b[0] = a[0];
for (int i = 1; i <= n - 2; i++) {
b[i] = max(b[i - 1], max(a[i], a[i + 1] - 1));
}
b[n - 1] = max(a[n - 1], b[n - 2]);
for (int i = n - 2; i >= 0; i--) {
b[i] = max(b[i], b[i + 1] - 1);
}
long long res = 0;
for (int i = 0; i <= n - 1; i++) {
res += (b[i] - a[i]);
}
printf("%lld\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[200000], ans[200000], col[200000], n;
inline int get(int x) {
memset(col, 0, sizeof(col));
int cnt = 0, ans = 1;
for (int i = 1; i <= n; i++) {
if (col[a[i]] == ans) continue;
cnt++;
col[a[i]] = ans;
if (cnt > x) {
ans++;
cnt = 1;
col[a[i]] = ans;
}
}
return ans;
}
void solve(int l, int r) {
if (l > r) return;
ans[l] = get(l), ans[r] = get(r);
if (ans[l] == ans[r]) {
for (int i = l + 1; i <= r - 1; i++) ans[i] = ans[l];
return;
}
int mid = l + (r - l) / 2;
solve(l + 1, mid), solve(mid, r - 1);
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
solve(1, n);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MOD2 = MOD + 2;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
int modulo(int a, int b) { return (a % b + b) % b; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
vector<vector<long long> > a(n, vector<long long>(m)),
ans(n, vector<long long>(m));
for (int i = (0); i <= (n - 1); i++) {
for (int j = (0); j <= (m - 1); j++) {
cin >> a[i][j];
}
}
bool ok = true;
for (int i = (0); i <= (n - 1); i++) {
for (int j = (0); j <= (m - 1); j++) {
if (!ok) break;
if (i == 0 || j == 0 || i == n - 1 || j == m - 1) {
if ((i == 0 && (j == 0 || j == m - 1)) ||
(i == n - 1 && (j == 0 || j == m - 1))) {
if (a[i][j] > 2) {
ok = false;
break;
} else {
ans[i][j] = 2;
}
} else {
if (a[i][j] > 3) {
ok = false;
break;
} else {
ans[i][j] = 3;
}
}
} else {
if (a[i][j] > 4) {
ok = false;
break;
} else {
ans[i][j] = 4;
}
}
}
}
if (!ok) {
cout << "NO\n";
} else {
cout << "YES\n";
for (int i = (0); i <= (n - 1); i++) {
for (int j = (0); j <= (m - 1); j++) {
cout << ans[i][j] << " ";
}
cout << endl;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> defExprList;
int brackets[1005];
int checkLevel(char *val, int fromPos, int toPos) {
if (fromPos > toPos) return 0;
int ansLeft, ansRight;
int bCnt = 0;
bCnt = 0;
for (int currPos = toPos; currPos >= fromPos; --currPos) {
bCnt += val[currPos] == ')';
bCnt -= val[currPos] == '(';
if (bCnt) continue;
if (val[currPos] == '+') {
ansLeft = checkLevel(val, fromPos, currPos - 1);
ansRight = checkLevel(val, currPos + 1, toPos);
;
return (ansLeft && ansRight);
}
if (val[currPos] == '-') {
ansLeft = checkLevel(val, fromPos, currPos - 1);
ansRight = checkLevel(val, currPos + 1, toPos);
;
return (ansLeft && ansRight > 1);
}
}
for (int currPos = toPos; currPos >= fromPos; --currPos) {
bCnt += val[currPos] == ')';
bCnt -= val[currPos] == '(';
if (bCnt) continue;
if (val[currPos] == '*') {
ansLeft = checkLevel(val, fromPos, currPos - 1);
ansRight = checkLevel(val, currPos + 1, toPos);
;
return (ansLeft > 1 && ansRight > 1) ? 2 : 0;
}
if (val[currPos] == '/') {
ansLeft = checkLevel(val, fromPos, currPos - 1);
ansRight = checkLevel(val, currPos + 1, toPos);
;
return (ansLeft > 1 && ansRight > 2) ? 2 : 0;
}
}
if ('(' == val[fromPos]) {
if (')' == val[toPos])
return checkLevel(val, fromPos + 1, toPos - 1) ? 3 : 0;
}
string keyStr(val, fromPos, toPos - fromPos + 1);
int ans = defExprList.count(keyStr) ? defExprList[keyStr] : 3;
;
return ans;
}
int parseExpr(char *val, bool checkMacro = true) {
char *p = val;
int idx = 0;
int meetBrackets = 0;
while (*p) {
switch (*p) {
case ' ':
break;
default:
if (!meetBrackets) val[idx++] = *p;
break;
}
++p;
}
val[idx] = 0;
if (val[0] == '#') return 3;
return checkLevel(val, 0, idx - 1);
}
int main() {
int n;
cin >> n;
cin.ignore();
char buf[1005];
string s;
char c;
int idx = 0;
for (__typeof(n) i = (0); i < (n); ++i) {
scanf(" #%*s");
cin >> s;
;
idx = 0;
while (~scanf("%c", &c)) {
if (c == '\n' || c == '\r' || c == '\0') break;
buf[idx++] = c;
}
buf[idx] = 0;
defExprList[s] = parseExpr(buf);
;
}
for (auto it : defExprList) {
;
}
idx = 0;
while (~scanf("%c", &c)) {
if (c == '\n' || c == '\r' || c == '\0') break;
buf[idx++] = c;
}
buf[idx] = 0;
;
int ans = parseExpr(buf, false);
cout << (ans ? "OK" : "Suspicious") << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2000 + 10;
const int Mod = 1000000007;
int n, m;
int C[MAX][MAX];
int f[MAX][MAX], f2[MAX][MAX];
int sum[MAX], sum2[MAX];
int main() {
int i, j, k;
C[0][0] = 1;
for ((i) = (1); (i) != (MAX); ++(i)) {
C[i][0] = 1;
for ((j) = (1); (j) <= (i); ++(j))
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % Mod;
}
scanf("%d%d", &n, &m);
for ((i) = (2); (i) <= (m); ++(i)) f[1][i] = 1;
for ((i) = (2); (i) <= (n); ++(i)) {
for ((k) = (1); (k) <= (m); ++(k)) {
sum[k] = (sum[k - 1] + (long long)f[i - 1][k] * (k - 1)) % Mod;
sum2[k] = (sum2[k - 1] + f[i - 1][k]) % Mod;
}
for ((j) = (2); (j) <= (m); ++(j))
f[i][j] = ((long long)sum2[j] * j - sum[j] + Mod) % Mod;
}
for ((i) = (2); (i) <= (n); ++(i)) {
for (k = m; k >= 1; --k) {
sum[k] =
(sum[k + 1] + (long long)f[i - 1][k] * (k + 1) * (m - k + 1)) % Mod;
sum2[k] = (sum2[k + 1] + (long long)f[i - 1][k] * (m - k + 1)) % Mod;
}
for ((j) = (2); (j) <= (m); ++(j))
f2[i][j] = (sum[j + 1] - (long long)sum2[j + 1] * j % Mod + Mod) % Mod;
for (k = m; k >= 1; --k) {
sum[k] = (sum[k + 1] + (long long)f2[i - 1][k] * (k + 1)) % Mod;
sum2[k] = (sum2[k + 1] + f2[i - 1][k]) % Mod;
}
for ((j) = (2); (j) <= (m); ++(j))
f2[i][j] =
((f2[i][j] + sum[j]) % Mod - (long long)sum2[j] * j % Mod + Mod) %
Mod;
}
int ans = 0;
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (m); ++(j))
ans = (ans + (long long)(f2[i][j] + (long long)f[i][j] * (m - j + 1)) %
Mod * (n - i + 1)) %
Mod;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, x[200000], s = 0, a = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x[i];
s = s + x[i];
}
for (i = 0; i < n; i++) {
a = a + x[i];
if (a >= s / 2 && s % 2 == 0)
break;
else if (s % 2 != 0 && a >= s / 2 + 1)
break;
}
cout << i + 1;
}
| 1 |
#include <bits/stdc++.h>
char s[100005], e[100005];
int sum, len, n;
int w[30][30];
int main() {
scanf("%s%s", s, e);
len = strlen(s);
if (len != strlen(e)) {
printf("-1\n");
return 0;
}
scanf("%d", &n);
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++)
if (i != j)
w[i][j] = 100005;
else
w[i][j] = 0;
for (int i = 0; i < n; i++) {
char a, b;
int c;
while (scanf("%c", &a) != EOF && (a < 'a' || a > 'z'))
;
while (scanf("%c", &b) != EOF && (b < 'a' || b > 'z'))
;
scanf("%d", &c);
if (c < w[a - 'a'][b - 'a']) w[a - 'a'][b - 'a'] = c;
}
for (int k = 0; k < 26; k++)
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++)
if (w[i][k] + w[k][j] < w[i][j]) w[i][j] = w[i][k] + w[k][j];
sum = 0;
for (int i = 0; i < len; i++)
if (s[i] != e[i]) {
int min = 100005;
int k = 0;
for (int j = 0; j < 26; j++)
if (w[s[i] - 'a'][j] + w[e[i] - 'a'][j] < min) {
k = j;
min = w[s[i] - 'a'][j] + w[e[i] - 'a'][j];
}
if (min >= 100005) {
printf("-1\n");
return 0;
} else {
sum += min;
s[i] = 'a' + k;
}
}
printf("%d\n", sum);
printf("%s\n", s);
return 0;
}
| 2 |
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <tuple>
#include <queue>
#include <stack>
#include <set>
using namespace std;
class Solver {
};
int get_value(string s) {
int val = 0;
int tmp = 1;
for (int i = 0; i < s.size(); i++) {
if ('2' <= s[i] && s[i] <= '9') {
tmp = s[i] - '0';
continue;
}
if (s[i] == 'm')val += tmp * 1000;
if (s[i] == 'c')val += tmp * 100;
if (s[i] == 'x')val += tmp * 10;
if (s[i] == 'i')val += tmp * 1;
tmp = 1;
}
return val;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s1, s2;
cin >> s1 >> s2;
int val = get_value(s1) + get_value(s2);
vector<char> chars{ 'm','c','x','i' };
for (int i = 0; i < 4; i++) {
int digit = (val / 1000) % 10;
if (digit == 1)cout << chars[i];
if (digit > 1)cout << digit << chars[i];
val *= 10;
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a1, b1, a2, b2, a3, b3;
scanf("%d %d", &a1, &b1);
scanf("%d %d", &a2, &b2);
scanf("%d %d", &a3, &b3);
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
if (i) swap(a2, b2);
if (j) swap(a3, b3);
if (a2 + a3 <= a1 && max(b2, b3) <= b1) {
printf("YES\n");
return (0);
}
if (a2 + a3 <= b1 && max(b2, b3) <= a1) {
printf("YES\n");
return (0);
}
if (j) swap(a3, b3);
if (i) swap(a2, b2);
}
}
printf("NO\n");
return (0);
}
| 2 |
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <map>
#include <list>
#include <set>
#include <numeric>
#include <queue>
#include <stack>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <climits>
#include <cfloat>
#include <ctime>
#include <complex>
#include <cassert>
#include <array>
#include <bitset>
#include <unordered_map>
#include <random>
using namespace std;
typedef long long LL;
typedef pair<LL,LL> P;
const int L=2e5+9;
LL c[L];
vector<int> es[L];
LL ps[L];
LL w[L];
LL cnt[L];
LL ret[L];
LL N;
LL dfs(int r, int p)
{
int pcnt=cnt[c[r]];
int pps=ps[c[r]];
ps[c[r]]=r;
LL s=1;
ret[c[r]]+=s;
LL sum=1;
for(auto i:es[r]){
if(i==p){
continue;
}
w[r]=0;
auto v=dfs(i,r);
auto t=w[r]+v;
ret[c[r]]+=t*s;
s+=t;
sum+=v;
}
{
auto t=N-sum-pcnt;
ret[c[r]]+=t*s;
}
cnt[c[r]]+=s;
w[pps]-=sum;
ps[c[r]]=pps;
return sum;
}
int main(){
scanf("%lld",&N);
for(int i = 1 ; i <= N ; i++){
scanf("%lld",&c[i]);
}
for(int i = 0 ; i < N-1 ; i++){
LL a,b;
scanf("%lld",&a);
scanf("%lld",&b);
es[a].push_back(b);
es[b].push_back(a);
}
dfs(1,0);
for(int i=1;i<=N;i++){
cout << ret[i] << endl;
}
return 0;
}
| 0 |
//~ author : Sumit Prajapati
#include <bits/stdc++.h>
using namespace std;
// #define int long long
#define curtime chrono::high_resolution_clock::now()
#define timedif(start,end) chrono::duration_cast<chrono::nanoseconds>(end - start).count()
auto time0=curtime;
int bin_power(int a,int b,int md){
int res=1;
while (b){
if (b&1)
res=(1LL*res*a)%md;
a=(1LL*a*a)%md;
b>>=1;
}
return res;
}
bool probablyPrimeFermat(int n, int iter=8) {
if (n < 4)
return n == 2 || n == 3;
for (int i = 0; i < iter; i++) {
int a = 2 + rand() % (n - 3);
if (bin_power(a, n - 1, n) != 1)
return false;
}
return true;
}
void solve(){
int a,b,k;
cin>>a>>b>>k;
if(k==1){
if(a==b)
cout<<"NO\n";
else if(a%b==0 || b%a==0)
cout<<"YES\n";
else
cout<<"NO\n";
return;
}
int a_sum=0,b_sum=0;
if(probablyPrimeFermat(a))
a_sum+=1,a=1;
for(int i=2;i*i<=a;i++){
if(a%i==0){
int cnt=0;
while(a%i==0)
a/=i,cnt++;
a_sum+=cnt;
}
}
if(a>1)
a_sum+=1;
if(probablyPrimeFermat(b))
b_sum+=1,b=1;
for(int i=2;i*i<=b;i++){
if(b%i==0){
int cnt=0;
while(b%i==0)
b/=i,cnt++;
b_sum+=cnt;
}
}
if(b>1)
b_sum+=1;
cout<<((a_sum+b_sum)>=k?"YES\n":"NO\n");
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
time0 = curtime;
srand(time(NULL));
int t=1;
cin>>t;
while(t--){
// cout<<"Case #"<<tt<<": ";
solve();
}
cerr<<"Execution Time: "<<timedif(time0,curtime)*1e-9<<" sec\n";
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int n, k;
cin >> n >> k;
int res = 0;
if (n % k == 0)
res = n;
else {
int a = static_cast<int>(n / k);
res = a * k + min(static_cast<int>(k / 2), n % k);
}
cout << res << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n), b(n);
for (int i = n - 1; i >= 0; i--) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
vector<pair<int, int>> a1(n + 1), b1(n + 1);
a1[n - 1] = {a[n - 1] == 1, a[n - 1] == 2};
for (int i = n - 2; i >= 0; i--) {
pair<int, int> ant = a1[i + 1];
a1[i] = {ant.first + (a[i] == 1), ant.second + (a[i] == 2)};
}
b1[n - 1] = {b[n - 1] == 1, b[n - 1] == 2};
for (int i = n - 2; i >= 0; i--) {
pair<int, int> ant = b1[i + 1];
b1[i] = {ant.first + (b[i] == 1), ant.second + (b[i] == 2)};
}
vector<int> arr1(n + 1, -1);
vector<int> arr2(n + 1, -1);
a1[n].first = 0;
a1[n].second = 0;
for (int i = 0; i <= n; i++) {
int d = a1[i].first - a1[i].second;
if (d > 0) {
if (arr1[d] == -1) arr1[d] = i;
} else if (d < 0) {
d *= -1;
if (arr2[d] == -1) arr2[d] = i;
} else {
if (arr1[0] == -1) arr1[0] = i;
if (arr2[0] == -1) arr2[0] = i;
}
}
int res = 0x3f3f3f3f;
b1[n].first = 0;
b1[n].second = 0;
for (int i = 0; i <= n; i++) {
int f = b1[i].first - b1[i].second;
if (f < 0) {
f *= -1;
if (arr1[f] != -1) {
res = min(res, arr1[f] + i);
}
} else if (f > 0) {
if (arr2[f] != -1) {
res = min(res, arr2[f] + i);
}
} else {
if (arr1[0] != -1) res = min(res, arr1[0] + i);
if (arr2[0] != -1) res = min(res, arr2[0] + i);
}
}
if (b1[0].first == b1[0].second) res = min(res, n);
if (a1[0].first == a1[0].second) res = min(res, n);
cout << ((res == 0x3f3f3f3f) ? 2 * n : res) << "\n";
}
return 0;
}
| 3 |
#include <cstdio>
#include <algorithm>
#include <map>
using namespace std;
#define MOD 1000000007
typedef long long ll;
map<pair<ll, ll>, pair<ll, ll> > M;
ll pow2[222222] = { 1 };
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
int main(void)
{
ll n, i, x, y, tmp = -1, cnt = 1;
scanf("%lld", &n);
while (n--)
{
scanf("%lld %lld", &x, &y);
if (x == 0 && y == 0)
{
++tmp;
continue;
}
if (make_pair(x, y) < make_pair(0LL, 0LL))
x = -x, y = -y;
ll GCD = gcd(abs(x), abs(y));
x /= GCD, y /= GCD;
if (y > 0)
M[make_pair(x, y)].first++;
else
M[make_pair(-y, x)].second++;
}
for (i = 1; i < 222222; i++)
pow2[i] = pow2[i - 1] * 2 % MOD;
for (auto p : M)
cnt = cnt * (pow2[p.second.first] + pow2[p.second.second] - 1LL) % MOD;
printf("%lld", (tmp + MOD + cnt) % MOD);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int b, x;
double a, c;
cin >> a >> b >> c;
x = ceil(a * (c / 100));
cout << max(0, x - b) << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main (){
ll n,a[100009],dp[100009];
cin>>n;
for(int i=0;i<n;i++)cin>>a[i];
dp[n-2]=abs(a[n-1]-a[n-2]);
dp[n-1]=0;
for(int i=n-3;i>=0;i--)
dp[i]=min(abs(a[i+2]-a[i])+dp[i+2],abs(a[i+1]-a[i])+dp[i+1]);
cout<<dp[0]<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > mat, pom;
vector<string> sol, msol;
void addintos(string &s, int a) {
string drugi;
do {
char c = a % 10 + 48;
drugi.push_back(c);
a /= 10;
} while (a);
reverse(drugi.begin(), drugi.end());
for (int i = 0; i < drugi.size(); i++) s.push_back(drugi[i]);
}
int main() {
int n, m, maxs = -1, sl = -1;
cin >> n >> m;
vector<int> vi(m, 0);
mat.insert(mat.begin(), n, vi);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> mat[i][j], maxs = max(maxs, mat[i][j]);
for (int i = 0; i <= maxs; i++) {
bool b = 1, b2 = 1;
pom.clear();
pom = mat;
sol.clear();
for (int j = 0; j < m; j++) {
pom[0][j] -= i;
if (pom[0][j] < 0) {
b = 0;
break;
}
}
if (!b) break;
for (int j = 0; j < i; j++) sol.push_back("row 1");
for (int j = 0; j < m; j++) {
int f = pom[0][j];
if (!f) continue;
for (int i1 = 0; i1 < n; i1++) {
if (pom[i1][j] < f) {
b = 0;
break;
}
}
if (b) {
for (int i1 = 0; i1 < n; i1++) pom[i1][j] -= f;
string a = "col ";
addintos(a, j + 1);
for (int i1 = 0; i1 < f; i1++) sol.push_back(a);
} else
break;
}
if (!b) continue;
for (int i1 = 1; i1 < n; i1++) {
int f = pom[i1][0];
for (int j = 0; j < m; j++) {
pom[i1][j] -= f;
if (pom[i1][j] != 0) {
b = 0;
break;
}
}
if (!b) break;
string a = "row ";
addintos(a, i1 + 1);
for (int i1 = 0; i1 < f; i1++) sol.push_back(a);
}
if (!b) continue;
if (sl < 0)
sl = sol.size(), msol = sol;
else if (sl > sol.size())
sl = sol.size(), msol = sol;
}
cout << sl << endl;
for (int i = 0; i < sl; i++) cout << msol[i] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
using namespace std;
using pii = pair<long long, long long>;
template <typename T>
using prior = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using Prior = priority_queue<T>;
const long long INF = 1E18;
const long long mod = 1E9 + 7;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t, a, b;
cin >> t;
while (t--) cin >> a >> b, cout << a + b << "\n";
return 0;
}
| 1 |
#include <cstdio>
int main()
{
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
printf("%d\n", (c / a) * b);
return 0;
} | 0 |
#include <bits/stdc++.h>
inline int getint() {
int x = 0, p = 1;
char c = getchar();
while (c <= 32) c = getchar();
if (c == 45) p = -p, c = getchar();
while (c > 32) x = x * 10 + c - 48, c = getchar();
return x * p;
}
using namespace std;
long long n, m, k;
int main() {
scanf("%I64d%I64d%I64d", &n, &m, &k);
if (k < n)
cout << k + 1 << " " << 1 << endl;
else {
k -= n;
m--;
long long x = k / m, y = k % m;
if (x & 1) y = m - y - 1;
x = n - x;
cout << x << " " << y + 2 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool bipartite;
vector<int> par;
vector<int> pard;
vector<int> rankk;
vector<bool> undo_bipartite;
vector<int> undo_par;
vector<int> undo_rankk;
pair<int, int> find(int i) {
int d = 0;
while (par[i] != -1) {
d ^= pard[i];
i = par[i];
}
return {i, d};
}
void merge(int i1, int i2) {
int d1, d2;
tie(i1, d1) = find(i1);
tie(i2, d2) = find(i2);
undo_bipartite.push_back(bipartite);
if (i1 == i2) {
if ((d1 ^ d2) != 1) bipartite = false;
undo_par.push_back(-1);
undo_rankk.push_back(-1);
} else {
if (rankk[i1] > rankk[i2]) swap(i1, i2);
par[i1] = i2;
pard[i1] = d1 ^ d2 ^ 1;
undo_par.push_back(i1);
if (rankk[i1] < rankk[i2]) {
undo_rankk.push_back(-1);
} else {
rankk[i2]++;
undo_rankk.push_back(i2);
}
}
}
void undo() {
bipartite = undo_bipartite.back();
undo_bipartite.pop_back();
if (undo_par.back() != -1) par[undo_par.back()] = -1;
undo_par.pop_back();
if (undo_rankk.back() != -1) rankk[undo_rankk.back()]--;
undo_rankk.pop_back();
}
int N, M, Q;
vector<pair<int, int> > str;
void merge(int m) { merge(str[m].first, str[m].second); }
struct grp {
int t;
grp() : t(undo_bipartite.size()) {}
~grp() {
while ((int)undo_bipartite.size() > t) undo();
}
};
vector<int> bla;
void compute(int l1, int l2, int r1, int r2) {
int lm = (l1 + l2) / 2;
int rm = r2 - 1;
{
grp G;
for (int m = (l1); m < (lm); m++) merge(m);
while (bipartite && rm >= r1) {
merge(rm);
rm--;
}
if (!bipartite)
rm += 2;
else
rm += 1;
bla[lm] = rm;
}
if (l1 <= lm - 1) {
grp G;
for (int m = (rm); m < (r2); m++) merge(m);
compute(l1, lm - 1, r1, rm);
}
if (lm + 1 <= l2) {
grp G;
for (int m = (l1); m < (lm + 1); m++) merge(m);
compute(lm + 1, l2, rm, r2);
}
}
int main() {
scanf("%d%d%d", &N, &M, &Q);
bipartite = true;
par.assign(N, -1);
pard.resize(N);
rankk.assign(N, 0);
for (int m = (0); m < (M); m++) {
int i, j;
scanf("%d%d", &i, &j);
i--;
j--;
str.emplace_back(i, j);
}
int L = 0;
{
grp G;
while (bipartite && L < M) {
merge(L);
L++;
}
if (!bipartite) L--;
}
bla.resize(L + 1);
compute(0, L, 0, M);
for (int q = (0); q < (Q); q++) {
int l, r;
scanf("%d%d", &l, &r);
l--;
r--;
if (l <= L && bla[l] <= r + 1)
printf("NO\n");
else
printf("YES\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long pow1(long long n, long long p) {
if (p == 0) return 1;
long long x = pow1(n, p / 2);
x = (x * x) % 1000000007;
if (p % 2 == 0)
return x;
else
return (x * n) % 1000000007;
}
long long binarySearch(long long arr[], long long l, long long r, long long x) {
if (r >= l) {
long long mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
long long gcd(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
bool find_any_solution(long long a, long long b, long long c, long long &x0,
long long &y0, long long &g) {
g = gcd(llabs(a), llabs(b), x0, y0);
if (c % g) {
return false;
}
x0 *= c / g;
y0 *= c / g;
if (a < 0) x0 = -x0;
if (b < 0) y0 = -y0;
return true;
}
void shift_solution(long long &x, long long &y, long long a, long long b,
long long cnt) {
x += cnt * b;
y -= cnt * a;
}
long long find_all_solutions(long long a, long long b, long long c,
long long minx, long long maxx, long long miny,
long long maxy) {
long long x, y, g;
if (!find_any_solution(a, b, c, x, y, g)) return 0;
a /= g;
b /= g;
long long sign_a = a > 0 ? +1 : -1;
long long sign_b = b > 0 ? +1 : -1;
shift_solution(x, y, a, b, (minx - x) / b);
if (x < minx) shift_solution(x, y, a, b, sign_b);
if (x > maxx) return 0;
long long lx1 = x;
shift_solution(x, y, a, b, (maxx - x) / b);
if (x > maxx) shift_solution(x, y, a, b, -sign_b);
long long rx1 = x;
shift_solution(x, y, a, b, -(miny - y) / a);
if (y < miny) shift_solution(x, y, a, b, -sign_a);
if (y > maxy) return 0;
long long lx2 = x;
shift_solution(x, y, a, b, -(maxy - y) / a);
if (y > maxy) shift_solution(x, y, a, b, sign_a);
long long rx2 = x;
if (lx2 > rx2) swap(lx2, rx2);
long long lx = max(lx1, lx2);
long long rx = min(rx1, rx2);
if (lx > rx) return 0;
return (rx - lx) / llabs(b) + 1;
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
bool compare(const pair<long long, long long> &p1,
const pair<long long, long long> &p2) {
if (p1.first < p2.first) return true;
if (p1.first == p2.first) return p1.second < p2.second;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
std::cin >> n;
string s, t, s1, t1;
std::cin >> s >> t;
t1 = t;
s1 = s;
sort(s1.begin(), s1.end());
sort(t1.begin(), t1.end());
if (s1 != t1) {
cout << -1;
} else {
long long i, j, sum = 0;
string s2 = s;
for (i = 0; i < n; i++) {
if (s[i] == t[i]) continue;
for (j = i; j < n; j++) {
if (t[i] == s[j]) break;
}
sum += (j - i);
for (;; j--) {
if (j == i) break;
swap(s[j], s[j - 1]);
}
}
s = s2;
cout << sum << "\n";
for (i = 0; i < n; i++) {
if (s[i] == t[i]) continue;
for (j = i; j < n; j++) {
if (t[i] == s[j]) break;
}
for (;; j--) {
if (j == i) break;
cout << j << " ";
swap(s[j], s[j - 1]);
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n, p, t, a, x;
cin >> n >> p;
list<int> l[n];
list<int>::iterator it;
while (p--)
{
cin >> t;
if (t == 0)
{
cin >> a >> x;
l[a].push_back(x);
}
if (t == 1)
{
cin >> a;
for (it = l[a].begin(); it != l[a].end(); it++)
{
if (it != l[a].begin())
cout << " ";
cout << *it;
}
cout << endl;
}
if (t == 2)
{
cin >> a >> x;
it = l[x].end();
l[x].splice(it, l[a]);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
long long resv, n, ans = 0, i, cnt = 0, a, b;
cin >> n;
resv = n;
vector<long long> v;
if (isPrime(n)) {
cout << n;
return 0;
}
if (n == 1) {
cout << 1;
return 0;
}
for (i = 2; i * i <= n; i++) {
if (n % i == 0) {
v.push_back(i);
while (n % i == 0) {
n /= i;
}
cnt++;
}
}
if (n > 1) {
v.push_back(n);
}
sort(v.begin(), v.end());
ans = v[0];
int arr[ans];
for (i = 0; i < v[0]; i++) {
arr[i] = 0;
}
arr[0] = 1;
for (i = 1; i < v.size(); i++) {
a = v[i];
cnt = 0;
while (a < resv && cnt < v[0]) {
cnt++;
if (arr[a % v[0]] == 0) {
ans--;
arr[a % v[0]] = 1;
}
a += v[i];
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long N = 3e5 + 5;
long long n, m, ans, sum, sum2;
void solve() {
cin >> n;
vector<long long> a(n + 1);
map<long long, long long> m1;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
m1[sum] = 1;
}
cin >> m;
vector<long long> b(m + 1);
for (long long i = 1; i <= m; i++) {
cin >> b[i];
sum2 += b[i];
if (m1[sum2] == 1) ans++;
}
if (sum != sum2) {
cout << "-1"
<< "\n";
return;
}
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include <iostream>
#include <vector>
using namespace std;
int dp[21][11][156];
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n,k,s;
while(cin >> n >> k >> s,n){
vector<vector<vector<int> > > dp(n+1,vector<vector<int> >(k+1,vector<int>(s+1,0)));
for(int i = 0;i < n;i++)dp[i][0][0] = 1;
for(int i = 1;i <= n;i++){
for(int j = 1;j <= k;j++){
for(int l = 1;l <= s;l++){
if(l < i)dp[i][j][l] = dp[i-1][j][l];
else dp[i][j][l] = dp[i-1][j][l] + dp[i-1][j-1][l-i];
}
}
}
cout << dp[n][k][s] << endl;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
string s;
cin >>s;
set<char> st;
for(auto i : s)st.insert(i);
cout << (st.size() == s.size() ? "yes" : "no") << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
const int inf = 0x7FFFFFFF;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
void show(T a, int n) {
for (int i = 0; i < n; ++i) cout << a[i] << ' ';
cout << endl;
}
template <class T>
void show(T a, int r, int l) {
for (int i = 0; i < r; ++i) show(a[i], l);
cout << endl;
}
struct S {
long long w, h;
long long bord, space;
string tp;
vector<int> son;
int vis;
void init(int x, int y, string t) {
w = x, h = y;
bord = space = 0;
tp = t;
son.clear();
vis = false;
}
void dfs();
} s[100000];
char buf[10000];
void S::dfs() {
vis = true;
if (son.size() > 0) {
for (int i = 0; i < son.size(); i++)
if (!s[son[i]].vis) {
s[son[i]].dfs();
}
if (tp == "VBox") {
for (int i = 0; i < son.size(); i++) {
int v = son[i];
w = max(s[v].w, w);
if (i > 0) h += space;
h += s[v].h;
}
w += 2 * bord;
h += 2 * bord;
} else if (tp == "HBox") {
for (int i = 0; i < son.size(); i++) {
int v = son[i];
h = max(s[v].h, h);
if (i > 0) w += space;
w += s[v].w;
}
w += 2 * bord;
h += bord * 2;
}
}
}
string nn[10000];
struct SS {
string s;
long long x, y;
const bool operator<(const SS &b) const { return s < b.s; }
} ss[10000];
int main() {
int n;
while (cin >> n) {
map<string, int> mp;
int cnt = 0;
for (int i = 0; i < n; i++) {
scanf(" %[^\n]", buf);
bool newtp = true;
for (int i = 0; buf[i]; i++)
if (buf[i] == '(' || buf[i] == ')' || buf[i] == '.' || buf[i] == ',') {
if (buf[i] == '.') newtp = false;
buf[i] = ' ';
}
istringstream sin(buf);
string t, nm, nm2;
sin >> t;
if (newtp) {
int x = 0, y = 0;
sin >> nm;
mp[nm] = cnt;
nn[cnt] = nm;
if (t == "Widget") {
sin >> x >> y;
}
s[cnt].init(x, y, t);
cnt++;
} else {
nm = t;
int x;
sin >> t;
if (t == "set_border") {
sin >> x;
s[mp[nm]].bord = x;
} else if (t == "set_spacing") {
sin >> x;
s[mp[nm]].space = x;
} else if (t == "pack") {
sin >> nm2;
s[mp[nm]].son.push_back(mp[nm2]);
} else
puts("fuck");
}
}
for (int i = 0; i < cnt; i++) {
if (!s[i].vis) s[i].dfs();
}
for (int i = 0; i < cnt; i++) {
ss[i].s = nn[i];
ss[i].x = s[i].w;
ss[i].y = s[i].h;
}
sort(ss, ss + cnt);
for (int i = 0; i < cnt; i++) {
cout << ss[i].s << ' ' << ss[i].x << ' ' << ss[i].y << endl;
}
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define N 100005
using namespace std;
int d[N],n,m,x,y,q[N],f,r,has[N],ans;
vector<int> v[N];
int main()
{
scanf("%d%d",&n,&m);
while(m--)
{
scanf("%d%d",&x,&y);
x--;y--;
v[x].push_back(y);
has[y]++;
}
for(int i=0;i<n;i++)
if(!has[i])
q[r++]=i;
while(f<r)
{
x=q[f++];
for(int i=0;i<v[x].size();i++)
{
y=v[x][i];
if(d[x]+1>d[y])d[y]=d[x]+1;
if(ans<d[y])ans=d[y];
has[y]--;
if(!has[y])q[r++]=y;
}
}
printf("%d\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, z, w, tmp, ans;
long long A[1005], x, y, k;
map<long long, int> M, P;
map<int, int> Q;
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) {
scanf("%I64d", &A[i]);
M[A[i]]++;
P[A[i]]++;
}
sort(A, A + n);
for (int i = (0); i < (n); i++) {
if (i != 0) {
if (A[i] == A[i - 1]) continue;
}
for (int j = (0); j < (n); j++)
if (i != j) {
if (j != 0) {
if (A[j] == A[j - 1] && j - 1 != i) continue;
}
if (A[i] == 0ll && A[j] == 0ll) continue;
x = A[i];
y = A[j];
M[x]--;
M[y]--;
tmp = 2;
while (M[x + y] > 0) {
M[x + y]--;
k = x + y;
x = y;
y = k;
tmp++;
}
ans = max(ans, tmp);
x = A[i];
y = A[j];
M[x]++;
M[y]++;
while (P[x + y] != M[x + y]) {
M[x + y]++;
k = x + y;
x = y;
y = k;
}
}
}
tmp = 0;
for (int i = (0); i < (n); i++)
if (A[i] == 0ll) tmp++;
ans = max(ans, tmp);
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const long long int INFLL = 1e18 + 10;
const long double EPS = 1e-8;
const long double EPSLD = 1e-14;
const long long int MOD = 1e9 + 7;
template <class T>
T &chmin(T &a, const T &b) {
return a = min(a, b);
}
template <class T>
T &chmax(T &a, const T &b) {
return a = max(a, b);
}
const int MAX_N = 100010;
int n;
int a[MAX_N];
int cnt[MAX_N];
int main() {
scanf("%d", &n);
for (int i = (0); i < (int)(n); i++) scanf("%d", &a[i]);
sort(a, a + n);
int minv = a[0];
int maxv = a[n - 1];
if (maxv - minv >= MAX_N) return puts("NO");
int m = maxv - minv;
for (int i = (0); i < (int)(n); i++) cnt[a[i] - minv]++;
cnt[0]--;
cnt[m]--;
for (int i = (1); i < (int)(m); i++) {
if (cnt[i] < 2) return puts("NO");
cnt[i] -= 2;
}
for (int i = (0); i < (int)(m + 1); i++) {
if (cnt[i + 1] < cnt[i]) return puts("NO");
cnt[i + 1] -= cnt[i];
cnt[i] = 0;
}
puts("YES");
return 0;
}
| 4 |
#include <stdio.h>
int main(){
int n,m,x,y,a[31];
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)a[i]=i;
for(int i=0;i<m;i++){
scanf("%d,%d",&x,&y);
a[0]=a[x];
a[x]=a[y];
a[y]=a[0];
}
for(int i=1;i<=n;i++){
printf("%d\n",a[i]);
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
#define mp make_pair
#define pb push_back
#define fst first
#define snd second
typedef long long ll;
typedef pair<int,int> pii;
const int maxn=155;
int n,k,mod;
int f[maxn][maxn][maxn];
map<pii,int>g[maxn][maxn][maxn];
void Add(int &a,int b){a+=b;if(a>=mod)a-=mod;}
int main(){
scanf("%d%d%d",&n,&k,&mod);
if(k%2==0){
k/=2;
f[0][0][0]=1;
rep(i,n)rep(p,k+1)rep(q,k+1){
int cur=f[i][p][q];
if(!cur)continue;
Add(f[i+1][q+1][p],cur);
Add(f[i+1][0][p],cur);
}
int ans=0;
rep(p,k+1)rep(q,k+1)Add(ans,f[n][p][q]);
printf("%d\n",ans);
}
else{
g[0][0][0][mp(n+1,n+1)]=1;
rep(i,n)rep(p,i/2+2)rep(q,i/2+2){
for(map<pii,int>::iterator it=g[i][p][q].begin();it!=g[i][p][q].end();it++){
int fp=(it->fst).fst,fq=(it->fst).snd,cur=it->snd;
if(!(i&1)){
Add(g[i+1][0][q][mp(n+1,fq)],cur);
if(i+1<fp){
if(i+1-k>=i-2*(q-1))Add(g[i+1][p+1][q][mp(fp,min(fq,i+1-2*p+k))],cur);
else Add(g[i+1][p+1][q][mp(fp,fq)],cur);
}
}
else{
Add(g[i+1][p][0][mp(fp,n+1)],cur);
if(i+1<fq){
if(i+1-k>=i-2*(p-1))Add(g[i+1][p][q+1][mp(min(fp,i+1-2*q+k),fq)],cur);
else Add(g[i+1][p][q+1][mp(fp,fq)],cur);
}
}
}
}
int ans=0;
rep(p,n/2+2)rep(q,n/2+2)
for(map<pii,int>::iterator it=g[n][p][q].begin();it!=g[n][p][q].end();it++)
Add(ans,it->snd);
printf("%d\n",ans);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int co = 0;
for (int i = 0; i < n - 1; i++) {
if (i == 0) co += arr[i];
co += ((abs(arr[i] - arr[i + 1])) + 1);
}
co += n;
if (n == 1) co = 2;
cout << co << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
string oper;
bool val;
int left = -1;
int right = -1;
bool will_left_change = false;
bool will_right_change = false;
};
vector<Node> tree;
bool f(bool l_val, bool r_val, string oper) {
if (oper == "AND") {
return (l_val && r_val);
} else if (oper == "OR") {
return (l_val || r_val);
} else if (oper == "XOR") {
return (l_val ^ r_val);
}
}
void calc(Node &v) {
if (v.oper == "IN") return;
calc(tree[v.left]);
if (v.right != -1) {
calc(tree[v.right]);
}
if (v.right == -1)
v.val = !tree[v.left].val;
else {
v.val = f(tree[v.left].val, tree[v.right].val, v.oper);
}
if (v.right == -1)
v.will_left_change = true;
else {
v.will_left_change = (f(tree[v.left].val, tree[v.right].val, v.oper) !=
f(!tree[v.left].val, tree[v.right].val, v.oper));
v.will_right_change = (f(tree[v.left].val, tree[v.right].val, v.oper) !=
f(tree[v.left].val, !tree[v.right].val, v.oper));
}
}
vector<int> ans;
void calc_leaves(Node &v, int ones_cnt, int depth, int v_index) {
if (v.oper == "IN") {
if (ones_cnt == depth) {
ans[v_index] = !tree[1].val;
} else {
ans[v_index] = tree[1].val;
}
return;
}
calc_leaves(tree[v.left], ones_cnt + (int)v.will_left_change, depth + 1,
v.left);
if (v.right != -1) {
calc_leaves(tree[v.right], ones_cnt + (int)v.will_right_change, depth + 1,
v.right);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
tree.resize(n + 1);
ans.resize(n + 1, -1);
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
if (s == "IN") {
int z;
cin >> z;
tree[i].oper = s;
tree[i].val = z;
} else if (s == "NOT") {
int id;
cin >> id;
tree[i].oper = s;
tree[i].left = id;
} else {
int left, right;
cin >> left >> right;
tree[i].oper = s;
tree[i].left = left;
tree[i].right = right;
}
}
calc(tree[1]);
calc_leaves(tree[1], 0, 0, -1);
for (int i = 1; i <= n; i++) {
if (ans[i] != -1) cout << ans[i];
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
int count = 0;
for (int i = 0; i <= 100; i++) {
int last_digit = n % 10;
if (abs(last_digit) == 8) {
if (count != 0) {
cout << count << endl;
break;
}
} else {
long long remain = abs(n / 10);
while (remain > 0) {
if (abs(remain % 10) == 8 && count != 0) {
cout << count << endl;
exit(0);
}
remain /= 10;
}
}
n++;
count++;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10, lg = 22;
vector<pair<int, pair<int, int> > > edge;
vector<pair<int, int> > g[MAX];
int h[MAX], f[MAX], par[MAX][lg], ans[MAX][lg];
int root(int v) { return f[v] < 0 ? v : f[v] = root(f[v]); }
bool merge(int a, int b) {
if ((a = root(a)) == (b = root(b))) return false;
if (f[b] < f[a]) swap(a, b);
return f[a] += f[b], f[b] = a, true;
}
void dfs(int v, int p = -1) {
for (auto uu : g[v])
if (uu.first != p) {
int u = uu.first;
par[u][0] = v, ans[u][0] = uu.second;
h[u] = h[v] + 1;
for (int i = 1; i < lg; i++)
par[u][i] = par[par[u][i - 1]][i - 1],
ans[u][i] = max(ans[u][i - 1], ans[par[u][i - 1]][i - 1]);
dfs(u, v);
}
}
int parent(int v, int h) {
for (int i = 0; i < lg; i++)
if (h & (1 << i)) v = par[v][i];
return v;
}
int res(int v, int h) {
int ret = 0;
for (int i = 0; i < lg; i++)
if (h & (1 << i)) ret = max(ret, ans[v][i]), v = par[v][i];
return ret;
}
int lca(int v, int u) {
if (h[v] < h[u]) swap(v, u);
v = parent(v, h[v] - h[u]);
if (v == u) return v;
for (int i = lg - 1; i >= 0; i--)
if (par[v][i] != par[u][i]) v = par[v][i], u = par[u][i];
return par[v][0];
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
memset(f, -1, sizeof f);
int n, m, a, b, c;
cin >> n >> m;
for (int i = 0; i < m; i++)
cin >> a >> b >> c, a--, b--, edge.push_back({c, {a, b}});
sort(edge.begin(), edge.end());
long long mst = 0;
for (int i = 0; i < m; i++) {
a = edge[i].second.first, b = edge[i].second.second, c = edge[i].first;
if (merge(a, b)) g[a].push_back({b, c}), g[b].push_back({a, c}), mst += c;
}
int comp = 0;
for (int i = 0; i < n; i++)
if (f[i] < 0) comp++;
dfs(0);
int q;
cin >> q;
while (q--) {
int a, b;
cin >> a >> b, a--, b--;
if (comp > 2)
cout << -1 << '\n';
else if (comp == 2) {
if (root(a) == root(b))
cout << -1 << '\n';
else
cout << mst << '\n';
} else {
int v = lca(a, b);
cout << mst - max(res(a, h[a] - h[v]), res(b, h[b] - h[v])) << '\n';
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
vector<int> v;
for (int i = 0; i < q; i++) {
int x, y;
cin >> x;
if (x == 0) {
cin >> y;
v.push_back(y);
}
if (x == 1) {
cin >> y;
cout << v.at(y) << endl;
}
if (x == 2)
v.pop_back();
}
}
| 0 |
#include <iostream>
#include <string>
using namespace std;
int main(void)
{
int n, m;
string str;
while (cin >> n, n){
cin >> m >> str;
int cnt = 0, res = 0;
for (int i = 1; i < m-1; i++){
if (str[i-1] == 'I' && str[i] == 'O' && str[i+1] == 'I') {
cnt++;
i++;
}
else cnt = 0;
if (n <= cnt) res++;
}
cout << res << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
template <typename T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
using ll = long long;
const int MN = 55, MD = 105;
int N, M, K;
struct Subj {
public:
ll a;
int d, c, id;
bool operator<(const Subj& o) const { return c < o.c; }
} a[MN];
ll dp[MN][MN][MD];
int pr[MN][MN][MD];
std::vector<std::array<ll, 2> > f;
void ans(int n, int d) {
printf("YES\n");
for (int i = N; i; --i) {
int v = pr[i][n][d];
f.push_back({a[n].id, a[n].a + d});
n = (v >> 8 & 0xff) - 1;
d = v & 0xff;
}
std::reverse(f.begin(), f.end());
for (auto x : f) printf("%lld %lld\n", x[0], x[1]);
}
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int i = 0; i < M; ++i) {
ll a, b;
int c;
scanf("%lld%lld%d", &a, &b, &c);
::a[i] = {a, (int)(b - a), c, i + 1};
}
std::sort(a, a + M);
memset(dp, -1, sizeof dp);
for (int i = 0, j; i < M; i = j) {
for (j = i; j < M && a[i].c == a[j].c; ++j) {
if (i)
for (int x = 0; x < i; ++x)
for (int k = 0; k <= a[x].d; ++k)
for (int v = 1; v < N; ++v)
if (~dp[v][x][k]) {
ll nk;
nk = (a[x].a + k) * K - a[j].a;
if (0 <= nk && nk <= a[j].d)
if (ckmax(dp[v + 1][j][nk], dp[v][x][k] + nk + a[j].a))
pr[v + 1][j][nk] = x + 1 << 8 | k;
nk = (a[x].a + k) + K - a[j].a;
if (0 <= nk && nk <= a[j].d)
if (ckmax(dp[v + 1][j][nk], dp[v][x][k] + nk + a[j].a))
pr[v + 1][j][nk] = x + 1 << 8 | k;
}
for (int k = 0; k <= a[j].d; ++k)
dp[1][j][k] = a[j].a + k, pr[1][j][k] = 0;
}
}
int n = -1, d = -1;
ll best = -1;
for (int i = 0; i < M; ++i)
for (int j = 0; j <= a[i].d; ++j)
if (ckmax(best, dp[N][i][j])) n = i, d = j;
if (~best)
ans(n, d);
else
printf("NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int m, n, j, k, l, i, o, p, __t, mod;
long long step[700][700], In[700], Out[700], Repre[700], In_num, Out_num;
int L[700 * 700], op, ed, inque[700], deg[700];
long long Way[700];
char ch;
void read(int &a) {
for (ch = getchar(); (ch < '0' || ch > '9') && (ch != '-'); ch = getchar())
;
if (ch == '-')
a = 0, __t = -1;
else
a = ch - '0', __t = 1;
for (ch = getchar(); ch >= '0' && ch <= '9'; ch = getchar())
a = a * 10 + ch - '0';
a *= __t;
}
struct matrix {
long long M[700][700];
void set(int x, int y, int a) { M[x][y] = a; }
void swap_line(int a, int b) {
for (int i = (1); i <= (In_num); i++) swap(M[a][i], M[b][i]);
}
void solve() {
long long ans = 1;
for (int i = (1); i <= (In_num); i++) {
bool find = 0;
for (int j = (i); j <= (In_num); j++)
if (M[j][i] != 0) {
find = 1;
swap_line(i, j);
if (i != j) ans *= -1;
break;
}
for (int j = (i + 1); j <= (In_num); j++)
if (M[j][i] != 0) {
for (; M[j][i] != 0;) {
if (abs(M[j][i]) < abs(M[i][i])) swap_line(i, j), ans *= -1;
long long dec = M[j][i] / M[i][i];
for (int k = (i); k <= (In_num); k++)
M[j][k] = (M[j][k] - M[i][k] * dec) % mod;
}
}
ans = (ans * M[i][i]) % mod;
}
cout << (ans + mod) % mod << endl;
}
} mat;
int main() {
read(m), read(n), read(mod);
for (int i = (1); i <= (n); i++) {
read(j), read(k);
step[j][k]++;
Out[j]++;
In[k]++;
}
for (int i = (1); i <= (m); i++)
if (Out[i] == 0) Repre[i] = ++In_num;
for (int i = (1); i <= (m); i++)
if (In[i] == 0) {
memset(Way, 0, sizeof Way);
memset(inque, 0, sizeof inque);
Way[i] = 1;
inque[L[op = ed = 1] = i] = 1;
++Out_num;
n = 0;
for (int now = L[ed]; ed <= op; ed++, now = L[ed])
for (int def = (1); def <= (m); def++)
if (step[now][def] > 0)
if (!inque[def]) inque[L[++op] = def] = 1;
for (int i = 1; i <= op; i++) {
for (int j = (1); j <= (m); j++)
if (inque[j] && j != L[i] && step[L[i]][j]) deg[L[i]]++;
if (deg[L[i]] == 0) L[++n] = L[i];
}
for (op = n, ed = 1; ed <= op; ed++) {
int now = L[ed];
for (int i = (1); i <= (m); i++)
if (inque[i] && deg[i] > 0 && step[i][now] > 0) {
deg[i]--;
if (deg[i] == 0) L[++op] = i;
}
}
for (int i = op; i; i--)
for (int j = (1); j <= (m); j++)
if (step[L[i]][j])
Way[j] = (Way[j] + step[L[i]][j] * Way[L[i]]) % mod;
for (int j = (1); j <= (m); j++)
if (Repre[j] != 0) mat.set(Out_num, Repre[j], Way[j]);
}
mat.solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
char s[1000];
scanf("%s", s);
int i, j, max = strlen(s);
int l = max;
for (i = 0; i <= l; i++) {
int count = 0;
int countl = 0;
int countr = 0;
int count1 = 0;
for (j = 0; j < i; j++)
if (s[j] == '1') countl += 1;
count1 = i - countl;
for (j = i; j < l; j++)
if (s[j] == '0') countr += 1;
count1 += (l - i - countr);
count = countl + countr;
if (max > count) max = count;
if (max > count1) max = count1;
}
cout << max << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
if ((n & 1) == 1)
cout << "black";
else
cout << "white\n1 2";
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n;
double a, d, t, v, x, y;
while (scanf("%d%lf%lf", &n, &a, &d) != EOF) {
y = 0.0;
while (n--) {
scanf("%lf%lf", &t, &v);
if (d - v * v / 2 / a > 0)
x = t + v / a + (d - v * v / 2 / a) / v;
else {
x = t + sqrt(2 * d / a);
}
if (x <= y)
printf("%.10lf\n", y);
else {
printf("%.10lf\n", x);
y = x;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
int mod = (int)1e9 + 7;
const int logN = 18;
const int inf = 1e9 + 9;
const int N = 2e5 + 6;
int n, m, x, y, z, t, root[N], p[N];
long long ans;
vector<pair<int, pair<int, int> > > v;
int findset(int x) { return root[x] = root[x] == x ? x : findset(root[x]); }
int can(int x, int y) {
x = findset(x);
y = findset(y);
if (x == y && p[x] <= 0) return 0;
if (x != y && p[x] == 0 && p[y] == 0) return 0;
return 1;
}
void go(int x, int y) {
x = findset(x);
y = findset(y);
if (x == y) {
p[x]--;
return;
}
p[x] += p[y];
p[x]--;
root[y] = x;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &x, &y, &z);
v.push_back(make_pair(z, make_pair(x, y)));
}
sort(v.begin(), v.end(), greater<pair<int, pair<int, int> > >());
for (int i = 1; i <= n; i++) p[i] = 1, root[i] = i;
for (__typeof(v.begin()) it = v.begin(); it != v.end(); it++) {
int x = it->second.first, y = it->second.second, z = it->first;
if (!can(x, y)) continue;
ans += z;
go(x, y);
}
cout << ans << '\n';
return 0;
}
| 6 |
#include<iostream>
#include<cmath>
using namespace std;
int N_MAX = 100000;
int main()
{
int k,i;
long long ma=2,mi=2,t;
long long a[N_MAX];
cin >> k;
for(i=0;i<k;i++)
cin >> a[i];
for(i=k-1;i>=0;i--){
t=ma/a[i];
if(t*a[i]<mi){
cout << "-1" << endl;
return 0;
}
ma=(t+1)*a[i]-1;
mi=(long long)ceil((double)mi/a[i])*a[i];
}
cout << mi << " " << ma << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define lp(i,n) for(int i=0;i<n;i++)
#define lpin(a,i,n) for(int i=0;i<n;i++){cin>>a[i];}
void out(pair<int,char> a[],int n){
lp(i,n){
if(i!=0) cout<<" ";
cout<<a[i].second<<a[i].first;
}
cout<<endl;
return;
}
int main(){
int n;
cin>>n;
pair<int,char> a[40],b[40];
lp(i,n){
int memo;
char memo2;
cin>>memo2>>memo;
a[i]=make_pair(memo,memo2);
b[i]=a[i];
}
lp(i,n-1){
for(int j=n-1;j>i;j--){
if(a[j].first<a[j-1].first)
swap(a[j],a[j-1]);
}
}
out(a,n);
cout<<"Stable"<<endl;
lp(i,n){
int minj=i;
for(int j=i;j<n;j++){
if(b[j].first<b[minj].first)
minj=j;
}
swap(b[i],b[minj]);
}
int check=0;
lp(i,n){
if(a[i]!=b[i]){
check=1;
break;
}
}
out(b,n);
if(check==0){
cout<<"Stable"<<endl;
}
else cout<<"Not stable"<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
const long long INF = 1e15;
int n, m, k;
vector<pair<int, int> > added;
long long dist[N];
int parent[3][N], sz[3][N];
void initDSU() {
iota(parent[1], parent[1] + N, 0);
iota(parent[2], parent[2] + N, 0);
fill(sz[1], sz[1] + N, 1);
fill(sz[2], sz[2] + N, 1);
}
int findSet(int src, int id) {
if (src == parent[id][src]) return src;
return parent[id][src] = findSet(parent[id][src], id);
}
void makeSet(int x, int y, int id) {
x = findSet(x, id);
y = findSet(y, id);
if (sz[id][x] > sz[id][y]) swap(x, y);
parent[id][x] = y;
sz[id][y] += sz[id][x];
}
bool canMakeSet(int x, int y, int id) {
x = findSet(x, id);
y = findSet(y, id);
if (x == y) return false;
return true;
}
bool check(int x, int y) {
if (y >= x - 1) return false;
return true;
}
void solve() {
initDSU();
cin >> n >> m >> k;
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
makeSet(v, u, 1);
}
for (int i = 1; i <= k; ++i) {
int u, v;
cin >> u >> v;
makeSet(v, u, 2);
}
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n && check(n, m) && check(n, k); ++j) {
if (canMakeSet(i, j, 1) && canMakeSet(i, j, 2)) {
added.emplace_back(i, j), ++m, ++k;
makeSet(i, j, 1);
makeSet(i, j, 2);
}
}
}
cout << added.size() << '\n';
for (pair<int, int> x : added) cout << x.first << ' ' << x.second << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
namespace Quick_Function {
template <typename Temp>
void Read(Temp &x) {
x = 0;
char ch = getchar();
bool op = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') op = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
if (op) x = -x;
}
template <typename T, typename... Args>
void Read(T &t, Args &...args) {
Read(t);
Read(args...);
}
template <typename Temp>
Temp Max(Temp x, Temp y) {
return x > y ? x : y;
}
template <typename Temp>
Temp Min(Temp x, Temp y) {
return x < y ? x : y;
}
template <typename Temp>
Temp Abs(Temp x) {
return x < 0 ? (-x) : x;
}
template <typename Temp>
void Swap(Temp &x, Temp &y) {
x ^= y ^= x ^= y;
}
} // namespace Quick_Function
using namespace Quick_Function;
const int MAXN = 6e5 + 5;
int n, ans;
struct Splay_Node {
int son[2], fa, val, tag;
};
struct Splay_Tree {
Splay_Node t[MAXN];
int root, tot, Top, stk[MAXN];
int Ident(int pos) { return t[t[pos].fa].son[1] == pos ? 1 : 0; }
void Connect(int pos, int fa, int flag) {
t[fa].son[flag] = pos, t[pos].fa = fa;
}
void Push_Down(int pos) {
if (!t[pos].tag) return;
if (t[pos].son[0]) {
t[t[pos].son[0]].val += t[pos].tag, t[t[pos].son[0]].tag += t[pos].tag;
}
if (t[pos].son[1]) {
t[t[pos].son[1]].val += t[pos].tag, t[t[pos].son[1]].tag += t[pos].tag;
}
t[pos].tag = 0;
}
int New(int val, int fa) {
t[++tot].fa = fa, t[tot].val = val;
return tot;
}
void Build() {
root = New(-0x3f3f3f3f, 0);
t[root].son[1] = New(0x3f3f3f3f, root);
}
void Rotate(int pos) {
int fa = t[pos].fa, grand = t[fa].fa;
int flag1 = Ident(pos), flag2 = Ident(fa);
Connect(pos, grand, flag2);
Connect(t[pos].son[flag1 ^ 1], fa, flag1);
Connect(fa, pos, flag1 ^ 1);
}
void Splay(int pos, int to) {
int tmp = pos;
Top = 0;
stk[++Top] = tmp;
while (tmp) stk[++Top] = tmp = t[tmp].fa;
while (Top) Push_Down(stk[Top--]);
for (int fa = t[pos].fa; t[pos].fa != to; Rotate(pos), fa = t[pos].fa)
if (t[fa].fa != to) Ident(pos) == Ident(fa) ? Rotate(fa) : Rotate(pos);
if (!to) root = pos;
}
void Insert(int &pos, int val, int fa) {
if (!pos) {
++ans;
pos = New(val, fa);
Splay(pos, 0);
return;
}
Push_Down(pos);
if (val < t[pos].val)
Insert(t[pos].son[0], val, pos);
else
Insert(t[pos].son[1], val, pos);
}
void Erase(int pos) {
Splay(pos, 0);
int l = t[pos].son[0], r = t[pos].son[1];
while (t[l].son[1]) l = t[l].son[1];
while (t[r].son[0]) r = t[r].son[0];
Splay(l, 0);
Splay(r, l);
t[r].son[0] = 0;
--ans;
}
int Get_Pre(int val) {
int pos, res, newroot;
pos = newroot = root;
while (pos) {
Push_Down(pos);
if (t[pos].val < val) {
res = pos;
pos = t[pos].son[1];
} else
pos = t[pos].son[0];
}
Splay(newroot, 0);
return res;
}
int Get_Nxt(int val) {
int pos, res, newroot;
pos = newroot = root;
while (pos) {
Push_Down(pos);
if (t[pos].val > val) {
res = pos;
pos = t[pos].son[0];
} else
pos = t[pos].son[1];
}
Splay(newroot, 0);
return res;
}
void Move(int l, int r) {
int u = Get_Nxt(l - 1), v = Get_Pre(r);
if (t[u].val > t[v].val) return;
if (u == v)
t[u].val++;
else if (t[u].val < t[v].val) {
Splay(u, 0);
Splay(v, u);
int rson = t[v].son[0];
++t[u].val;
++t[v].val, t[rson].val++;
if (rson) ++t[rson].tag;
}
}
};
Splay_Tree tree;
int main() {
Read(n);
tree.Build();
tree.Insert(tree.root, 0, 0);
ans = 0;
for (int i = 1, l, r; i <= n; i++) {
Read(l, r);
int pos = tree.Get_Nxt(r - 1);
if (pos && pos != 1 && pos != 2) tree.Erase(pos);
tree.Move(l, r);
tree.Insert(tree.root, l, 0);
}
printf("%d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int mod = 1e9 + 7;
long long a[maxn];
int w[maxn];
vector<long long> E[maxn];
void solve() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
E[i].clear();
}
for (int i = 1; i <= k; i++) cin >> w[i];
sort(a + 1, a + 1 + n, greater<long long>());
sort(w + 1, w + 1 + k, greater<int>());
long long ans = 0;
int b = 1;
for (int i = k; i >= 1; i--) {
E[i].push_back(a[b++]);
}
int r = n;
int g = 1;
while (g <= k) {
while ((int)E[g].size() < w[g]) {
E[g].push_back(a[r--]);
}
g++;
}
for (int i = 1; i <= k; i++) {
long long max1 = -1e9 - 1, min1 = 1e9 + 7;
for (auto &v : E[i]) {
max1 = max(max1, v);
min1 = min(min1, v);
}
ans += max1 + min1;
}
cout << ans << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100006], low[100006], high[100006];
int main() {
int n;
while (~scanf("%d", &n)) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
low[1] = 0, low[2] = 1;
for (int i = 2; i <= n - 1; i++) {
if (a[i] > a[i - 1])
low[i + 1] = low[i] + 1;
else
low[i + 1] = 1;
}
high[n] = 0, high[n - 1] = 1;
for (int i = n - 1; i >= 2; i--) {
if (a[i + 1] > a[i])
high[i - 1] = high[i] + 1;
else
high[i - 1] = 1;
}
int key = 0;
for (int i = 1; i <= n; i++) {
if (a[i + 1] - 1 > a[i - 1]) key = max(key, low[i] + high[i] + 1);
key = max(key, low[i] + 1);
key = max(key, high[i] + 1);
}
printf("%d\n", key);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long double N,P;
long ans;
cin >> N >> P;
ans = (long)pow(P,1/N);
while((long)P % (long)pow(ans,N) != 0){
ans--;
}
cout << ans << endl;
return 0;
} | 0 |
#include <iostream>
#include <vector>
#define rep(i,n) for(int i=0;i<(n);i++)
#define INF 1e+100
#define vint vector<int>
#define abs(x) ((x)>=0?(x):-(x))
using namespace std;
int main()
{
int n;
cin >> n;
int MAX_N = (1 << n), ID[n], d[n], box[n];
rep (i, n )
cin >> ID[i] >> d[i] >> box[i];
double dp[n][MAX_N];
vint path[n][MAX_N];
int w[MAX_N];
rep (i, MAX_N ){
int sum = 0, cnt = 0;
for (int j = 1; j < MAX_N; j = (j << 1), cnt++ ){
if ((i & j ) != 0 ){
sum += box[cnt];
}// end if
} // end for
w[i] = sum*20;
} // end rep
fill (&dp[0][0], &dp[n-1][MAX_N], INF );
rep (i, n ){
dp[i][1 << i] = 0.;
path[i][1 << i].push_back (i );
} // end rep
rep (i, MAX_N ){
double v = 2000.0/(double)(70 + w[i] );
rep (j, n ){
int now = (1 << j );
if ( (i & now ) == 0 ) continue; // ܾKêĢȢ
rep (k, n ){
int next = (1 << k );
if ( (i & next ) ) continue; // à¤Kê½
double cost = (double)(abs(d[j] - d[k] ) )/v;
if (dp[k][i|next] > dp[j][i] + cost ){
dp[k][i|next] = dp[j][i] + cost;
path[k][i|next] = path[j][i];
path[k][i|next].push_back (k );
} // end if
} // end rep
} // end rep
} // end rep
double min = INF;
vint ans;
rep (i, n ){
if (min > dp[i][MAX_N-1] ){
min = dp[i][MAX_N-1];
ans = path[i][MAX_N-1];
} // end if
} // end rep
rep (i, ans.size() ){
if (i != 0 )
cout << ' ';
cout << ID[ans[i]];
} // end rep
cout << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
const int M = 33;
const int K = 670000;
const int LIT = 2500;
const int INF = 1 << 30;
const int base = 137;
const double eps = 1e-10;
const int dir[5][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
const int dir2[10][2] = {{-1, 0}, {1, 0}, {0, 1}, {0, -1},
{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
const int ABS(int a) { return a > 0 ? a : -a; }
int n;
char m[5][N];
void init() {
memset(m, 0, sizeof(m));
if (n % 2 == 0) {
for (int i = 0, f = 0; i < n; i += 2, f ^= 1) {
m[0][i] = m[0][i + 1] = f + 'a';
m[3][i] = m[3][i + 1] = f + 'a';
}
m[1][0] = m[2][0] = 'c';
m[1][n - 1] = m[2][n - 1] = 'z';
for (int i = 1, f = 0; i < n - 1; i += 2, f ^= 1) {
m[1][i] = m[1][i + 1] = f + 'd';
}
for (int i = 1, f = 0; i < n - 1; i += 2, f ^= 1) {
m[2][i] = m[2][i + 1] = f + 'e';
}
} else {
for (int i = 0, f = 0; i < n; i += 2, f ^= 1) {
m[0][i] = m[0][i + 1] = f + 'a';
m[1][i] = m[1][i + 1] = f + 'd';
}
m[0][n - 1] = m[1][n - 1] = 'z';
m[2][0] = m[3][0] = 'z';
for (int i = 1, f = 0; i < n; i += 2, f ^= 1) {
m[2][i] = m[2][i + 1] = f + 'g';
m[3][i] = m[3][i + 1] = f + 'a';
}
}
}
void solve() {
if (n == 1) {
printf("a\na\nb\nb\n");
return;
}
for (int i = 0; i <= 3; i++) {
for (int j = 0; j < n; j++) printf("%c", m[i][j]);
printf("\n");
}
}
int main() {
while (cin >> n) {
init();
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int n, b;
while (scanf("%d", &n) != EOF) {
b = 0;
int ans;
scanf("%d", &ans);
for (int i = 1; i < n; i++) {
scanf("%d", &b);
ans = gcd(ans, b);
}
printf("%d\n", ans * n);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n, h, cnt = 0;
char old;
cin >> n;
cin >> s;
n = s.length();
old = s[0];
for (int i = 1; i < n; i++) {
if (old == s[i]) {
cnt = cnt + 1;
} else {
old = s[i];
}
}
cout << cnt;
return 0;
}
| 1 |
//Love and Freedom.
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
#define ll long long
#define inf 20021225
using namespace std;
int read()
{
int s=0,t=1; char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-') t=-1; ch=getchar();}
while(ch>='0' && ch<='9') s=s*10+ch-'0',ch=getchar();
return s*t;
}
#define N 3010
int mdn;
void upd(int &x,int y){x+=x+y>=mdn?y-mdn:y;}
int ksm(int bs,int mi)
{
int ans=1;
while(mi)
{
if(mi&1) ans=1ll*ans*bs%mdn;
bs=1ll*bs*bs%mdn; mi>>=1;
}
return ans;
}
int qsm(int bs,int mi)
{
int ans=1;
while(mi)
{
if(mi&1) ans=1ll*ans*bs%(mdn-1);
bs=1ll*bs*bs%(mdn-1); mi>>=1;
}
return ans;
}
int f[N][N],n,c[N][N];
void init()
{
f[1][1]=1; c[0][0]=c[1][0]=c[1][1]=1;
for(int i=2;i<=n+1;c[i][0]=1,i++) for(int j=1;j<=n+1;j++)
f[i][j]=(f[i-1][j-1]+1ll*f[i-1][j]*j%mdn)%mdn,
c[i][j]=(c[i-1][j-1]+c[i-1][j])%mdn;
}
int F(int x)
{
int ans=0,k=ksm(2,n-x),tmp=1,w=ksm(2,qsm(2,n-x));
for(int i=0;i<=x;i++) upd(ans,1ll*tmp*f[x+1][i+1]%mdn*w%mdn),tmp=1ll*tmp*k%mdn;
return ans;
}
int main()
{
n=read(); mdn=read(); init(); int ans=0;
for(int i=0;i<=n;i++) upd(ans,1ll*(i&1?mdn-1:1)*F(i)%mdn*c[n][i]%mdn);
printf("%d\n",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[505][505];
memset(arr, -1, sizeof arr);
int n, m;
cin >> n >> m;
vector<int> x(n);
for (int i = 0; i < n; ++i) scanf("%d", &x[i]);
for (int i = 0; i < m; ++i) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
--a, --b;
arr[a][b] = c;
arr[b][a] = c;
}
if (n == 1) {
cout << 0 << endl;
return 0;
}
double res = 0;
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
if (arr[i][j] != -1) res = max(res, (0.0 + x[i] + x[j]) / arr[i][j]);
cout << setprecision(18);
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char c[1000001];
int a[1000001];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c[i];
}
int s1 = 0, s2 = 0;
for (int i = 1; i <= n; i++) {
if (c[i] == '(') {
if (s1 <= s2) {
s1++;
a[i] = 0;
} else {
s2++;
a[i] = 1;
}
}
if (c[i] == ')') {
if (s1 >= s2) {
s1--;
a[i] = 0;
} else {
s2--;
a[i] = 1;
}
}
}
for (int i = 1; i <= n; i++) {
cout << a[i];
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c;
void move1step(int& a, int& b, const int& q) {
int c = a - q * b;
a = b;
b = c;
}
int eGCD(int r0, int r1, int& x0, int& y0) {
int x1 = y0 = 0, y1 = x0 = 1;
while (r1) {
int q = r0 / r1;
move1step(r0, r1, q);
move1step(x0, x1, q);
move1step(y0, y1, q);
}
return r0;
}
int main() {
int X, Y;
cin >> a >> b >> c;
int mgcd = eGCD(a, b, X, Y);
if (-c % mgcd == 0) {
cout << X * ((c * -1) / mgcd) << ' ' << Y * ((c * -1) / mgcd) << endl;
} else {
cout << -1;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n % 3 == 0) {
cout << n / 3 * 2;
}
if (n % 3 > 0) {
cout << (n - 1) / 3 * 2 + 1;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dp[107][107][107], f[107], pd[107], n, k;
string s;
const long long mod = 1e9 + 7;
long long pw(long long a, long long b) {
if (b == 0) return 1LL;
if (b == 1) return a;
long long ret = pw(a, b / 2);
if (b % 2 == 0) return ret * ret % mod;
return ret * ret % mod * a % mod;
}
void add(long long &a, long long b) { a = (a + b) % mod; }
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
cin >> s;
f[0] = 1;
f[1] = 1;
for (int i = 2; i <= k; i++) f[i] = (f[i - 1] + f[i - 2]) % (mod - 1);
for (int i = 0; i <= k; i++) pd[i] = pw(2LL, f[i]);
for (int i = 1; i <= n; i++) {
dp[s[i - 1] - '0'][i][i] = 1;
}
for (int i = 2; i <= k; i++) {
for (int l = 1; l <= n; l++) {
for (int r = l; r <= n; r++) {
for (int m = l - 1; m <= r; m++) {
if (m == r)
add(dp[i][l][r],
dp[i - 1][l][r] * (r == n ? pd[i - 2] : 1LL) % mod);
else if (m == l - 1)
add(dp[i][l][r],
dp[i - 2][l][r] * (l == 1 ? pd[i - 1] : 1LL) % mod);
else
add(dp[i][l][r], dp[i - 1][l][m] * dp[i - 2][m + 1][r] % mod);
}
}
}
}
cout << dp[k][1][n];
}
| 6 |
Subsets and Splits