solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
const long long int maxn = 500005;
const long long int mm = 1e+18;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
int a[n], p[m];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> p[i];
bool temp = true;
int count = 0;
while (temp) {
count = 0;
for (int i = 0; i < m; i++) {
int x = p[i], y;
y = x - 1;
if (a[y] > a[x]) {
int str = a[x];
a[x] = a[y];
a[y] = str;
count++;
}
}
if (count == 0) temp = false;
}
count = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i] > a[i + 1]) {
count++;
break;
}
}
if (count > 0) {
cout << "NO" << endl;
} else
cout << "YES" << endl;
}
return 0;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
const int INF = 1000000000, mod = 1000000007;
const long long LLINF = 1000000000000000000ll;
int BUBEN = 474;
struct Set {
long long add;
long long sum;
vector<int> v;
Set() {}
Set(vector<int> v, long long sum) : v(v), add(0ll), sum(sum) {}
};
vector<Set> light, heavy;
long long a[N];
int type[N];
int pos[N];
int inter1[500][N], inter2[500][500];
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
BUBEN = (int)floor(sqrt(n + .0));
for (int i = 1; i <= n; ++i) {
scanf("%I64d", &a[i]);
}
for (int i = 0; i < m; ++i) {
int k;
scanf("%d", &k);
long long sum = 0ll;
vector<int> temp(k);
for (int j = 0; j < k; ++j) {
scanf("%d", &temp[j]);
sum += a[temp[j]];
}
if (k <= BUBEN) {
light.push_back(Set(temp, sum));
type[i] = 0;
pos[i] = light.size() - 1;
} else {
heavy.push_back(Set(temp, sum));
type[i] = 1;
pos[i] = heavy.size() - 1;
}
}
for (size_t i = 0; i < heavy.size(); ++i) {
vector<int> is(N, 0);
for (size_t j = 0; j < heavy[i].v.size(); ++j) {
is[heavy[i].v[j]]++;
}
for (size_t j = 0; j < light.size(); ++j) {
int cnt = 0;
for (int k = 0; k < light[j].v.size(); ++k) {
cnt += is[light[j].v[k]];
}
inter1[i][j] = cnt;
}
for (size_t j = 0; j < heavy.size(); ++j) {
int cnt = 0;
for (int k = 0; k < heavy[j].v.size(); ++k) {
cnt += is[heavy[j].v[k]];
}
inter2[i][j] = inter2[j][i] = cnt;
}
}
while (q-- > 0) {
char t;
t = getchar();
t = getchar();
if (t == '?') {
int k;
scanf("%d", &k);
--k;
long long ans = 0;
if (type[k] == 0) {
for (size_t i = 0; i < light[pos[k]].v.size(); ++i) {
ans += a[light[pos[k]].v[i]];
}
for (size_t i = 0; i < heavy.size(); ++i) {
ans += heavy[i].add * 1ll * inter1[i][pos[k]];
}
} else {
ans = heavy[pos[k]].sum;
for (size_t i = 0; i < heavy.size(); ++i) {
ans += heavy[i].add * 1ll * inter2[pos[k]][i];
}
}
printf("%I64d\n", ans);
} else {
int k, x;
scanf("%d%d", &k, &x);
--k;
if (type[k] == 0) {
for (size_t i = 0; i < light[pos[k]].v.size(); ++i) {
a[light[pos[k]].v[i]] += x;
}
for (size_t i = 0; i < heavy.size(); ++i) {
heavy[i].sum += x * 1ll * inter1[i][pos[k]];
}
} else {
heavy[pos[k]].add += x;
}
}
}
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long long> vec(100001, 0);
int main() {
int k = 1, step = 2;
int n;
cin >> n;
while (k <= n) {
n -= k;
k += step;
step++;
}
cout << step - 2;
return 0;
}
| 800 | CPP |
t=int(input())
for _ in range(t):
n=int(input())
lst=list(map(int,input().split()))
e_sum=0
for i in range(0,n,2):
e_sum+=lst[i]
# print(e_sum)
mx1=0
mmx1=0
for i in range(0,n-1,2):
tmp=lst[i+1]-lst[i]
mx1=max(mx1+tmp,0)
if mmx1<mx1:
mmx1=mx1
# print(mx1)
mx2=0
mmx2=0
for i in range(1,n-1,2):
# print("i",i)
tmp=lst[i]-lst[i+1]
mx2=max(mx2+tmp,0)
# print("m2",mx2)
if mmx2<mx2:
mmx2=mx2
# print(mx2)
print(e_sum+max(mmx1,mmx2))
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int k1, k2;
long long int dp[101][101][11][11];
long long int rec(long long int n1, long long int n2, long long int x,
long long int y) {
if (n1 == 0 && n2 == 0) return 1;
if (dp[n1][n2][x][y] != -1) return dp[n1][n2][x][y];
long long int a1 = 0, a2 = 0;
if (x > 0 && n1 > 0) a1 = rec(n1 - 1, n2, x - 1, k2);
if (y > 0 && n2 > 0) a2 = rec(n1, n2 - 1, k1, y - 1);
return dp[n1][n2][x][y] = (a1 + a2) % 100000000;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(dp, -1, sizeof(dp));
long long int n1, n2;
cin >> n1 >> n2 >> k1 >> k2;
cout << rec(n1, n2, k1, k2);
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mn = 3e5 + 5;
int n, m;
long long T;
vector<int> g[mn];
long long a[mn], c[mn];
int p[mn];
long long l[mn];
int tid[mn];
long long t[mn];
long long cnt[mn];
void add(long long *t, int i, long long x) {
while (i <= n) t[i] += x, i += i & -i;
}
long long sum(long long *t, int i) {
long long s = 0;
while (i) s += t[i], i -= i & -i;
return s;
}
int binary_search(long long *t, long long T) {
int u = 0;
bool high = 1;
for (int i = 20; i >= 0; i--) {
int nxtpos = u ^ (1 << i);
if (!high || ((1 << i) & n)) {
if (T < t[nxtpos])
high = 0;
else
T -= t[nxtpos], u ^= (1 << i);
}
}
return u;
}
long long ans;
long long dp[mn];
inline long long getans(long long T) {
int k = binary_search(t, T);
T -= sum(t, k);
long long ans = sum(cnt, k);
if (k == n) return ans;
long long more = sum(cnt, k + 1) - ans;
long long morecost = sum(t, k + 1) - sum(t, k);
long long cost = morecost / more;
ans += T / cost;
return ans;
}
void dfs(int x, long long T) {
if (T < 0) return;
add(t, tid[x], a[x] * c[x]);
add(cnt, tid[x], a[x]);
dp[x] = getans(T);
vector<long long> v;
for (auto &i : g[x]) {
dfs(i, T - l[i] * 2);
if (dp[i] > 0) v.push_back(dp[i]);
}
sort(v.begin(), v.end());
if (!v.empty() && x != 1) v.pop_back();
for (auto &i : v) dp[x] = max(i, dp[x]);
add(t, tid[x], -a[x] * c[x]);
add(cnt, tid[x], -a[x]);
}
int main() {
scanf("%d%lld", &n, &T);
vector<pair<int, int> > v;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (int i = 1; i <= n; i++) {
scanf("%lld", &c[i]);
v.push_back({c[i], i});
}
for (int i = 2; i <= n; i++) {
scanf("%d%lld", &p[i], &l[i]);
g[p[i]].push_back(i);
}
sort(v.begin(), v.end());
for (int i = 0; i < (int)v.size(); i++) {
tid[v[i].second] = i + 1;
}
dfs(1, T);
printf("%lld\n", dp[1]);
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long dp[41][3][3][3];
int t[3][3];
long long solve(int n, int src, int snk, int tmp) {
if (n == 1) return min(t[src][snk], t[src][tmp] + t[tmp][snk]);
long long &res = dp[n][src][snk][tmp];
if (res != -1) return res;
res = 1LL << 61;
res = min(res, solve(n - 1, src, tmp, snk) + t[src][snk] +
solve(n - 1, tmp, snk, src));
res = min(res, solve(n - 1, src, snk, tmp) + t[src][tmp] +
solve(n - 1, snk, src, tmp) + t[tmp][snk] +
solve(n - 1, src, snk, tmp));
return res;
}
int main() {
int n;
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j) scanf("%d", t[i] + j);
scanf("%d", &n);
memset(dp, -1, sizeof dp);
printf("%I64d\n", solve(n, 0, 2, 1));
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, second;
string s;
cin >> s;
n = s.size();
cout << n * 25 + 26;
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n > 0) {
string o;
cin >> o;
int counter = 0, max_area = 0;
bool fact = true;
for (int i = 0; i < o.size(); i++) {
if (o[i] == 'L') {
fact = false;
break;
}
}
if (fact == true) {
cout << 1 << endl;
} else {
for (int i = 0; i < o.size(); i++) {
if (o[i] == 'L') {
counter++;
}
if (o[i] == 'R' || i + 1 == o.size()) {
max_area = max(max_area, counter);
counter = 0;
}
}
cout << max_area + 1 << endl;
}
n--;
}
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
x = x * 2;
cout << x << endl;
}
return (0);
}
| 800 | CPP |
input()
d = set(list(map(int, input().strip().split())))
x = min(d)
d.remove(x)
sol = [x]
while d:
if x*2 in d:
x = x*2
sol.append(x)
d.remove(x)
elif x%3==0 and x//3 in d:
x = x//3
sol.append(x)
d.remove(x)
else:
break
sol2 = []
x = sol[0]
while d:
if x*3 in d:
x = x*3
sol2.append(x)
d.remove(x)
elif x%2 == 0 and x//2 in d:
x = x//2
sol2.append(x)
d.remove(x)
sol = list(reversed(sol2)) + sol
print(' '.join(map(str, sol)))
# n, k = map(int, input().strip().split())
# d = sorted(list(map(int, input().strip().split())))
# if k == 0:
# print(d[0]-1)
# elif k == n:
# print(d[-1]+1)
# else:
# if d[k-1] in [d[k], d[k]-1]:
# print(-1)
# else:
# print(d[k]-1)
# # 9 3 6 12 4 8 | 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
string s;
int cnt[26];
bool used[26];
bool ok(char ch1, char ch2) {
if (ch1 == 'a')
return ch2 != 'b';
else if (ch1 == 'z')
return ch2 != 'y';
else
return (ch2 != ch1 - 1) && (ch2 != ch1 + 1);
}
string cal(int c) {
memset(used, false, sizeof(used));
used[c] = true;
string t = string(cnt[c], c + 'a');
while (true) {
bool f = false;
for (int x = 0; x < 26; ++x)
if (cnt[x] && !used[x]) {
if (ok(t.back(), x + 'a')) {
t += string(cnt[x], x + 'a');
f = true;
used[x] = true;
}
}
if (!f) break;
}
return t;
}
void solve() {
const int n = s.length();
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; ++i) cnt[s[i] - 'a']++;
for (int i = 0; i < 26; ++i)
if (cnt[i]) {
string t = cal(i);
if ((int)t.length() == n) {
cout << t << '\n';
return;
}
}
cout << "No answer\n";
}
int main() {
int t;
cin >> t;
while (t--) {
cin >> s;
solve();
}
return 0;
}
| 1,800 | CPP |
a,b = map(int,input().split())
l = sorted(list(map(int,input().split())))
z =[]
for i in range(b-a+1):
z.append(l[i+a-1]-l[i])
print(min(z)) | 900 | PYTHON3 |
n, m = map(int, input().split())
print(-sum(sorted(map(lambda x: int(x) if int(x) < 0 else 0, input().split()))[:m]))
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define ar array
#define ll long long
#define int long long int
#define ull unsigned long long
#define pb push_back
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define all(x) (x).begin(),(x).end()
#define uniq(v) (v).erase(unique(all(v)),(v).end())
#define sz(x) (int)((x).size())
#define fr first
#define sc second
#define pii pair<int,int>
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define mem1(a) memset(a,-1,sizeof(a))
#define mem0(a) memset(a,0,sizeof(a))
#define ppc __builtin_popcount
#define ppcll __builtin_popcountll
const int MAX_N = 1e5 + 1;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll LINF = 1e18;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t;
cin >> t;
while (t--)
{
int n;
cin >> n;
int dp[n];
for (int i = 0; i < n; i++) {
cin >> dp[i];
}
sort(dp, dp + n);
int ans = 0;
int sum = 0;
for (int i = 2; i < n; i++) {
int temp = (dp[i] * (i - 1));
sum += dp[i - 2];
ans += sum;
ans -= temp;
}
cout << ans << "\n";
}
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int N;
cin >> N;
long long int powa = 3;
for (; powa < N;) {
if (N % powa) break;
powa *= 3;
}
cout << N / powa + ((N % powa) ? (1) : (0));
return 0;
}
| 1,600 | CPP |
# cook your dish here
n,m=input().split()
n,m=int(n),int(m)
a=list(map(int,input().split()))
b=list(map(int,input().split()))
m1=min(a)
m2=min(b)
if(m1==m2):
print(m1)
else:
x=100
y=100
for i in range(n):
for j in range(m):
if(b[j]==a[i]):
x=a[i]
if(x<y):
y=x
if(y==100):
print(min(m1,m2)*10+max(m1,m2))
else:
print(y) | 900 | PYTHON3 |
import sys
import os.path
from collections import *
import math
import bisect
import heapq as hq
from fractions import Fraction
from random import randint
if (os.path.exists('input.txt')):
sys.stdin = open("input.txt", "r")
sys.stdout = open("output.txt", "w")
##########################################################
input = sys.stdin.readline
def solve():
n = int(input())
s1 = input().rstrip('\n')
s2 = input().rstrip('\n')
x = []
for i in range(n):
x.append(s1[i])
x.append(s2[i])
for i in range(6):
x.append('2')
n *= 2
res = 0
i = 0
while i < n:
if x[i] == '0' and x[i + 1] == '1' or x[i] == '1' and x[i + 1] == '0':
res += 2
i += 2
elif x[i] == '0' and x[i + 1] == '0':
if x[i + 2] == '1' and x[i + 3] == '1':
res += 2
i += 4
else:
res += 1
i += 2
else:
if x[i + 2] == '0' and x[i + 3] == '0':
res += 2
i += 4
else:
res += 0
i += 2
print(res)
t = int(input())
while t:
t -= 1
solve()
########################################################## | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010, mod = 1000000007;
int n, q, k, m, r, a[N], fa[N][17], dep[N], hd[N],
o = 1, bin[20], h[N], f[N][310], st[N], ed[N], c[N], vis[N], idx;
struct Edge {
int v, nt;
} E[N << 1];
char gc() {
static char *p1, *p2, s[1000000];
if (p1 == p2) p2 = (p1 = s) + fread(s, 1, 1000000, stdin);
return (p1 == p2) ? EOF : *p1++;
}
int rd() {
int x = 0;
char c = gc();
while (c < '0' || c > '9') c = gc();
while (c >= '0' && c <= '9') x = (x << 1) + (x << 3) + c - '0', c = gc();
return x;
}
void adde(int u, int v) {
E[o] = (Edge){v, hd[u]};
hd[u] = o++;
E[o] = (Edge){u, hd[v]};
hd[v] = o++;
}
void dfs(int u, int F) {
st[u] = ++idx;
fa[u][0] = F;
dep[u] = dep[F] + 1;
for (int i = 1; bin[i] < dep[u]; ++i) fa[u][i] = fa[fa[u][i - 1]][i - 1];
for (int i = hd[u]; i; i = E[i].nt) {
int v = E[i].v;
if (v == F) continue;
dfs(v, u);
}
ed[u] = idx;
}
int lca(int u, int v) {
if (dep[u] < dep[v]) swap(u, v);
for (int i = 0; i < 17; ++i)
if (bin[i] & (dep[u] - dep[v])) u = fa[u][i];
if (u == v) return u;
for (int i = 16; ~i; --i)
if (fa[u][i] != fa[v][i]) u = fa[u][i], v = fa[v][i];
return fa[u][0];
}
void add(int x, int y) {
for (; x <= n; x += x & -x) c[x] += y;
}
int ask(int x) {
int re = 0;
for (; x; x -= x & -x) re += c[x];
return re;
}
void update(int u, int x) {
vis[u] += x;
add(st[u], x);
add(ed[u] + 1, -x);
}
int query(int u) {
int t = lca(u, r);
return ask(st[u]) + ask(st[r]) - ask(st[t]) * 2 + vis[t];
}
int main() {
n = rd();
q = rd();
for (int i = bin[0] = 1; i <= 17; ++i) bin[i] = bin[i - 1] << 1;
for (int i = 1; i < n; ++i) adde(rd(), rd());
dfs(1, 0);
f[0][0] = 1;
for (int i = 1; i <= q; ++i) {
k = rd();
m = rd();
r = rd();
for (int j = 1; j <= k; ++j) a[j] = rd(), update(a[j], 1);
for (int j = 1; j <= k; ++j) h[j] = query(a[j]) - 1;
sort(h + 1, h + k + 1);
for (int j = 1; j <= k; ++j)
for (int l = 1; l <= m; ++l) {
f[j][l] = ((long long)f[j - 1][l] * max(0, l - h[j]) % mod +
f[j - 1][l - 1]) %
mod;
}
int ans = 0;
for (int l = 0; l <= m; ++l) ans = (ans + f[k][l]) % mod;
printf("%d\n", ans);
for (int j = 1; j <= k; ++j) update(a[j], -1);
}
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Ramps {
int x, d, t, p, start, finsh, time, id;
bool operator<(const Ramps &a) const {
return start < a.start || start == a.start && time < a.time;
}
bool operator<(int a) const { return start < a; }
void init(int x) {
this->start = this->finsh = x;
this->time = 0;
}
} ramps[200010];
struct Edge {
int x, y, len, id;
Edge(int x, int y, int len, int id = 0) {
this->x = x;
this->y = y;
this->len = len;
this->id = id;
}
bool operator<(const Edge &a) const {
return x < a.x || x == a.x && len < a.len;
}
};
vector<Edge> edge;
int first[200010], dist[200010], inque[200010], que[200010];
struct Path {
int from, id;
} path[200010];
void SPFA(int n, int m, int source) {
int left = 0, right = 0;
for (int i = 0; i < n; ++i) {
dist[i] = 1000000000;
inque[i] = 0;
}
inque[source] = 1;
dist[source] = 0;
que[right++] = source;
while (left != right) {
int u = que[left];
inque[u] = 0;
left = (left + 1) % 200010;
for (int i = first[u]; i < m && edge[i].x == u; ++i) {
int v = edge[i].y, w = edge[i].len;
if (dist[u] + w < dist[v]) {
path[v].from = u;
path[v].id = edge[i].id;
dist[v] = dist[u] + w;
if (!inque[v]) {
inque[v] = 1;
que[right] = v;
right = (right + 1) % 200010;
}
}
}
}
}
int input(int n, int L) {
int k = 1;
ramps[0].init(0);
for (int i = 1; i <= n; ++i) {
cin >> ramps[k].x >> ramps[k].d >> ramps[k].t >> ramps[k].p;
ramps[k].id = i;
if (ramps[k].x >= ramps[k].p && ramps[k].t < ramps[k].d) {
ramps[k].start = ramps[k].x - ramps[k].p;
ramps[k].finsh = ramps[k].x + ramps[k].d;
ramps[k].time = ramps[k].p + ramps[k].t;
++k;
}
}
ramps[k++].init(L);
return k;
}
void solve(int n, int L) {
sort(ramps, ramps + n);
for (int i = 1; i < n; ++i) {
edge.push_back(Edge(i - 1, i, ramps[i].start - ramps[i - 1].start));
edge.push_back(Edge(i, i - 1, ramps[i].start - ramps[i - 1].start));
}
for (int i = 1; i < n - 1; ++i) {
int pos = lower_bound(ramps, ramps + n, ramps[i].finsh) - ramps;
edge.push_back(Edge(i, pos,
ramps[i].time + ramps[pos].start - ramps[i].finsh,
ramps[i].id));
edge.push_back(Edge(i, pos - 1,
ramps[i].time + ramps[i].finsh - ramps[pos - 1].start,
ramps[i].id));
}
sort(edge.begin(), edge.end());
for (int i = edge.size() - 1; i >= 0; --i) {
first[edge[i].x] = i;
}
SPFA(n, edge.size(), 0);
vector<int> ans;
int to = n - 1;
while (to) {
if (path[to].id) {
ans.push_back(path[to].id);
}
to = path[to].from;
}
cout << dist[n - 1] << endl;
cout << ans.size() << endl;
for (int i = ans.size() - 1; i >= 0; --i) {
cout << ans[i] << ' ';
}
cout << endl;
}
int main() {
int n, L;
while (cin >> n >> L) {
n = input(n, L);
solve(n, L);
}
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long i, j, n, t;
map<long long, long long> m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> t;
vector<long long> a(n);
long long cnt = 0;
for (long long(i) = (0); (i) < (n); ++(i)) {
cin >> a[i];
if (a[i] % t == 0) cnt++;
a[i] = a[i] % t;
m[a[i]]++;
}
long long ans = 0, red;
sort(a.begin(), a.end());
for (long long(i) = (1); (i) < (t); ++(i)) {
long long r = t - i;
if (i != r)
red = min(m[i], m[r]);
else
red = m[i] / 2;
if (red > 0) {
ans += red;
m[r] -= red;
m[i] -= red;
}
}
cout << (ans * 2) + ((cnt / 2) * 2);
return 0;
}
| 1,200 | CPP |
from fractions import gcd
from collections import Counter
n = int(input())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
l = list(zip(a, b))
res = sum([1 if a[0] == 0 and a[1] == 0 else 0 for a in l])
l = list(filter(lambda a : (a[0] != 0), l))
l = [a if a[1] > 0 else (-a[0], -a[1]) for a in l]
C = Counter()
for a in l:
d = gcd(a[0], a[1])
b = (a[0] / d, a[1] / d)
C[b] += 1
if len(C) > 0:
res += C.most_common(1)[0][1]
print(res) | 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
ifstream from;
const long long nmin = 1, nmax = 1000;
long long n, m, rt, res, i, j, k, ax;
char ch;
if (0) from.open("test.txt");
cin >> n >> m;
vector<vector<char> > v(n);
vector<long long> vx(n), vy(m);
for (i = 0; i < n; i++) v[i].resize(m);
for (i = 0; i < n; i++) vx[i] = 0;
for (j = 0; j < m; j++) vy[j] = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> ch;
if (ch == '*') {
v[i][j] = 1;
vx[i]++;
vy[j]++;
} else
v[i][j] = 0;
}
}
res = 0;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (v[i][j] == 1) res += (vx[i] - 1) * (vy[j] - 1);
cout << res << endl;
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long INF = 1e18;
const int mod = 1e9 + 7;
const long long N = 2e6 + 7;
vector<string> ranks = {"2", "3", "4", "5", "6", "7", "8",
"9", "T", "Q", "K", "A", "J"};
vector<string> suits = {"C", "D", "H", "S"}, replacement;
set<string> cards;
vector<vector<string> > m;
vector<pair<int, int> > positions;
vector<int> dx = {-1, -1, -1, 0, 1, 1, 1, 0, 0};
vector<int> dy = {-1, 0, 1, 1, 1, 0, -1, -1, 0};
int J, r, c;
pair<int, int> J1 = {-1, -1}, J2 = {-1, -1};
map<pair<int, int>, int> used;
bool valid(int x, int y) {
if (x < r && x >= 0 && y < c && y >= 0 && !used[{x, y}]) return true;
return false;
}
bool check() {
used.clear();
positions.clear();
int cnt = 0;
for (int i = 0; i < int(r); i++) {
for (int j = 0; j < int(c); j++) {
int ok = 1;
set<char> rnk, sut;
for (int k = 0; k < int(9); k++) {
int x = i + dx[k], y = j + dy[k];
if (!valid(x, y)) {
ok = 0;
break;
}
rnk.insert(m[x][y][0]);
sut.insert(m[x][y][1]);
}
if (ok && ((int)rnk.size() == 9 || (int)sut.size() == 1)) {
for (int k = 0; k < int(9); k++) {
int x = i + dx[k], y = j + dy[k];
used[{x, y}] = 1;
}
cnt++;
positions.push_back({i, j});
}
}
}
if (cnt >= 2) return true;
return false;
}
bool ok() {
if (J == 1) {
for (auto i : cards) {
replacement.clear();
if (J1.first != -1) {
m[J1.first][J1.second] = *cards.begin();
replacement.push_back("Replace J1 with " + *cards.begin() + ".");
} else {
m[J2.first][J2.second] = *cards.begin();
replacement.push_back("Replace J2 with " + *cards.begin() + ".");
}
if (check()) {
return true;
}
}
return false;
}
if (J == 2) {
for (auto i : cards) {
for (auto j : cards) {
if (i == j) continue;
replacement.clear();
string rem1 = i;
string rem2 = j;
m[J1.first][J1.second] = rem1;
m[J2.first][J2.second] = rem2;
replacement.push_back("Replace J1 with " + rem1 + " and J2 with " +
rem2 + ".");
if (check()) return true;
replacement.clear();
m[J1.first][J1.second] = rem2;
m[J2.first][J2.second] = rem1;
replacement.push_back("Replace J1 with " + rem2 + " and J2 with " +
rem1 + ".");
if (check()) return true;
}
}
return false;
}
replacement.push_back("There are no jokers.");
return check();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
for (auto rank : ranks) {
for (auto suit : suits) {
cards.insert(rank + suit);
}
}
cin >> r >> c;
for (int i = 0; i < int(r); i++) {
vector<string> vc(c);
for (int j = 0; j < int(c); j++) {
cin >> vc[j];
cards.erase(vc[j]);
if (vc[j] == "J1" || vc[j] == "J2") {
J++;
if (vc[j] == "J1")
J1 = {i, j};
else
J2 = {i, j};
}
}
m.push_back(vc);
}
if (ok()) {
cout << "Solution exists." << endl;
for (auto i : replacement) cout << i << endl;
vector<string> vc = {"first", "second"};
for (int i = 0; i < int(2); i++)
cout << "Put the " << vc[i] << " square to (" << positions[i].first
<< ", " << positions[i].second << ")." << endl;
} else
cout << "No solution." << endl;
cerr << "\nTime elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
}
| 2,200 | CPP |
t=int(input())
lst=list()
for i in range(t):
lst.append(input())
for j in lst:
x=int(j)//2
if int(j)%2:
print(x)
else:
print(x-1) | 800 | PYTHON3 |
#!/usr/bin/env python3
"""
CodeForces
466 A. Cheap Travel
@author yamaton
@date 2015-08-01
"""
def solve(n, m, a, b):
"""
n ... # of rides needed
m ... # of rides a special ticket provides
a ... cost of single ride
b ... cost of a special ticket
"""
# if there is no discount
if a <= b / m:
return a * n
else:
special_tickets = n // m
single_tickets = n % m
return min(a * single_tickets + b * special_tickets, b * (special_tickets + 1))
def main():
[n, m, a, b] = [int(i) for i in input().strip().split()]
result = solve(n, m, a, b)
print(result)
if __name__ == '__main__':
main()
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 202;
const int oo = 1e6;
int c[MAX_N];
vector<int> p[MAX_N];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> c[i], --c[i];
for (int i = 0; i < n; i++) {
int k;
cin >> k;
while (k--) {
int x;
cin >> x;
--x;
p[x].push_back(i);
}
}
int ans = oo;
for (int t = 0; t < 3; t++) {
int f[MAX_N] = {0}, res = -1;
queue<int> q[3];
for (int i = 0; i < n; i++)
for (int j = 0; j < p[i].size(); j++) f[p[i][j]]++;
for (int i = 0; i < n; i++)
if (!f[i]) q[c[i]].push(i), f[i] = oo;
for (int i = t; q[0].size() + q[1].size() + q[2].size(); ++res, ++i)
for (int j = i % 3; q[j].size(); q[j].pop()) {
int x = q[j].front();
for (int k = 0; k < p[x].size(); k++) --f[p[x][k]];
for (int k = 0; k < n; k++)
if (!f[k]) q[c[k]].push(k), f[k] = oo;
}
ans = min(ans, res + n);
}
cout << ans << endl;
return 0;
}
| 1,700 | CPP |
import math
t = int(input())
for _ in range(t):
a, b, c, d, k = map(int, input().split())
r1, r2 = int(math.ceil(a/c)), int(math.ceil(b/d))
if r1 + r2 > k: print(-1)
else: print(r1, r2) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > ans;
pair<int, int> d[100005];
int cnt[100005];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> d[i].first;
d[i].second = i;
}
sort(d + 1, d + n + 1);
if (d[1].first) return cout << -1, 0;
int cur = 1;
for (int i = 2; i <= n; i++) {
if (!d[i].first) return cout << -1, 0;
while (d[i].first - 1 > d[cur].first) cur++;
if (d[i].first - 1 != d[cur].first) return cout << -1, 0;
if (cnt[cur] == k) cur++;
if (d[i].first - 1 != d[cur].first) return cout << -1, 0;
cnt[cur]++;
cnt[i]++;
ans.push_back({d[cur].second, d[i].second});
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << endl;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) {
long long z = y;
while (x % y != 0) {
z = x % y;
x = y;
y = z;
}
return z;
}
struct Point {
long double x, y;
Point() {}
Point(long double x, long double y) : x(x), y(y) {}
long double abs() const { return hypot(x, y); }
Point operator+(const Point& o) const { return Point(x + o.x, y + o.y); }
Point operator-(const Point& o) const { return Point(x - o.x, y - o.y); }
void readin() { scanf("%Lf%Lf", &x, &y); }
} A, B, Q;
long double x, y, r;
long double cal(long double T) {
long double rx = (A.x + B.x) / 2 + (A.y - B.y) * T;
long double ry = (A.y + B.y) / 2 + (B.x - A.x) * T;
Point cen = Point(rx, ry);
return (cen - A).abs() - (cen - Q).abs();
}
long double gk(long double r) {
long double L = -1e12, R = 1e12;
int tmp = cal(L) > r;
for (int(cc) = 0; (cc) < (int)(100); (cc)++) {
long double mid = (L + R) / 2;
int zz = cal(mid) > r;
if (zz == tmp)
L = mid;
else
R = mid;
}
return L;
}
vector<pair<long double, int>> vp;
void fmain(int ID) {
A.readin();
B.readin();
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%Lf%Lf%Lf", &x, &y, &r);
Q = Point(x, y);
long double L = gk(r), R = gk(-r);
if (R < L) swap(L, R);
vp.push_back({L, 1});
vp.push_back({R, -1});
}
vp.push_back({0, 0});
sort(vp.begin(), vp.end());
long double ans = 1e12;
for (int i = 0, j = 0; i < vp.size(); i++) {
if (j == 0) ans = min(ans, fabs(vp[i].first));
j += vp[i].second;
if (j == 0) ans = min(ans, fabs(vp[i].first));
}
printf("%.10Lf\n", sqrt(0.25 + ans * ans) * (A - B).abs());
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 2,800 | CPP |
s = list(input())
t = list(input())
t.reverse()
flag = 0
if len(s)!=len(t):
print("NO")
else:
for i in range(len(s)):
if s[i]!=t[i]:
print("NO")
flag=0
break
else:
flag = 1
if flag==1:
print("YES") | 800 | PYTHON3 |
nn = int(input())
arr = [int(i) for i in input().split()]
s = 0
for i in range(nn):
if arr[i] >= 0:
arr[i] = -arr[i]-1
if abs(arr[i]) >= abs(arr[s]) and arr[i] != -1:
s = i
if nn%2:
arr[s] = -arr[s]-1
print(' '.join(map(str, arr)))
| 1,500 | PYTHON3 |
#!/usr/local/bin/python3
import sys, os
f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
sys.stdin = open('./input.txt', 'r')
def solve():
a,b,c = f()
mxlen = 2*c
com = min(a, b)
mxlen += 2*com
a -= com
b -= com
if a or b:
mxlen += 1
print(mxlen)
solve()
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> G[5010];
int col[5010];
int ss[5050];
int n, m, n1, n2, n3;
int nowp = 0;
int x, y;
bool is_bi(int u) {
ss[u] = nowp;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
ss[v] = nowp;
if (col[v] == col[u]) return false;
if (!col[v]) {
col[v] = 3 - col[u];
if (col[v] == 1)
x++;
else
y++;
if (!is_bi(v)) return false;
}
}
return true;
}
int w[10010], v[10010];
int dp[5050][5050];
int item[5010];
int main() {
cin >> n >> m >> n1 >> n2 >> n3;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (!col[i]) {
nowp++;
x = 1, y = 0;
col[i] = 1;
bool fg = is_bi(i);
if (!fg) {
puts("NO");
return 0;
}
w[nowp] = x;
v[nowp] = y;
}
}
dp[0][0] = 3;
for (int i = 0; i < nowp; i++) {
for (int j = 0; j <= n1 + n2 + n3; j++) {
if (dp[i][j] != 0) {
dp[i + 1][j + w[i + 1]] = 1;
dp[i + 1][j + v[i + 1]] = 2;
}
}
}
int now = n2;
if (dp[nowp][n2] == 0)
puts("NO");
else {
puts("YES");
for (int i = n; i; i--) {
if (dp[i][now] == 2) {
item[i] = 2;
now -= v[i];
} else {
item[i] = 1;
now -= w[i];
}
}
for (int i = 1; i <= n; i++) {
int noc = item[ss[i]];
if ((noc == 2 && col[i] == 1) || (noc == 1 && col[i] == 2)) {
if (n1)
n1--, putchar('1');
else
putchar('3');
} else
putchar('2');
}
puts("");
}
}
| 2,100 | CPP |
import pprint
n, r1, r2, r3, d = map(int, input().split())
*arr, = map(int, input().split())
dp = [[0, 0] for _ in range(n + 1)]
dp[0][0] = -d
dp[0][1] = 2 * n * r2 + 2 * n * d
for i in range(n):
fast_kill = arr[i] * r1 + r3
slow_kill = min((arr[i] + 2) * r1, r2 + r1)
# print(i, arr[i], fast_kill, slow_kill)
extra = -d if i == n - 1 else 0
dp[i + 1][0] = min(dp[i][0] + fast_kill, dp[i][1] + fast_kill + extra, dp[i][1] + slow_kill) + d
dp[i + 1][1] = dp[i][0] + slow_kill + 3 * d
# pprint.pprint(dp)
print(min(dp[i + 1]))
| 2,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<long> b, c, d, e;
map<long, long> fix;
long n, m, i, j, k, l, k1, a[100000], p, x;
int main() {
cin >> n >> k1;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a, a + n + 1);
b.push_back(0);
c.push_back(0);
d.push_back(0);
e.push_back(0);
for (i = 1; i <= n; i++) {
if (b.size() >= k1 + 1) break;
k = b.size();
for (j = 0; j < k; j++)
if (fix[b[j] + a[i]] != 1) {
fix[b[j] + a[i]] = 1;
b.push_back(b[j] + a[i]);
c.push_back(a[i]);
d.push_back(j);
e.push_back(e[j] + 1);
}
}
for (j = 1; j <= k1; j++) {
p = b[j];
x = j;
cout << e[j] << " ";
while (p > 0) {
cout << c[x] << " ";
p -= c[x];
x = d[x];
}
cout << endl;
}
}
| 1,600 | CPP |
n=input()
n=list(n)
s=input()
s=list(s)
c=0
k=0
temp=''
if len(n)!=len(s):
print("NO")
else:
for i in range(len(s)):
d=s[-1-i]
temp=temp+d
for i in range(len(n)):
if n[i]==temp[i]:
c=c+1
if c==len(n):
print("YES")
else:
print("NO") | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 601;
int n, m, a[N], b[N];
bool dp[N][N], calculated[N][N];
int trace[N][N], res[N];
int f(int l, int r) {
if (l > r || l < 1 || r > n) return 0;
if (calculated[l][r]) return dp[l][r];
calculated[l][r] = 1;
if (l == r) {
return (dp[l][r] = a[l] <= 1);
}
if (f(l + 1, r)) {
int d = (r - l + 1) * 2 - 1;
if (a[l] <= d && d <= b[l]) {
trace[l][r] = n + 1;
return (dp[l][r] = 1);
}
}
for (int k = l; k < r; ++k) {
if (f(l, k) && f(k + 1, r)) {
trace[l][r] = k;
return (dp[l][r] = 1);
}
}
return 0;
}
void find(int l, int r, int L, int R) {
if (l == r) {
res[L] = 1;
res[R] = -1;
return;
}
if (trace[l][r] == n + 1) {
res[L] = 1;
res[R] = -1;
find(l + 1, r, L + 1, R - 1);
return;
}
int k = trace[l][r];
find(l, k, L, L + 2 * (k - l + 1) - 1);
find(k + 1, r, L + 2 * (k - l + 1), R);
}
void testcase() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i] >> b[i];
}
if (!f(1, n)) {
cout << "IMPOSSIBLE";
return;
}
find(1, n, 1, 2 * n);
for (int i = 1; i <= 2 * n; ++i) cout << (res[i] == 1 ? '(' : ')');
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
int tcase = 1;
for (int i = 1; i <= tcase; ++i) testcase();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline bool checkBit(long long n, long long i) {
return n & ((long long)1 << i);
}
inline long long setBit(long long n, long long i) {
return n | ((long long)1 << i);
;
}
inline long long resetBit(long long n, long long i) {
return n & (~((long long)1 << i));
}
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) { a = (a + 1000000007) % 1000000007; }
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInv(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInv(b));
}
inline long long fact(long long r) {
long long ans = 1;
while (r) ans = modMul(ans, r), r--;
return ans;
}
inline long long invfact(long long r) {
long long ans = 1;
while (r) ans = modMul(ans, modInv(r)), r--;
return ans;
}
inline double dgcd(double a, double b) {
if (a < b) return dgcd(b, a);
if (b < .0001) return a;
return dgcd(b, fmod(a, b));
}
const long long N = 1e5 + 1;
long long ones, zeros, a[N], len[N];
vector<long long> ans;
string s;
void solve() {
cin >> s;
for (long long i = 0; i < (long long)((s).size()); i++) {
if (s[i] == '1') a[i] = 1;
}
for (long long i = 0; i < (long long)((s).size()); i++) {
if (!a[i])
zeros++;
else
ones = max(zeros, ones) + 1;
len[i] = max(ones, zeros);
}
stack<long long> sc;
ones = zeros = 0;
for (long long i = 0; i < (long long)((s).size()); i++) {
if (a[i]) {
if (i < (long long)((s).size()) - 1 && !a[i + 1])
ans.push_back(1), ones = max(ones + 1, zeros + 1);
else {
if (zeros + 1 > len[i])
ans[sc.top()] = 1, i--, zeros--, sc.pop();
else
ans.push_back(0), zeros++, sc.push(i);
}
} else if (zeros + 1 > len[i])
ans[sc.top()] = 1, zeros--, i--, sc.pop();
else
ans.push_back(0), zeros++;
}
for (auto it = (ans).begin(); it != (ans).end(); it++) cout << (*it);
cout << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) {
solve();
}
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<string> vec;
int opponents, days;
string str, item;
bool flag;
int winD = 0, ans = 0;
scanf("%d %d", &opponents, &days);
for (int x = 0; x < days; x++) {
cin >> str;
vec.push_back(str);
}
for (int y = 0; y < vec.size(); y++) {
item = vec[y];
flag = false;
for (int z = 0; z < item.size(); z++) {
if (item[z] == '0') {
flag = true;
break;
} else {
flag = false;
}
}
if (flag) {
winD++;
ans = max(ans, winD);
} else {
ans = max(ans, winD);
winD = 0;
}
}
printf("%d\n", ans);
return 0;
}
| 800 | CPP |
a=input()
b=list(a)
b=set(b)
b=list(b)
if(b.count(" ")==1):
b.remove(" ")
b.remove("{")
b.remove("}")
if(b.count(",")==1):
b.remove(",")
print(len(b)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000 * 1000 * 1000 + 7;
int main() {
int n;
cin >> n;
vector<pair<int, int>> dp(1 + n, {0, 0});
dp[0] = {1, 1};
for (int i = 1; i <= n; ++i) {
if (i % 2 == 0) {
dp[i].first = (dp[i - 1].first + dp[i - 1].second) % MOD;
dp[i].second = dp[i - 1].second;
} else {
dp[i].first = dp[i - 1].first;
dp[i].second = (dp[i - 1].first + dp[i - 1].second) % MOD;
}
}
cout << (1LL * dp[n].first + dp[n].second + MOD - 2) % MOD << endl;
return 0;
}
| 1,600 | CPP |
s = ''.join(sorted(input()))[::-1]
print(''.join(i for i in s if i == s[0])) | 800 | PYTHON3 |
t=int(input())
for _ in range(t):
n = int(input())
if(n%2==1 or (n//2)%2==1):
print('NO')
continue
else:
o = [1]
e = [2]
for i in range(2,n//2+1):
if(i%2==1):
o.append(o[-1]+2)
e.append(e[-1]+4)
else:
o.append(o[-1]+4)
e.append(e[-1]+2)
print('YES')
print(*e,end=' ')
print(*o) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
bool is_prime(long long n) {
if (n == 1 || n == 0) return false;
if (n == 2 || n == 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 1; (6 * i + 1) <= n; i++) {
if (6 * i + 1 == n) return true;
if (6 * i - 1 == n) return true;
}
return false;
}
unordered_set<long long> prime_till_n(long long n) {
vector<long long> arr(n + 1);
arr[0] = 0;
arr[1] = 0;
for (long long i = 2; i <= n; i++) arr[i] = (long long)1;
for (long long i = 2; i <= (n - 1) / 2; i++) {
if (arr[i] == 1) {
long long j = i;
while (i + j <= n) {
if (arr[i + j] == 1) {
arr[i + j] = 0;
}
j += i;
}
}
}
unordered_set<long long> ans;
for (long long i = 0; i <= n; i++) {
if (arr[i] == 1) ans.insert(i);
}
return ans;
}
bool is_palindrome(string s) {
string r = s;
reverse(r.begin(), r.end());
if (s.compare(r) == 0) return true;
return false;
}
bool issubstr(string s1, string s2) {
int M = s1.length();
int N = s2.length();
for (int i = 0; i <= N - M; i++) {
int j;
for (j = 0; j < M; j++)
if (s2[i + j] != s1[j]) break;
if (j == M) return true;
}
return false;
}
long long xortilln(long long n) {
if (n % 4 == 0ll) return n;
if (n % 4 == 1ll) return 1ll;
if (n % 4 == 2ll) return n + 1ll;
return 0ll;
}
void solve() {
string s;
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
cin >> s;
vector<long long> up, down;
for (long long i = 0; i < n; i++) {
if (s[i] == '1')
up.push_back(v[i]);
else
down.push_back(v[i]);
}
sort(up.begin(), up.end());
sort(down.begin(), down.end());
unordered_map<long long, long long> up2, down2;
for (int i = 0; i < down.size(); i++) down2[down[i]] = i + 1;
for (int i = 0; i < up.size(); i++) up2[up[i]] = down.size() + i + 1;
for (int i = 0; i < n; i++) {
if (s[i] == '1')
cout << up2[v[i]] << " ";
else
cout << down2[v[i]] << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long i = 1, t = 1;
cin >> t;
while (t--) {
solve();
i++;
}
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200005];
double check(double mid) {
double ans = 0.0;
double x = 0.0, y = 0.0;
double hamada = 0.0;
for (int i = 0; i < n; i++) {
hamada += a[i] - mid;
ans = max(ans, max(fabs(hamada - x), fabs(hamada - y)));
x = max(x, hamada);
y = min(y, hamada);
}
return ans;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
double lo = -10000.0, hi = 10000.0;
int x = 0;
while (x++ < 500) {
double mid1 = (lo + lo + hi) / 3.0, mid2 = (hi + hi + lo) / 3.0;
if (check(mid1) > check(mid2)) {
lo = mid1;
} else
hi = mid2;
}
printf("%.12lf", check((lo + hi) / 2.0));
return 0;
}
| 2,000 | CPP |
import math
def main():
n, r = input().split()
n = int(n)
r = int(r)
print(-(r/(1-1/math.sin(math.pi/n))))
if __name__ == "__main__":
main() | 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n % 3 == 0) {
cout << 1 << " " << 1 << " " << n - 2 << endl;
} else if (n % 3 == 1) {
cout << 1 << " " << 1 << " " << n - 2 << endl;
} else if (n % 3 == 2) {
cout << 1 << " " << 2 << " " << n - 3 << endl;
}
return 0;
}
| 800 | CPP |
#Vasya the Hipstar
a,b = map(int,input().split())
st = ''
if a>b:
st+=str(b)+' '
st+=str((a-b)//2)
else:
st+=str(a)+' '
st+=str((b-a)//2)
print(st)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
char mas[110][110][110];
int main() {
int n, m, k, i, j, q;
int ans = 0;
char ch;
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= n; i++) {
scanf("\n");
for (j = 1; j <= m; j++) {
for (q = 1; q <= k; q++) scanf("%c", &mas[i][j][q]);
if (j != m) scanf("\n");
}
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
for (q = 1; q <= k; q++) {
if (mas[i][j][q] == '0')
ans += 0;
else if (i == 1 && j == 1 && q == 1)
ans += 0;
else if (i == n && j == m && q == k)
ans += 0;
else {
if (mas[i][j][q - 1] == '1' && mas[i][j][q + 1] == '1')
ans++;
else if (mas[i][j - 1][q] == '1' && mas[i][j + 1][q] == '1')
ans++;
else if (mas[i - 1][j][q] == '1' && mas[i + 1][j][q] == '1')
ans++;
else if (mas[i][j][q - 1] == '1' && mas[i][j + 1][q] == '1' &&
mas[i][j + 1][q - 1] == '0')
ans++;
else if (mas[i][j - 1][q] == '1' && mas[i][j][q + 1] == '1' &&
mas[i][j - 1][q + 1] == '0')
ans++;
else if (mas[i][j - 1][q] == '1' && mas[i + 1][j][q] == '1' &&
mas[i + 1][j - 1][q] == '0')
ans++;
else if (mas[i][j + 1][q] == '1' && mas[i - 1][j][q] == '1' &&
mas[i - 1][j + 1][q] == '0')
ans++;
else if (mas[i][j][q - 1] == '1' && mas[i + 1][j][q] == '1' &&
mas[i + 1][j][q - 1] == '0')
ans++;
else if (mas[i][j][q + 1] == '1' && mas[i - 1][j][q] == '1' &&
mas[i - 1][j][q + 1] == '0')
ans++;
}
}
printf("%d\n", ans);
return 0;
}
| 1,800 | CPP |
import sys
import math
#import random
#sys.setrecursionlimit(int(1e6))
input = sys.stdin.readline
############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
def inp():
return(int(input()))
def inara():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
################################################################
############ ---- THE ACTUAL CODE STARTS BELOW ---- ############
k,n,w=invr()
lagbe=0
for i in range(0,w):
lagbe+=(i+1)*k
ans=max(0,lagbe-n)
print(ans)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll n;
map<ll, string> m;
set<ll> s[10];
int len(ll x) {
if (x == 0) {
return 1;
}
int res = 0;
while (x) {
res++;
x /= 10;
}
return res;
}
string get(ll x) {
if (m.count(x)) {
return m[x];
}
return to_string(x);
}
void relax(ll x, string expr) {
if (x > n || len(x) <= expr.size()) {
return;
}
if (m.count(x) && m[x].size() <= expr.size()) {
return;
}
s[m[x].size()].erase(x);
m[x] = expr;
s[expr.size()].emplace(x);
}
void generatePowers() {
for (ll a = 2; a * a <= n; ++a) {
ll x = a * a;
ll b = 2;
while (x <= n) {
relax(x, to_string(a) + "^" + to_string(b));
x *= a;
b++;
}
}
}
void generatePowerAndPower() {
for (int i = 1; i <= 4; ++i) {
for (int j = 1; i + j + 1 <= 7; ++j) {
for (ll x : s[i]) {
for (ll y : s[j]) {
relax(x * y, get(x) + "*" + get(y));
}
}
}
}
}
void generatePowerMul() {
for (int i = 1; i <= 5; ++i) {
const ll pow10 = pow(10, 6 - i);
for (int j = 1; j < pow10; ++j) {
for (ll x : s[i]) {
relax(x * j, to_string(j) + "*" + get(x));
}
}
}
}
void init() {
generatePowers();
generatePowerAndPower();
generatePowerMul();
}
string ans;
void relaxAns(const string& s) {
if (ans.size() > s.size()) {
ans = s;
}
}
void finalRelax() {
for (int i = 1; 2 * i + 1 < ans.size(); ++i) {
for (ll x : s[i]) {
relaxAns(get(n - x) + "+" + get(x));
if (n % x == 0) {
relaxAns(get(n / x) + "*" + get(x));
}
}
ll pow10 = pow(10, i);
for (int j = 1; j < pow10; ++j) {
relaxAns(get(n - j) + "+" + get(j));
if (n % j == 0) {
relaxAns(get(n / j) + "*" + get(j));
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
if (n == 1e10) {
cout << "10^10\n";
return 0;
}
init();
ans = get(n);
finalRelax();
cout << ans << '\n';
return 0;
}
| 2,700 | CPP |
t=int(input())
while t>0 :
n=int(input())
l=list(map(int,input().split()))
l.sort()
a=1001
for i in range(1,n) :
if l[i]-l[i-1]<a :
a=l[i]-l[i-1]
print(a)
t-=1 | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int dp[2][1 << 17], mat[5], w[5], n;
bool s[1010][5];
char ch[1010];
int main() {
scanf("%d", &n);
for (int i = 1; i <= 4; i++) scanf("%d", &w[i]);
for (int i = 1; i <= 4; i++) {
scanf("%s", ch);
for (int j = 0; j < n; j++) s[j + 1][i] = ch[j] == '.';
}
int s0 = 0;
mat[1] = 1;
mat[2] = 51;
mat[3] = 1911;
mat[4] = 65535;
memset(dp, 0x3f3f3f3f, sizeof(dp));
for (int i = 1; i <= 4; i++)
for (int j = 1; j <= 4; j++)
if (s[j][i]) s0 |= 1 << ((j - 1) * 4 + i - 1);
int cur = 1, pre = 0;
dp[pre][s0] = 0;
w[0] = 0;
for (int i = 0; i < n; i++) {
int nxt = 0;
memset(dp[cur], 0x3f3f3f3f, sizeof(dp[cur]));
for (int j = 1; j <= 4; j++)
if (s[i + 5][j]) nxt |= 1 << j - 1;
for (int st = 0; st < (1 << 16); st++) {
if (dp[pre][st] == 0x3f3f3f3f) continue;
for (int a = 0; a <= 4; a++)
for (int b = 0; b <= 3; b++)
for (int c = 0; c <= 2; c++)
for (int d = 0; d <= 1; d++) {
int cost = w[a] + w[b] + w[c] + w[d];
int add = mat[a] << (4 - a) | mat[b] << (3 - b) |
mat[c] << (2 - c) | mat[d] << (1 - d);
if (((st | add) & 15) == 15) {
int nxt_st = (st >> 4) | (add >> 4) | (nxt << 12);
dp[cur][nxt_st] = min(dp[cur][nxt_st], dp[pre][st] + cost);
}
}
}
swap(cur, pre);
}
printf("%d\n", dp[pre][0]);
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
int n, k, tot;
long long ans;
int p[1000010], phi[1000010];
bool tag[1000010];
void init() {
phi[1] = 1;
for (int i = 2; i <= n; ++i) {
if (!tag[i]) phi[p[++tot] = i] = i - 1;
for (int j = 1; j <= tot; ++j) {
int k = i * p[j];
if (k > n) break;
tag[k] = true;
if (i % p[j])
phi[k] = phi[i] * (p[j] - 1);
else {
phi[k] = phi[i] * p[j];
break;
}
}
}
}
int main() {
read(n), read(k), init(), tot = 0;
if (k == 1) {
puts("3");
return 0;
}
for (int i = 3; i <= n; ++i) p[++tot] = phi[i];
sort(p + 1, p + tot + 1);
for (int i = 1; i <= k; ++i) ans += p[i];
printf("%lld", ans + 2);
return 0;
}
| 2,800 | CPP |
a,b=map(int,input().split())
for i in range(b):
if a%2==0:
a//=2
if a%5==0:
a//=5
b=10**b
print(a*b)
| 1,100 | PYTHON3 |
n,k=map(int,input().split())
r=list(map(int,input().split()))
h=[0]*n
for _ in range(k):
a,b=map(int,input().split())
if r[a-1]<r[b-1]:h[b-1]+=1
if r[b-1]<r[a-1]:h[a-1]+=1
x=[[r[i],i] for i in range(n)]
x.sort()
o=['0']*n
u=0
for i in range(1, n):
if x[i][0]!=x[i-1][0]:
u=i
o[x[i][1]]=str(max(0,u-h[x[i][1]]))
print(' '.join(o)) | 1,500 | PYTHON3 |
n=int(input())
i=0
sum=0
while i<n//2:
i+=1
if (n-i)%i==0:
sum+=1
print(sum) | 800 | PYTHON3 |
t=int(input())
for q in range(t):
n,a,b,c,d = map(int,input().split())
i=n*(a-b)
j=n*(a+b)
if(j < (c-d) or i >(c+d) ):print("No")
else:print("Yes") | 900 | PYTHON3 |
a=sorted(list(map(int,input().split('+'))))
for i in range(len(a)):
if i==len(a)-1: print(a[i])
else: print(a[i],end='+') | 800 | PYTHON3 |
n = int(input())
a = [int(x) for x in input().split()]
set1 = sorted(list(set(a)))
max1 = set1[-1]
num = [0]*(max1+1)
for i in a:
num[i] += 1
f = [0]*(max1+1)
f[1] = num[1]
j = 1
for i in set1:
if i >= 2:
if i > j+1:
f[j:i] = [f[j]]*(i-j)
f[i] = max(f[i-1], f[i-2]+i*num[i])
j = i
print(f[max1])
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int root = 15311432;
const int root_1 = 469870224;
const int root_pw = 1 << 23;
const int sz = 32768;
template <class T>
T eea(T a, T b, T& x, T& y) {
if (!b) {
x = 1;
y = 0;
return a;
}
T x1, y1;
T g = eea(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return g;
}
int inverse(int n) {
int x, y;
eea(n, mod, x, y);
x %= mod;
if (x < 0) x += mod;
return x;
}
int ad(int x, int y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
int sb(int x, int y) {
x -= y;
if (x < 0) x += mod;
return x;
}
void fft(vector<int>& a, bool invert) {
int n = a.size();
for (int i = 1, j = 0; i < n; i++) {
int bit = n >> 1;
for (; j & bit; bit >>= 1) j ^= bit;
j ^= bit;
if (i < j) swap(a[i], a[j]);
}
for (int len = 2; len <= n; len <<= 1) {
int wlen = invert ? root_1 : root;
for (int i = len; i < root_pw; i <<= 1) wlen = 1LL * wlen * wlen % mod;
for (int i = 0; i < n; i += len) {
int w = 1;
for (int j = 0; j < len / 2; j++) {
int u = a[i + j], v = a[i + j + len / 2] * 1ll * w % mod;
a[i + j] = ad(u, v);
a[i + j + len / 2] = sb(u, v);
w = w * 1ll * wlen % mod;
}
}
}
if (invert) {
int n_1 = inverse(n);
for (int& x : a) x = x * 1ll * n_1 % mod;
}
}
int n, K, k, w;
int l[55], r[55], u[55], q[55], d[55];
int a[20005];
vector<int> dp(vector<int> a) {
vector<int> d(sz);
d[0] = 1;
int k = 0;
for (int x : a) {
vector<int> tmp(sz);
k++;
for (int i = 0; i <= k + 1; i++) {
tmp[i] = ad(tmp[i], d[i]);
if (i > 0) tmp[i] = ad(tmp[i], d[i - 1] * 1ll * x % mod);
}
swap(d, tmp);
}
return d;
}
vector<int> blok[55];
vector<int> spoji(vector<int> a, vector<int> b) {
fft(a, false);
fft(b, false);
for (int i = 0; i < sz; i++) a[i] = a[i] * 1ll * b[i] % mod;
fft(a, true);
return a;
}
int f[20005], finv[20005];
int bk(int n, int k) {
if (n < 0 || k < 0 || n - k < 0) return 0;
return f[n] * 1ll * finv[n - k] % mod * finv[k] % mod;
}
vector<int> igd_slow(vector<int> d, int n, int q) {
vector<int> r(sz);
for (int k = 0; k < sz; k++) {
int qi = 1;
for (int i = k; i >= 0; i--) {
r[k] = ad(r[k], bk(n - i, k - i) * 1ll * qi % mod * d[i] % mod);
qi = qi * 1ll * q % mod;
}
}
return r;
}
vector<int> igd_fast(vector<int> d, int n, int q) {
vector<int> alfa(sz), beta(sz);
int qi = 1;
for (int i = 0; i <= n; i++) {
alfa[i] = d[i] * 1ll * f[n - i] % mod;
beta[i] = qi * 1ll * finv[i] % mod;
qi = qi * 1ll * q % mod;
}
auto r = spoji(alfa, beta);
for (int i = 0; i < sz; i++)
r[i] = i <= n ? r[i] * 1ll * finv[n - i] % mod : 0;
return r;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
f[0] = finv[0] = 1;
for (int i = 1; i < 20005; i++) {
f[i] = f[i - 1] * 1ll * i % mod;
finv[i] = inverse(f[i]);
}
cin >> n >> K;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] = ad(a[i], 0);
}
cin >> w;
for (int i = 0; i < w; i++) {
int t;
cin >> t;
if (t == 2) {
cin >> q[i] >> l[i] >> r[i] >> d[i];
d[i] = ad(d[i], 0);
q[i] = ad(q[i], 0);
} else {
int dd;
cin >> q[i] >> l[i] >> dd;
dd = ad(dd, 0);
q[i] = ad(q[i], 0);
r[i] = l[i];
d[i] = sb(dd, a[l[i] - 1]);
}
l[i]--;
}
k = copy(l, l + w, u) - u;
k = copy(r, r + w, u + k) - u;
u[k++] = 0;
u[k++] = n;
sort(u, u + k);
k = unique(u, u + k) - u;
k--;
for (int i = 0; i < k; i++) {
blok[i] = dp(vector<int>(a + u[i], a + u[i + 1]));
}
for (int i = 0; i < w; i++) {
vector<int> sol(sz);
sol[0] = 1;
int fr = lower_bound(u, u + k, l[i]) - u;
int to = lower_bound(u, u + k, r[i]) - u;
for (int j = 0; j < k; j++) {
sol = spoji(sol, igd_fast(blok[j], u[j + 1] - u[j],
sb((fr <= j && j < to) * d[i], q[i])));
}
int t = sol[K];
if (K & 1) t = sb(0, t);
cout << t << '\n';
}
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long res = 1;
a = a % 1000000007;
while (b > 0) {
if (b & 1) {
res = (res * a) % 1000000007;
b--;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
long long fermat_inv(long long y) { return power(y, 1000000007 - 2ll); }
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
int calc(string s) {
int val = 0;
for (int i = 0; i < s.length(); i++) {
val *= 27;
if (s[i] == '_')
val += 26;
else
val += s[i] - 'a';
}
return val;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
int n, k;
cin >> n >> k;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int ans = 0;
int j = 0;
long long sum = 0;
long long ans1 = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
while ((i - j + 1) * a[i] - sum > k) {
sum -= a[j];
j++;
}
if (i - j + 1 > ans) {
ans = i - j + 1;
ans1 = a[i];
}
}
cout << ans << " " << ans1;
}
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, res = 0, z, w;
cin >> x >> y;
z = max(x, y);
w = min(x, y);
res = ceil((z - w) / 3.0);
w += res;
z -= 2 * res;
if (w - z == 2)
res += 2 * z;
else
res += (w - 2) * 2 + 1;
if (res < 0)
cout << 0;
else
cout << res;
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n;
map<int, vector<vector<int> > > m;
vector<int> v, ans;
map<int, int> s;
for (int i = 0; i < n - 2; i++) {
int f, g, h;
cin >> f >> g >> h;
v.push_back(f);
v.push_back(g);
v.push_back(h);
s[f]++;
s[g]++;
s[h]++;
m[f].push_back(v);
m[g].push_back(v);
m[h].push_back(v);
v.clear();
}
for (auto i = s.begin(); i != s.end(); i++) {
if (i->second == 1) {
ans.push_back(i->first);
for (auto p = m[i->first].begin(); p != m[i->first].end(); p++) {
auto j = *p;
for (int u = 0; u < 3; u++) {
if (s[j[u]] == 2) a = j[u];
if (s[j[u]] == 3) b = j[u];
}
}
ans.push_back(a);
ans.push_back(b);
break;
}
}
while (ans.size() < n) {
int x, y, z, t;
t = ans.size();
x = ans[t - 1];
y = ans[t - 2];
z = ans[t - 3];
for (auto p = m[y].begin(); p != m[y].end(); p++) {
auto j = *p;
if (((j[0] == y && j[1] == x) || (j[0] == x && j[1] == y)) && j[2] != z)
ans.push_back(j[2]);
else if (((j[0] == y && j[2] == x) || (j[0] == x && j[2] == y)) &&
j[1] != z)
ans.push_back(j[1]);
else if (((j[1] == y && j[2] == x) || (j[1] == x && j[2] == y)) &&
j[0] != z)
ans.push_back(j[0]);
}
}
for (auto c : ans) {
cout << c << " ";
}
return 0;
}
| 1,600 | CPP |
n , m = map(int, input().split())
prefix = [0] * 102
ans = [0] * 102
cnt = 0
for i in range(1, n + 1):
l , r = map(int , input().split())
prefix[l] += 1
prefix[r+1] -= 1
for i in range(2, m + 1):
prefix[i] += prefix[i-1]
for i in range(1, m + 1):
if (prefix[i] == 0):
ans[cnt] = i
cnt += 1
print(cnt)
if ( cnt == 0):
print("")
else:
for i in range(0, cnt):
print(ans[i], end =" ") | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long read(int x = 0) {
int c, f = 1;
for (c = getchar(); !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - 48;
return f * x;
}
long long N, K, a, b, mn, mx, i, to, L, t;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
int main() {
mn = (1ll << 60), mx = -(1ll << 60);
N = read(), K = read();
a = read(), b = read();
for (i = 0; i < N; i++) {
to = i * K - b;
if (to < 0) to = (to + N * K) % (N * K);
L = to - a;
if (L < 0) L += N * K;
t = (N * K) / gcd(N * K, L);
mn = min(mn, t);
mx = max(mx, t);
to = i * K + b;
if (to >= N * K) to -= N * K;
L = to - a;
if (L < 0) L += N * K;
t = (N * K) / gcd(N * K, L);
mn = min(mn, t);
mx = max(mx, t);
}
cout << mn << ' ' << mx;
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 3;
int n, q, a[MAXN], f[MAXN];
struct node {
int l, r, num;
} tre[MAXN << 2];
inline void build(int i, int l, int r) {
tre[i].l = l, tre[i].r = r, tre[i].num = 0;
if (l == r) return;
int mid = (l + r) >> 1;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
}
inline int query(int i, int s) {
if (tre[i].l == tre[i].r) {
return tre[i].l - 1;
}
if (s > tre[i << 1].num) {
s -= tre[i << 1].num;
return query(i << 1 | 1, s);
} else
return query(i << 1, s);
}
inline void modify(int i, int l, int r) {
if (tre[i].l > r || tre[i].r < l) return;
if (tre[i].l == l && tre[i].r == r) {
tre[i].num++;
return;
}
modify(i << 1, l, r);
modify(i << 1 | 1, l, r);
tre[i].num = tre[i << 1].num + tre[i << 1 | 1].num;
}
struct edge {
int xs, xe, y, num;
int t;
friend bool operator<(edge a, edge b) {
if (a.y != b.y) return a.y < b.y;
return a.t < b.t;
}
} s[MAXN << 1];
int ncnt, ans[MAXN], sum[MAXN];
int lowbit(int x) { return x & -x; }
void change(int x, int delta) {
for (; x <= n; x += lowbit(x)) sum[x] += delta;
}
int query1(int l, int r) {
int tot = 0;
l--;
for (; r; r -= lowbit(r)) tot += sum[r];
for (; l; l -= lowbit(l)) tot -= sum[l];
return tot;
}
int main() {
scanf("%d%d", &n, &q);
build(1, 0, n + 1);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == i) f[i] = i - 1;
if (a[i] > i) f[i] = -1;
if (a[i] < i) f[i] = query(1, tre[1].num - i + a[i] + 1);
modify(1, f[i] + 1, f[i] + 1);
}
for (int i = 1; i <= n; i += 1) {
s[++ncnt].t = 1, s[ncnt].xs = s[ncnt].xe = i, s[ncnt].y = f[i];
}
for (int i = 1; i <= q; i++) {
int x, y;
scanf("%d%d", &x, &y);
y = n - y;
x++;
s[++ncnt].t = 2;
s[ncnt].xs = x, s[ncnt].xe = y, s[ncnt].y = n + 3, s[ncnt].num = i;
s[++ncnt].t = 0;
s[ncnt].xs = x, s[ncnt].xe = y, s[ncnt].y = x - 1, s[ncnt].num = i;
}
sort(s + 1, s + ncnt + 1);
for (int i = 1; i <= ncnt; i++) {
if (s[i].t == 1) {
if (s[i].y == -1) continue;
change(s[i].xe, 1);
} else if (s[i].t == 2) {
int tot = query1(s[i].xs, s[i].xe);
ans[s[i].num] = tot - ans[s[i].num];
} else {
int tot = query1(s[i].xs, s[i].xe);
ans[s[i].num] = tot;
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
| 2,300 | CPP |
A,B = [int(p) for p in input().split()]
x,y,z = [int(p) for p in input().split()]
m = 2*x + y
n = 3*z + y
yellow = m-A
blue = n-B
if (yellow >=0 and blue >=0):
print (yellow+blue)
elif(yellow < 0 and blue>0):
print (blue)
elif(yellow > 0 and blue<0):
print (yellow)
else:
print (0) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void cmin(T &a, T b) {
((a > b) && (a = b));
}
template <class T>
inline void cmax(T &a, T b) {
((a < b) && (a = b));
}
char IO;
int rd() {
int s = 0, f = 0;
while (!isdigit(IO = getchar()))
if (IO == '-') f = 1;
do s = (s << 1) + (s << 3) + (IO ^ '0');
while (isdigit(IO = getchar()));
return f ? -s : s;
}
const int N = 2e5 + 10, INF = 1e9 + 10;
int n, m, q, tn, bit;
vector<int> G[N], E[N];
int val[N], low[N], t[N], dfn, stk[N], stktop;
multiset<int> st[N];
void pre_dfs(int u, int f) {
low[u] = t[u] = ++dfn;
stk[++stktop] = u;
for (auto v : G[u]) {
if (v == f) continue;
if (!t[v]) {
pre_dfs(v, u);
if (low[v] >= t[u]) {
for (int t = ++n; t != v;) E[n].push_back(t = stk[stktop--]);
E[u].push_back(n);
} else
cmin(low[u], low[v]);
} else
cmin(low[u], t[v]);
}
}
int dep[N], top[N], fa[N], sz[N], son[N], L[N], R[N], id[N], mi[N];
void dfs1(int u, int f) {
if (u <= tn) st[f].insert(val[u]);
fa[u] = f, sz[u] = 1;
for (auto v : E[u]) {
dep[v] = dep[u] + 1;
dfs1(v, u);
sz[u] += sz[v];
if (sz[v] > sz[son[u]]) son[u] = v;
}
mi[u] = st[u].size() ? *st[u].begin() : val[u];
}
void dfs2(int u, int t) {
id[L[u] = ++dfn] = u, top[u] = t;
if (son[u]) dfs2(son[u], t);
for (auto v : E[u]) {
if (v == son[u]) continue;
dfs2(v, v);
}
R[u] = dfn;
}
int s[N << 2];
void Build() {
bit = 1;
while (bit <= n + 1) bit <<= 1;
memset(s, 127, sizeof s);
for (int i = 1, iend = n; i <= iend; ++i) s[i + bit] = mi[id[i]];
for (int i = bit, iend = 1; i >= iend; --i)
s[i] = min(s[i << 1], s[i << 1 | 1]);
}
void Upd(int p, int x) {
s[p += bit] = x;
while (p > 1) p >>= 1, s[p] = min(s[p << 1], s[p << 1 | 1]);
}
int Que(int l, int r) {
if (l == r) return s[l + bit];
int res = INF;
for (l += bit - 1, r += bit + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
((~l & 1) && res > s[l ^ 1] && (res = s[l ^ 1]));
((r & 1) && res > s[r ^ 1] && (res = s[r ^ 1]));
}
return res;
}
void Set(int u, int x) {
Upd(L[u], x);
if (!fa[u]) return (void)(val[u] = x);
st[fa[u]].erase(st[fa[u]].find(val[u]));
st[fa[u]].insert(val[u] = x);
Upd(L[fa[u]], mi[fa[u]] = *st[fa[u]].begin());
}
int Quepath(int x, int y) {
if (x == y) return val[x];
int res = INF;
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
cmin(res, Que(L[top[x]], L[x]));
x = fa[top[x]];
}
if (L[x] > L[y]) swap(x, y);
cmin(res, Que(L[x], L[y]));
if (x > tn) cmin(res, val[fa[x]]);
return res;
}
char opt[2];
int main() {
tn = n = rd(), m = rd(), q = rd();
for (int i = 1, iend = n; i <= iend; ++i) val[i] = rd();
for (int i = 1, iend = m; i <= iend; ++i) {
int u = rd(), v = rd();
G[u].push_back(v), G[v].push_back(u);
}
pre_dfs(1, 0), dfn = 0;
dfs1(1, 0), dfs2(1, 1);
Build();
for (int i = 1, iend = q; i <= iend; ++i) {
scanf("%s", opt);
if (opt[0] == 'C') {
int x = rd(), w = rd();
Set(x, w);
} else
printf("%d\n", Quepath(rd(), rd()));
}
}
| 3,200 | CPP |
#include <bits/stdc++.h>
const long long N = 305;
const long long MOD = 1e9 + 7;
using namespace std;
long long n, size[N], tot = 0;
long long jie[N], f[N][N], a[N], p[N], ts[N], c[N][N];
long long chk(long long x) {
long long m = sqrt(x);
if (m * m == x) return 1;
return 0;
}
long long cmp(long long x, long long y) { return x > y; }
void pre() {
for (long long i = 0; i <= n; i++) c[i][i] = c[i][0] = 1, c[i][1] = i;
for (long long i = 3; i <= n; i++) {
for (long long j = 2; j <= i - 1; j++) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % MOD;
}
}
jie[1] = 1;
for (long long i = 2; i <= n; i++) jie[i] = jie[i - 1] * i % MOD;
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (long long i = 1; i <= n; i++) {
long long flag = 0;
for (long long grp = 1; grp <= tot; grp++)
if (chk(p[grp] * a[i])) {
size[grp]++;
flag = 1;
break;
}
if (flag == 0) {
tot++;
p[tot] = a[i];
size[tot] = 1;
}
}
sort(size + 1, size + tot + 1, cmp);
pre();
ts[0] = 0;
for (long long i = 1; i <= tot; i++) ts[i] = ts[i - 1] + size[i];
f[0][0] = 1;
long long m = 0;
for (long long i = 1; i <= tot; i++) {
for (long long j = 0; j <= m + 1; j++) {
if (f[i - 1][j] == 0) continue;
for (long long k = 0; k < size[i]; k++) {
long long temp = f[i - 1][j] * c[size[i] - 1][k];
temp %= MOD;
for (long long p = 0; p <= k + 1; p++) {
long long temp1 = temp * c[j][p];
temp1 %= MOD;
f[i][j + size[i] - 1 - k - p] +=
(temp1 * c[m + 1 - j][k + 1 - p]) % MOD;
f[i][j + size[i] - 1 - k - p] %= MOD;
}
}
}
m += size[i];
}
for (long long i = 1; i <= tot; i++)
f[tot][0] = (f[tot][0] * jie[size[i]]) % MOD;
printf("%lld", f[tot][0]);
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
using ll = long long;
using ld = long double;
const int MAXMEM = 200 * 1000 * 1024;
char _memory[MAXMEM];
size_t _ptr = 0;
void *operator new(size_t _x) {
_ptr += _x;
return _memory + _ptr - _x;
}
void operator delete(void *) noexcept {}
const string FILENAME = "input";
const int MAXN = 100228;
const int BLOCK = 35;
const int BLOCK1 = 1000;
int n, w, q;
int x[MAXN];
int ans[MAXN];
int mx[18][MAXN];
int mx1[18][MAXN];
int gr[MAXN];
inline int getmax(const int l, const int r) {
int grs = 31 - __builtin_clz(r - l + 1);
return max(mx1[grs][l], mx1[grs][r - (1 << grs) + 1]);
}
inline int getmin(const int l, const int r) {
int grs = 31 - __builtin_clz(r - l + 1);
return min(mx[grs][l], mx[grs][r - (1 << grs) + 1]);
}
inline bool check(const int l, const int r, int k) {
if (l > r || r >= n) {
return false;
}
int f = getmin(l, r);
int f1 = getmax(l, r);
return f + w - f1 >= k;
}
inline int findGroupEnd(const int i, const int k) {
int l = i;
int r = n - 1;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (check(i, mid, k)) {
l = mid;
} else {
r = mid - 1;
}
}
return l + 1;
}
int curs[MAXN];
int jump[MAXN];
int target[MAXN];
int val;
void calc(int i) {
if (curs[i] - i == BLOCK) {
jump[i] = 0;
target[i] = i;
} else {
if (curs[i] >= n) {
jump[i] = 1;
target[i] = curs[i];
} else {
if (target[curs[i]] >= i + BLOCK) {
int t = curs[i];
int cnt = 1;
int val = i + BLOCK;
while (curs[t] < val) {
cnt++;
t = curs[t];
}
target[i] = curs[t];
jump[i] = cnt + 1;
} else {
jump[i] = 1 + jump[curs[i]];
target[i] = target[curs[i]];
}
}
}
}
void calc1(int i) {
if (curs[i] - i == BLOCK) {
jump[i] = 0;
target[i] = i;
} else {
if (curs[i] >= n) {
jump[i] = 1;
target[i] = curs[i];
}
}
}
int gt[MAXN];
int ls[MAXN];
int ft[MAXN];
int ukr;
int nxt[MAXN];
bool used[MAXN];
int st[MAXN];
int uks;
int grs;
int stacker[MAXN];
int ukt = 0;
int curuk[MAXN];
int curval[MAXN];
void dfs(int start) {
ukt = 0;
stacker[ukt] = start;
curuk[start] = gt[start];
ukt++;
uks = 0;
curval[start] = 0;
while (ukt) {
int u = stacker[ukt - 1];
if (curuk[u] == gt[u]) {
used[u] = true;
if (u <= grs) {
if (target[curs[u]] >= u + BLOCK) {
while (curval[u] < uks && st[curval[u]] >= u + BLOCK) {
curval[u]++;
}
int l = curval[u];
jump[u] = uks - l;
if (curs[st[l]] - st[l] == BLOCK) {
target[u] = st[l];
} else {
jump[u]++;
target[u] = curs[st[l]];
}
} else {
jump[u] = 1 + jump[curs[u]];
target[u] = target[curs[u]];
}
}
st[uks] = u;
uks++;
}
if (curuk[u] == -1) {
uks--;
ukt--;
continue;
}
int h = ft[curuk[u]];
curuk[u] = nxt[curuk[u]];
if (!used[h]) {
stacker[ukt] = h;
curval[h] = curval[u];
curuk[h] = gt[h];
ukt++;
}
}
}
void add(int a, int b) {
if (gt[a] == -1) {
gt[a] = ukr;
ls[a] = ukr;
ft[ukr] = b;
nxt[ukr] = -1;
ukr++;
} else {
nxt[ls[a]] = ukr;
ft[ukr] = b;
nxt[ukr] = -1;
ls[a] = ukr;
ukr++;
}
}
void update(int tt) {
for (int i = tt; i >= max(0, tt - BLOCK - 1); i--) {
int val = i + BLOCK;
if (curs[i] == val) {
jump[i] = 0;
target[i] = i;
} else {
if (curs[i] >= n) {
jump[i] = 1;
target[i] = curs[i];
} else {
if (target[curs[i]] >= val) {
int t = curs[i];
int cnt = 1;
while (curs[t] < val) {
cnt++;
t = curs[t];
}
target[i] = curs[t];
jump[i] = cnt + 1;
} else {
jump[i] = 1 + jump[curs[i]];
target[i] = target[curs[i]];
}
}
}
}
}
bool bad[MAXN];
int curs2[MAXN];
inline bool comp(const pair<int, pair<int, int> > &a,
const pair<int, pair<int, int> > &b) {
return a.first < b.first;
}
int useded[MAXN];
int ukted;
int ptr[MAXN];
int mink[MAXN];
int maxk[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> w >> q;
for (int i = 0; i < n; i++) {
cin >> x[i];
mx[0][i] = x[i];
mx1[0][i] = x[i];
}
for (int k = 1; k < 18; k++) {
for (int i = 0; i < n; i++) {
int t = min(i + (1 << (k - 1)), n - 1);
mx[k][i] = min(mx[k - 1][i], mx[k - 1][t]);
mx1[k][i] = max(mx1[k - 1][i], mx1[k - 1][t]);
}
}
int cur = 1;
int step = 0;
for (int i = 1; i <= n; i++) {
if (cur + cur <= i) {
cur += cur;
step++;
}
gr[i] = step;
}
vector<pair<int, int> > st;
for (int it = 0; it < q; it++) {
int k;
cin >> k;
st.push_back({w - k, it});
}
sort((st).begin(), (st).end());
vector<pair<int, pair<int, int> > > g;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= BLOCK; j++) {
int maxk = 0;
if (i + j - 1 >= n) {
maxk = 0;
} else {
int s = getmin(i, i + j - 1);
int s1 = getmax(i, i + j - 1);
maxk = max(0, s + w - s1);
}
if (maxk) {
g.push_back({maxk, {i, j}});
}
}
curs[i] = i + 1;
mink[i] = x[i];
maxk[i] = x[i];
ptr[i] = i;
}
sort((g).begin(), (g).end(), comp);
reverse((g).begin(), (g).end());
val = 1;
int uk = 0;
for (int i = n - 1; i >= 0; i--) {
calc(i);
}
int uk1 = 0;
for (int it = 0; it < q; it++) {
val = w - st[it].first;
ukted++;
vector<int> h;
while (uk < (int)(g).size() && g[uk].first >= val) {
int gh = curs[g[uk].second.first];
chkmax(curs[g[uk].second.first],
g[uk].second.first + g[uk].second.second);
if (curs[g[uk].second.first] != gh) {
h.push_back(g[uk].second.first);
}
uk++;
}
for (auto x : h) {
if (useded[x] != ukted) {
useded[x] = ukted;
update(x);
}
}
int cur = 0;
int cnt = 0;
while (cur < n) {
if (curs[cur] - cur == BLOCK) {
cnt++;
while (ptr[cur] < n && ptr[cur] < cur + BLOCK1 &&
mink[cur] + w - maxk[cur] >= val) {
ptr[cur]++;
chkmin(mink[cur], x[ptr[cur]]);
chkmax(maxk[cur], x[ptr[cur]]);
}
if (ptr[cur] < cur + BLOCK1) {
cur = ptr[cur];
} else {
cur = findGroupEnd(cur, val);
}
} else {
cnt += jump[cur];
cur = target[cur];
}
}
ans[st[it].second] = cnt - 1;
}
for (int it = 0; it < q; it++) {
cout << ans[it] << '\n';
}
return 0;
}
| 3,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 155;
int a[MAXN];
int cache[MAXN][MAXN][2];
int cache2[MAXN][MAXN][MAXN];
string str;
int rec(int, int, int);
int inner_rec(int st, int ed, int cnt) {
if (cache2[st][ed][cnt] >= -2) return cache2[st][ed][cnt];
int tmp, tmp2, res;
res = -2;
if (a[cnt] >= 0) {
tmp = rec(st, ed, 1);
if (tmp >= 0) res = max(res, tmp + a[cnt]);
}
if (a[cnt + 1] >= 0) {
for (int i = st; i < ed; i++) {
tmp = rec(st, i, 1);
tmp2 = rec(i + 1, ed, 1);
if (tmp < 0 || tmp2 < 0) continue;
res = max(res, tmp + tmp2 + a[cnt + 1]);
}
}
for (int i = st + 1; i < ed; i++) {
tmp = rec(st, i, 1);
tmp2 = inner_rec(i, ed, cnt);
if (tmp >= 0 && tmp2 >= 0) res = max(res, tmp + tmp2);
}
for (int j = ed - 1; j > st; j--)
if (str[st] == str[j]) {
tmp = rec(j + 1, ed, 1);
tmp2 = inner_rec(st + 1, j, cnt + 2);
if (tmp >= 0 && tmp2 >= 0) res = max(res, tmp + tmp2);
}
return cache2[st][ed][cnt] = res;
}
int rec(int st, int ed, int all) {
if (st >= ed) return 0;
if (cache[st][ed][all] >= -2) return cache[st][ed][all];
if (all) return cache[st][ed][all] = inner_rec(st, ed, 0);
int res = 0;
for (int i = st; i < ed; i++)
for (int j = i + 1; j <= ed; j++) {
int tmp = rec(i, j, 1);
if (tmp >= 0) res = max(res, rec(st, i, 0) + tmp + rec(j, ed, 0));
}
return cache[st][ed][all] = res;
}
int main() {
int l;
cin >> l;
for (int i = 0; i < l; i++) cin >> a[i + 1];
a[0] = -1;
cin >> str;
for (int i = 0; i < MAXN; i++)
for (int j = 0; j < MAXN; j++) cache[i][j][0] = cache[i][j][1] = -10;
for (int i = 0; i < MAXN; i++)
for (int j = 0; j < MAXN; j++)
for (int k = 0; k < MAXN; k++) cache2[i][j][k] = -10;
int ans = rec(0, l, 0);
cout << ans << endl;
return 0;
}
| 2,600 | CPP |
t = int(input())
import math
delay = []
for _ in range(t):
n, x = map(int, input().split())
a = input().split()
a = [int(i) for i in a]
a = list(set(a))
a.sort()
tent = x
for ele in a:
if ele <= tent:
tent+=1
elif ele == tent + 1:
tent += 1
else:
break
delay.append(tent)
# print(tent)
for d in delay:
print(d)
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[30];
vector<pair<long long, long long> > res;
int solve(int n, int from, int to, int mask, bool imp) {
if (n == 0) return mask;
if (a[n - 1] == 1) {
int tmp = solve(n - 1, from, 6 - from - to, mask, false);
res.push_back(pair<long long, long long>(from, to));
mask = solve(n - 1, 6 - from - to, to, tmp, imp);
} else {
if ((mask & (1 << (n - 1))) || imp == false) {
int tmp = solve(n - 1, from, 6 - from - to, mask, false);
for (register int i = (0); i < (int)(a[n - 1]); ++i)
res.push_back(pair<long long, long long>(from, to));
mask = solve(n - 1, 6 - from - to, to, tmp ^ (1 << (n - 1)), imp);
} else {
if (n == 1) {
for (register int i = (0); i < (int)(a[n - 1] - 1); ++i)
res.push_back(pair<long long, long long>(from, 6 - from - to));
res.push_back(pair<long long, long long>(from, to));
for (register int i = (0); i < (int)(a[n - 1] - 1); ++i)
res.push_back(pair<long long, long long>(6 - from - to, to));
} else {
int tmp = solve(n - 1, from, to, mask, false);
for (register int i = (0); i < (int)(a[n - 1]); ++i)
res.push_back(pair<long long, long long>(from, 6 - from - to));
tmp = solve(n - 1, to, from, tmp ^ (1 << (n - 1)), false);
for (register int i = (0); i < (int)(a[n - 1]); ++i)
res.push_back(pair<long long, long long>(6 - from - to, to));
mask = solve(n - 1, from, to, tmp ^ (1 << (n - 1)), true);
}
}
}
return mask;
}
int cnt[30];
int main() {
int n, x;
cin >> n;
for (register int i = (0); i < (int)(n); ++i) cin >> x, cnt[x]++;
n = 0;
for (int i = 0; i < 30; i++)
if (cnt[i]) a[n++] = cnt[i];
solve(n, 1, 3, 0, true);
cout << ((int)(res).size()) << endl;
for (register int i = (0); i < (int)(((int)(res).size())); ++i)
cout << res[i].first << " " << res[i].second << endl;
return 0;
}
| 2,500 | CPP |
def bactery(number):
days = 0
while number > 0:
if number % 2 == 1:
days += 1
number //= 2
return days
print(bactery(int(input())))
| 1,000 | PYTHON3 |
k,p=[int(i) for i in input().split()]
l=[]
for i in range(9):
l.append(((i+1)*11)%p)
for i in range(9):
sum = ((i+1)*1001)%p
for j in range(10):
l.append((sum+110*j)%p)
for i in range(9):
sum = ((i+1)*100001)%p
for j in range(10):
sum1 = (sum + j*10010)%p
for q in range(10):
l.append((sum1+q*1100)%p)
for i in range(9):
sum = ((i+1)*10000001)%p
for j in range(10):
sum1 = (sum + j*1000010)%p
for q in range(10):
sum2 = (sum1 + q*100100)%p
for w in range(10):
l.append((sum2+w*11000)%p)
for i in range(9):
sum = ((i+1)*1000000001)%p
for j in range(10):
sum1 = (sum + j*100000010)%p
for q in range(10):
sum2 = (sum1 + q*10000100)%p
for w in range(10):
sum3 = (sum2 + w*1001000)%p
for e in range(10):
l.append((sum3 + e*110000)%p)
l.append(100000000001%p)
sum=0
for i in range(k):
sum = (sum+l[i])%p
print (sum) | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MAXN = 1010;
char ch[MAXN];
int k, n, f[MAXN], dp[MAXN];
int main(int argc, char const *argv[]) {
std::cin >> ch + 1;
std::cin >> k;
n = strlen(ch + 1);
if (k == 0) return std::cout << "1", 0;
f[1] = 0;
for (int i = 2; i <= n; i++) f[i] = f[__builtin_popcount(i)] + 1;
int pre = 0;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = n; j; j--) dp[j] = (dp[j] + dp[j - 1]) % MOD;
if (ch[i] == '1') dp[pre]++;
pre += ch[i] - '0';
}
dp[pre]++;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (f[i] == k - 1) ans = (ans + dp[i]) % MOD;
}
if (k == 1) ans = (ans - 1 + MOD) % MOD;
return std::cout << ans, 0;
}
| 1,800 | CPP |
def bs(b,val):
low = 0
high = len(b)-1
while low<=high:
mid = (low+high)//2
if b[mid] > val and b[mid-1] <= val:
return mid
elif b[mid] <= val:
low = mid+1
else:
high = mid-1
return -1
n,m = map(int,input().split())
k,j = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
if a[k-1] < b[0]:
if len(b) >= j:
print("YES")
exit()
ans = bs(b,a[k-1])
if ans== -1:
print("NO")
exit()
else:
if len(b) - ans >= j:
print("YES")
else:
print("NO") | 900 | PYTHON3 |
a,b,c = sorted(map(int,input().split()))
print(a*(2*c+a-1)+(c+a-1)*(b-a-1))
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
const int N = 1000005;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, x;
cin >> n >> x;
if (n == 1) {
cout << "YES\n";
cout << x;
return 0;
}
if (n == 2) {
if (x == 0)
cout << "NO";
else {
cout << "YES\n";
cout << "0 " << x;
}
return 0;
}
vector<int> v;
v.push_back(100000);
v.push_back(200000);
for (int i = 0; i < n - 3; i++) v.push_back(i);
int ans = 0;
for (int i = 0; i < v.size(); i++) ans ^= v[i];
v.push_back(ans ^ x);
cout << "YES\n";
ans = 0;
for (int i = 0; i < n; i++) ans ^= v[i], cout << v[i] << " ";
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, x, y, a1[100010], a2[100010], a3[100010], a4[100010];
cin >> n;
vector<int> v;
for (i = 0; i < n; i++) cin >> a1[i];
for (i = 0; i < n; i++) a4[i] = a1[i];
sort(a1, a1 + n);
for (i = 0; i < n - 1; i++) cin >> a2[i];
sort(a2, a2 + n - 1);
for (i = 0; i < n - 2; i++) cin >> a3[i];
sort(a3, a3 + n - 2);
for (i = 0, j = 0; i < n; i++) {
if (a1[i] == a2[j])
j++;
else
v.push_back(a1[i]);
}
for (i = 0, j = 0; i < n - 1; i++) {
if (a2[i] == a3[j])
j++;
else
v.push_back(a2[i]);
}
for (i = 0; i < v.size(); i++) cout << v[i] << endl;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int i, n, tt[300000], a[300000], k, pt[500000], hd[300000], nt[500000], m, kk,
v[300000], d[300000][3], q[3000000], t, h, x, y, Mx;
void add(int x, int y) {
++kk;
nt[kk] = hd[x];
hd[x] = kk;
pt[kk] = y;
}
void Bfs(int x, int y) {
for (i = 1; i <= n; ++i) d[i][y] = 1e9;
t = 1;
h = 0;
q[t] = x;
d[x][y] = 0;
while (h < t) {
h++;
for (int i = hd[q[h]]; i; i = nt[i])
if (d[q[h]][y] + 1 < d[pt[i]][y]) {
d[pt[i]][y] = d[q[h]][y] + 1;
if (!v[pt[i]]) q[++t] = pt[i], v[pt[i]] = 1;
}
v[q[h]] = 0;
}
}
bool cmp(int x, int y) { return d[x][1] < d[y][1]; }
int main() {
cin >> n >> m >> k;
for (i = 1; i <= k; ++i) scanf("%d", &a[i]);
for (i = 1; i <= m; ++i) scanf("%d%d", &x, &y), add(x, y), add(y, x);
Bfs(1, 1);
Bfs(n, 2);
sort(a + 1, a + k + 1, cmp);
for (i = 1; i < k; ++i) Mx = max(d[a[i]][1] + d[a[i + 1]][2] + 1, Mx);
cout << min(Mx, d[n][1]);
}
| 1,900 | CPP |
def main():
N=int(input())
if N%2 == 0 and N>2:
print('YES')
else:
print('NO')
main() | 800 | PYTHON3 |
import sys
n, h = map(int, sys.stdin.readline().split())
an = list(map(int, sys.stdin.readline().split()))
result = 0
for a in an:
if a > h:
result += 2
else:
result += 1
print(result)
| 800 | PYTHON3 |
oi=[int(i) for i in input().split()]
a, b = oi[0], oi[1]
ans=0
while a > 0 and b > 0:
if a >= b:
ans = ans + a // b
a = a % b
else:
ans = ans + b // a
b = b % a
print(ans)
| 1,100 | PYTHON3 |
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))[::-1]
cur = 0
i = 0
while i < n and a[i] >= cur:
cur = a[i]
i += 1
if i == n:
print(0)
continue
cur = a[i]
while i < n and a[i] <= cur:
cur = a[i]
i += 1
print(n-i)
| 1,200 | PYTHON3 |
n = int(input())
s = input()
cnt = 0
for i in range(n - 10):
if s[i] == '8':
cnt += 1
if cnt >= ((n - 9) // 2):
print('YES')
else:
print('NO')
| 1,200 | PYTHON3 |
import sys
n,k=list(map(int,sys.stdin.readline().strip().split()))
x=sys.stdin.readline().strip()
xc=x
x=x[:k]
y=str(int(x)+1)
op1=(x*(n//k+1))[:n]
# print(op1)
print(n)
if(op1>=xc):
print(op1)
else:
op2=(y*(n//k+1))[:n]
print(op2) | 1,700 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, t, x[200005], a[200005], vis[200005], per[200005], b[200005];
int main() {
scanf("%I64d%I64d", &n, &t);
for (i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (i = 1; i <= n; i++) scanf("%lld", &x[i]);
for (i = n; i > 0; i--) {
if (x[i] < i) {
printf("No\n");
return 0;
}
vis[x[i] + 1] = 1;
per[x[i]]++;
per[i]--;
}
for (i = n; i > 0; i--) {
per[i] += per[i + 1];
if (per[i]) {
if (vis[i]) {
printf("No\n");
return 0;
} else
vis[i] = -1;
}
}
b[n + 1] = 3e18;
vis[n + 1] = 0;
for (i = n; i > 0; i--) {
if (vis[i + 1] == 1)
b[i] = a[i + 1] + t - 1;
else
b[i] = b[i + 1] - 1;
if (b[i] >= b[i + 1]) {
printf("No\n");
return 0;
}
if (vis[i + 1] == -1 && b[i] < a[i + 1] + t) {
printf("No\n");
return 0;
}
}
printf("Yes\n");
for (i = 1; i <= n; i++) printf("%lld ", b[i]);
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 250;
long long dp[2][MAX][MAX];
long long gdeep;
long long deeps[MAX], deeps2[MAX], vist[MAX], store[MAX][MAX], stidx[MAX][MAX],
parent[MAX];
vector<long long> childs[MAX];
long long head[MAX], nxt[MAX << 1], to[MAX << 1], ent, cur;
long long n, k, d[MAX];
struct node {
long long mask, v, deep;
node() {}
node(long long a, long long b, long long c) : mask(a), v(b), deep(c) {}
};
vector<node> ss[2][MAX][MAX];
void add(long long a, long long b) {
nxt[ent] = head[a], to[ent] = b, head[a] = ent++;
nxt[ent] = head[b], to[ent] = a, head[b] = ent++;
}
void dfs1(long long v, long long pa) {
vist[v] = 1;
deeps[v] = 0;
for (long long i = head[v]; ~i; i = nxt[i]) {
long long u = to[i];
if (u != pa && vist[u] == 0) {
parent[u] = v;
dfs1(u, v);
deeps[v] = std::max(deeps[v], deeps[u] + 1);
}
}
}
void dfs2(long long v, long long pa) {
vist[v] = 1;
for (long long i = head[v]; ~i; i = nxt[i]) {
long long u = to[i];
if (u != pa && vist[u] == 0) {
childs[v].push_back(u);
dfs2(u, v);
}
}
}
bool debug = 0;
long long sol(long long mask, long long v, long long deep) {
auto &ele = dp[mask][v][deep];
auto &ve = ss[mask][v][deep];
if (ele != -1) return ele;
if (mask == 0) {
if (vist[v] == 0) {
vist[v] = 1;
for (long long i = 0; i < childs[v].size(); i++) {
long long u = childs[v][i];
for (long long dd = 0; dd <= deeps[u]; dd++) {
sol(mask, u, dd);
}
store[u][deeps[u]] = dp[mask][u][deeps[u]],
stidx[u][deeps[u]] = deeps[u];
for (long long dd = deeps[u] - 1; dd >= 0; dd--) {
if (store[u][dd + 1] > dp[mask][u][dd]) {
store[u][dd] = dp[mask][u][dd], stidx[u][dd] = dd;
} else
store[u][dd] = store[u][dd + 1], stidx[u][dd] = stidx[u][dd + 1];
}
}
}
if (childs[v].size() == 0) {
if (deep == 0)
return ele = k;
else
return ele = LLONG_MAX;
} else {
if (deep == 0) {
ele = k;
for (long long i = 0; i < childs[v].size(); i++) {
long long u = childs[v][i];
ele += std::min(sol(1, u, 1) - k, store[u][0]);
if (sol(1, u, 1) - k < store[u][0])
ve.push_back({1, u, 1});
else
ve.push_back({0, u, stidx[u][0]});
}
return ele;
} else {
if (deep > deeps[v]) return ele = LLONG_MAX;
ele = LLONG_MAX;
for (long long i = 0; i < childs[v].size(); i++) {
long long u = childs[v][i];
if (deeps[u] >= deep - 1) {
vector<node> tmp;
long long t1 = sol(0, u, deep - 1);
tmp.push_back({0, u, deep - 1});
if (t1 != LLONG_MAX) {
for (long long j = 0; j < childs[v].size(); j++) {
long long t = childs[v][j];
if (t != u) {
if (deep - 1 > deeps[t])
t1 += sol(1, t, deep + 1) - k,
tmp.push_back({1, t, deep + 1});
else {
if (sol(1, t, deep + 1) - k < store[t][deep - 1])
t1 += sol(1, t, deep + 1) - k,
tmp.push_back({1, t, deep + 1});
else
t1 += store[t][deep - 1],
tmp.push_back({0, t, stidx[t][deep - 1]});
}
}
}
if (t1 + d[deep] < ele) {
ele = t1 + d[deep];
ve = move(tmp);
}
}
}
}
return ele;
}
}
} else {
if (childs[v].size() == 0) {
if (deep > deeps2[v])
return ele = LLONG_MAX;
else
return ele = d[deep] + k;
} else {
if (deep > deeps2[v]) return ele = LLONG_MAX;
ele = d[deep] + k;
for (int i = 0; i < childs[v].size(); i++) {
long long u = childs[v][i];
long long t1 = sol(mask, u, deep + 1) - k;
long long t2 = LLONG_MAX, idx;
for (long long dd = 0; dd <= deeps[u]; dd++) {
if (sol(0, u, dd) < t2) {
t2 = sol(0, u, dd), idx = dd;
}
}
if (t1 < t2) {
ele += t1, ve.push_back({mask, u, deep + 1});
} else
ele += t2, ve.push_back({0, u, idx});
}
return ele;
}
}
}
void printdp() {
printf("parentinfo\n");
for (int i = 1; i <= n; i++) printf("i = %d, pa = %lld\n", i, parent[i]);
printf("deepinfo\n");
for (int i = 1; i <= n; i++) printf("i = %d, dd = %lld\n", i, deeps[i]);
printf("deep2info\n");
for (int i = 1; i <= n; i++) printf("i = %d, dd = %lld\n", i, deeps2[i]);
for (int i = 1; i <= n; i++) {
printf("*********************i = %d :\n", i);
for (int dd = 0; dd <= deeps[i]; dd++) {
printf("(%d, %d, %d) = %lld\n", 0, i, dd, dp[0][i][dd]);
}
for (int dd = 0; dd <= deeps2[i]; dd++) {
printf("(%d, %d, %d) = %lld\n", 1, i, dd, dp[1][i][dd]);
}
}
}
bool power[MAX];
long long ans[MAX];
void assignP(long long mask, long long v, long long deep) {
auto &ve = ss[mask][v][deep];
if (mask == 0 && deep == 0) power[v] = 1;
for (int i = 0; i < ve.size(); i++) {
node &nn = ve[i];
assignP(nn.mask, nn.v, nn.deep);
}
}
void bfs() {
for (int i = 1; i <= n; i++) {
memset(vist, 0, sizeof(vist));
queue<int> q;
q.push(i), vist[i] = 1;
if (power[i] == 1)
ans[i] = i;
else {
bool find = 0;
while (!q.empty() && !find) {
int v = q.front();
q.pop();
for (int j = head[v]; ~j; j = nxt[j]) {
int u = to[j];
if (vist[u] == 0) {
if (power[u] == 1) {
ans[i] = u, find = 1;
break;
} else {
vist[u] = 1, q.push(u);
}
}
}
}
}
}
}
int main() {
scanf("%lld%lld", &n, &k);
for (long long i = 1; i <= n - 1; i++) scanf("%lld", &d[i]);
memset(head, -1, sizeof(head));
ent = 0;
for (long long i = 1; i <= n - 1; i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
add(a, b);
}
gdeep = LLONG_MIN;
for (long long i = 1; i <= n; i++) deeps[i] = LLONG_MIN;
memset(vist, 0, sizeof(vist));
parent[1] = -1, dfs1(1, -1);
for (long long i = 1; i <= n; i++) {
deeps2[i] = 0;
long long tt = i, zz = 1;
if (i == 2)
debug = 1;
else
debug = 0;
while (tt != -1) {
long long pa = parent[tt];
if (pa != -1) {
deeps2[i] = std::max(deeps2[i], zz);
for (long long j = head[pa]; ~j; j = nxt[j]) {
long long u = to[j];
if (u != tt && u != parent[pa]) {
deeps2[i] = std::max(deeps2[i], deeps[u] + zz + 1);
}
}
}
++zz, tt = pa;
}
}
memset(vist, 0, sizeof(vist));
dfs2(1, -1);
for (long long i = 1; i <= n; i++) {
for (long long dd = 0; dd <= deeps[i]; dd++) dp[0][i][dd] = -1;
for (long long dd = 0; dd <= deeps2[i]; dd++) dp[1][i][dd] = -1;
}
memset(vist, 0, sizeof(vist));
long long opt = LLONG_MAX, t1;
node optn;
for (long long dd = 0; dd <= deeps[1]; dd++) {
t1 = sol(0, 1, dd);
if (t1 < opt) opt = t1, optn = {0, 1, dd};
}
for (long long dd = 1; dd <= deeps2[1]; dd++) {
t1 = sol(1, 1, dd);
if (t1 < opt) opt = t1, optn = {1, 1, dd};
}
printf("%lld\n", opt);
memset(power, 0, sizeof(power));
assignP(optn.mask, optn.v, optn.deep);
bfs();
for (int i = 1; i <= n; i++) printf("%lld ", ans[i]);
printf("\n");
return 0;
}
| 2,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, count = 0;
cin >> n;
vector<pair<long double, long double>> vct(n);
long long i, j;
for (i = 0; i < n; i++) cin >> vct[i].first >> vct[i].second;
sort(vct.begin(), vct.end());
for (i = 0; i < vct.size() - 1; i++) {
for (j = i + 1; j < vct.size(); j++) {
pair<long double, long double> vpr;
vpr.first = (vct[i].first + vct[j].first) / 2;
vpr.second = (vct[i].second + vct[j].second) / 2;
if (binary_search(vct.begin(), vct.end(), vpr)) {
count += 1;
}
}
}
cout << count << endl;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
for (; b; a %= b, swap(a, b))
;
return a;
}
long long a[6];
int n;
long long b[100001];
vector<pair<long long, long long> > v;
int cnt[100001];
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
for (int i = 0; i < 6; i++) cin >> a[i];
sort(a, a + 6);
cin >> n;
for (int i = 0; i < n; i++) {
long long b;
cin >> b;
for (int j = 0; j < 6; j++) {
v.push_back({b - a[j], i});
}
}
sort(v.begin(), v.end());
long long l = -1, r = 1e10;
while (l + 1 < r) {
long long m = (l + r) / 2;
bool isOK = false;
memset(cnt, 0, sizeof cnt);
int s = 0;
int cr = 0;
for (int cl = 0; cl < v.size(); cl++) {
long long x = v[cl].first;
while (cr < v.size() && v[cr].first <= x + m) {
if (cnt[v[cr++].second]++ == 0) s++;
}
if (s == n) {
isOK = true;
break;
}
if (--cnt[v[cl].second] == 0) s--;
}
if (isOK)
r = m;
else
l = m;
}
cout << r;
}
| 1,900 | CPP |
t = int(input())
for _ in range(t):
r,c = map(int, input().split())
if(r==1 or c==1):
print("YES")
continue
elif(r==2 and c ==2):
print("YES")
continue
else:
print("NO") | 800 | PYTHON3 |
from math import *
for _ in range(int(input())):
n=int(input())
if n%4!=0:
print('NO')
else:
print('YES')
summ=0
for i in range(2,n+1,2):
print(i,end=' ')
summ+=i
summ2=0
for i in range(1,n-1,2):
print(i,end=' ')
summ2+=i
print(summ-summ2)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 88;
int n, m, T, a[N], k, b[N], sum[N], dp[N][N][N * N / 2];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i] == 0) {
++b[k];
} else {
k++;
}
}
k++;
partial_sum(b, b + k, sum);
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0] = 0;
int inf = dp[1][1][1];
for (int i = 0; i < k; i++) {
for (int j = 0; j <= sum[k - 1]; j++) {
for (int step = 0; step <= n * (n - 1) / 2; step++) {
if (dp[i][j][step] != inf) {
for (int to = j; to <= sum[k - 1]; to++) {
dp[i + 1][to][step + abs(to - sum[i])] =
min(dp[i + 1][to][step + abs(to - sum[i])],
dp[i][j][step] + (to - j) * (to - j));
}
}
}
}
}
for (int step = 0; step <= n * (n - 1) / 2; step++) {
inf = min(inf, dp[k][sum[k - 1]][step]);
int val = sum[k - 1] * sum[k - 1] - inf;
cout << val / 2 << " ";
}
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, t, m, n, value, r, q, c, z, a, b, d;
cin >> n >> k;
long long int pri[n + 1];
long long int sum = 0;
for (i = 1; i <= n; i++) {
cin >> pri[i];
sum = sum + pri[i];
}
long long int vis[n + 1];
long long int Ans = 0;
a = sum;
memset(vis, 0, sizeof(vis));
for (i = 0; i < k; i++) {
sum = a;
cin >> z;
vis[z] = 1;
if (z != 1 && z != n) {
if (!vis[z - 1]) {
sum = sum - pri[z - 1];
}
if (!vis[z + 1]) {
sum = sum - pri[z + 1];
}
}
if (z == n) {
if (!vis[1]) {
sum = sum - pri[1];
}
if (!vis[n - 1]) {
sum = sum - pri[n - 1];
}
}
if (z == 1) {
if (!vis[2]) {
sum = sum - pri[2];
}
if (!vis[n]) {
sum = sum - pri[n];
}
}
sum = sum - pri[z];
Ans = Ans + sum * pri[z];
a = a - pri[z];
}
long long int ans = 0;
for (i = 1; i < n; i++) {
ans = ans + pri[i] * pri[i + 1];
}
Ans = Ans + pri[1] * pri[n] + ans;
cout << Ans;
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int mini[18][18], mini2[18][18];
int n, m, a;
vector<int> v[17];
int dp[20][1 << 16];
int call(int now, int mask, int pre) {
int& ret = dp[now][mask];
if (ret != -1) return ret;
if (mask + 1 == (1 << n)) {
return mini2[now][pre];
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (mask >> i & 1) continue;
ans = max(ans, min(mini[now][i], call(i, mask | (1 << i), pre)));
}
ret = ans;
return ret;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a;
v[i].push_back(a);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int val = 2e9 + 1;
int x;
for (int k = 0; k < m; k++) {
val = min(val, abs(v[i][k] - v[j][k]));
}
mini[i][j] = val;
val = 2e9 + 1;
for (int k = 0; k < m - 1; k++) {
val = min(val, abs(v[i][k] - v[j][k + 1]));
}
mini2[i][j] = val;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
memset(dp, -1, sizeof dp);
ans = max(ans, call(i, 1 << i, i));
}
cout << ans << endl;
}
| 2,000 | CPP |
s = input()
if s[1:].isupper() and s[0].islower() or s.isupper() or len(s) == 1:
print(s.swapcase())
else:
print(s)
| 1,000 | PYTHON3 |
n,m = input().split()
n,m=int(n),int(m)
from math import sqrt
cnt = 0
for i in range(n+1):
if sqrt(n-i)+i*i==m:
cnt+=1
print(cnt) | 800 | PYTHON3 |