solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
const int N = 2005;
int n, m;
vector<vector<char>> a;
vector<vector<int>> c, u;
bool check2(int i, int j, int i1, int j2) {
if (i < 1 || j < 1 || i1 < 1 || j2 < 1) return 0;
if (i > n || j > m || i1 > n || j2 > m) return 0;
return c[i1][j2] - c[i - 1][j2] - c[i1][j - 1] + c[i - 1][j - 1] ==
(i1 - i + 1) * (j2 - j + 1);
}
bool check(int vl) {
for (int i = 0; i < n + 2; ++i) {
for (int j = 0; j < m + 2; ++j) {
u[i][j] = 0;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (a[i][j] == 'X' && check2(i - vl, j - vl, i + vl, j + vl)) {
++u[i - vl][j - vl];
--u[i - vl][j + vl + 1];
--u[i + vl + 1][j - vl];
++u[i + vl + 1][j + vl + 1];
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
u[i][j] += u[i - 1][j] + u[i][j - 1] - u[i - 1][j - 1];
if (a[i][j] == 'X' && u[i][j] == 0) {
return 0;
}
if (a[i][j] == '.' && u[i][j] != 0) {
abort();
}
}
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m;
a.resize(n + 2, vector<char>(m + 2, 0));
c.resize(n + 2, vector<int>(m + 2, 0));
u.resize(n + 2, vector<int>(m + 2, 0));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> a[i][j];
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
c[i][j] = c[i - 1][j] + c[i][j - 1] - c[i - 1][j - 1] + (a[i][j] == 'X');
}
}
int l = 0, r = max(n, m), mid;
while (r - l > 1) {
mid = (l + r) >> 1;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
cout << l << '\n';
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (a[i][j] == 'X' && check2(i - l, j - l, i + l, j + l)) {
cout << 'X';
} else {
cout << '.';
}
}
cout << '\n';
}
return 0;
}
| 2,200 | CPP |
# n=int(input())
# n,k=map(int,input().split())
'''l=0
r=10**13
while l+1<r:
mid=(l+r)//2
val=(max(0,b_b*mid-b)*rb+max(0,b_s*mid-s)*rs+max(0,b_c*mid-b)*rc)
if val>money:
r=mid
if val<=money:
l=mid'''
# arr=list(map(int,input().split()))
# n=int(input())
# n,k=map(int,input().split())
# arr=list(map(int,input().split()))
n,d=map(int,input().split())
arr=list(map(int,input().split()))
i=0
ans=0
for j in range(n):
while j-i>=3 and arr[j]-arr[i]>d:
i+=1
if arr[j]-arr[i]<=d:
ans+=(j-i)*(j-i-1)//2
print(ans)
| 1,300 | PYTHON3 |
a = list(map(int, input().split()))
l = a.copy()
legs = False
leg = 0
cnt = 0
for i in a:
if a.count(i) >= 4:
legs = True
leg = i
break
for i in a:
if cnt > 3:
break
if i == leg:
l.remove(i)
cnt += 1
if legs:
if l[0] == l[1]:
print("Elephant")
else:
print("Bear")
else:
print("Alien")
| 1,100 | PYTHON3 |
def next(shape):
if shape == 'v': return '<'
elif shape == '<': return '^'
elif shape == '^': return '>'
else: return 'v'
start, end = input().split(' ')
n = int(input())
if n % 2 == 0: print('undefined')
elif n % 4 == 1: print('cw' if end == next(start) else 'ccw')
else: print('cw' if end == next(next(next(start))) else 'ccw') | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int g;
int f(int k) {
int h = g, ans = 0;
while (h) {
ans += h % k;
h /= k;
}
return ans;
}
int gcd(int k, int m) {
if (k == 0) return m;
if (m == 0) return k;
if (k > m) return gcd(k % m, m);
return gcd(k, m % k);
}
int main() {
int b;
scanf("%d", &g);
int s = 0;
for (b = 2; b < g; b++) {
s += f(b);
}
int o = gcd(s, g - 2);
printf("%d/%d\n", s / o, (g - 2) / o);
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 305;
const long long INF = 1e18 + 7;
const long long mod = 1e9 + 7;
const double PI = acos(-1);
const double eps = 1e-6;
long long C[110][110];
void init() {
memset(C, 0, sizeof(C));
C[0][0] = 1;
for (int i = 1; i < 100; ++i) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; ++j) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
}
struct matrix {
long long jie[110][110];
long long n, m;
void init() {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) jie[i][j] = 0;
}
matrix operator*(const matrix &a) const {
matrix b;
b.n = n;
b.m = a.m;
b.init();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= a.m; ++j) {
b.jie[i][j] = 0;
for (int k = 1; k <= m; ++k) {
b.jie[i][j] = ((jie[i][k] * a.jie[k][j]) % mod + b.jie[i][j]) % mod;
}
}
return b;
}
} t1, t2, t3;
matrix mpow(matrix a, long long b) {
matrix kk;
kk.n = kk.m = a.n;
kk = a;
b--;
while (b) {
if (b & 1) kk = kk * a;
a = a * a;
b >>= 1;
}
return kk;
}
long long n, m;
void gao() {
t1.n = 2 * m + 3;
t1.m = 1;
t1.init();
for (int i = 1; i <= t1.n - 1; ++i) t1.jie[i][1] = 1;
t1.jie[t1.n][1] = 0;
t2.n = t2.m = 2 * m + 3;
t2.init();
for (int i = 1; i <= m + 1; ++i) {
for (int j = 1; j <= i; ++j) {
t2.jie[i][j] = t2.jie[i + 1 + m][j] = t2.jie[i][1 + m + j] =
C[i - 1][j - 1];
}
}
t2.jie[2 * m + 3][1 + m] = 1;
t2.jie[2 * m + 3][2 * m + 3] = 1;
}
int main() {
init();
while (scanf("%lld", &n) != EOF) {
scanf("%lld", &m);
if (n == 1) {
printf("1\n");
return 0;
}
gao();
t3 = mpow(t2, n - 1) * t1;
long long ans = 0;
ans = (t3.jie[m + 1][1] % mod + t3.jie[m * 2 + 3][1] % mod + mod) % mod;
printf("%lld\n", ans);
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<string> v;
int n, k;
string x[9];
class state {
public:
int mask;
string str;
};
int tar;
void generate() {
queue<state> q;
state sr, ns;
for (int i = 0; i < k; ++i) {
sr.str = (char)(i + '0');
sr.mask = 1 << i;
q.push(sr);
}
while (!q.empty()) {
sr = q.front();
q.pop();
if (sr.mask == (1 << k) - 1) {
v.push_back(sr.str);
}
for (int i = 0; i < k; ++i) {
if (!(1 << i & sr.mask)) {
ns.mask = sr.mask | 1 << i;
ns.str = sr.str + (char)(i + '0');
q.push(ns);
}
}
}
}
int main() {
cin >> n >> k;
int res = 1 << 30;
for (int i = 0; i < n; ++i) cin >> x[i];
generate();
for (int i = 0; i < v.size(); ++i) {
int a[9] = {0};
string per = v[i];
for (int j = 0; j < n; ++j)
for (int k = 0; k < per.size(); ++k)
a[j] = a[j] * 10 + x[j][per[k] - '0'] - '0';
sort(a, a + n);
res = min(res, a[n - 1] - a[0]);
}
cout << res;
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int val[200005];
int nxt[200005];
vector<pair<int, int> > vec;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, big = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> val[i];
nxt[i] = (i + 1);
big = max(big, val[i]);
vec.push_back(make_pair(val[i], i));
}
sort(vec.begin(), vec.end());
for (int i = 0; i < vec.size(); i++) {
pair<int, int> temp = vec[i];
int tval = temp.first;
int tidx = temp.second;
int trav = nxt[tidx];
if (val[tidx] == -1 || tval == big) continue;
val[tidx] = -1;
while ((val[trav] == -1 || val[trav] == tval) && trav <= n) {
val[trav] = -1;
trav = nxt[trav];
}
int cnt = trav - tidx;
if (cnt % 2 == 0) {
nxt[tidx] = trav;
val[tidx] = -1;
} else {
cout << "NO\n";
exit(0);
}
}
cout << "YES\n";
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
inline unsigned int getuint() {
char w = getchar();
while (w < '0' || '9' < w) w = getchar();
unsigned int ans = 0;
for (; '0' <= w && w <= '9'; w = getchar()) ans = ans * 10 + w - '0';
return ans;
}
inline bool is_prime(int n) {
for (int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return n > 1;
}
char str[105];
bool test(int i) {
printf("%d\n", i);
fflush(stdout);
scanf("%s", str);
return str[0] == 'y';
}
int main() {
for (int i = 1; i * i <= 100; i++)
if (is_prime(i)) {
if (test(i)) {
int tag = 1;
for (int j = 1; i * j <= 100; j++)
if (is_prime(j) && test(i * j)) {
tag = 0;
break;
}
puts(tag ? "prime" : "composite");
fflush(stdout);
return 0;
}
}
puts("prime");
fflush(stdout);
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000000;
int c[1000];
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<string> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> ans;
bool run = true;
while (run) {
run = false;
for (int i = 0; i < n; i++) {
if (c[i] == a[i]) {
run = true;
ans.push_back(i + 1);
for (int j = 0; j < n; j++)
if (v[i][j] == '1') c[j]++;
break;
}
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
| 2,300 | CPP |
from collections import Counter
l, r = [int(n) for n in input().split()]
def find(l, r):
for i in range(l, r+1):
if Counter(str(i)).most_common(1)[0][1] == 1:
return i
return -1
print(find(l,r)) | 800 | PYTHON3 |
import sys
import math
import bisect
import itertools
def main():
n = int(input())
s = set(list(input()))
if len(s) == 1 or len(s) < n:
print('Yes')
else:
print('No')
if __name__ == "__main__":
main()
| 900 | PYTHON3 |
i = 0
j = 0
for m in range(1,6):
row = input().split(" ")
if '1' in row:
i = m
for n in range(0,5):
if int(row[n]) == 1:
j = n+1
print(abs(i-3)+abs(j-3)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long double X1, X2, Y1, Y2, x, y, ux, uy, wx, wy, umax, t;
bool check(long double time) {
long double t1 = min(time, t);
long double t2 = max(time - t, (long double)0);
long double x = X1 + t1 * ux + t2 * wx;
long double y = Y1 + t1 * uy + t2 * wy;
long double distance = sqrt((x - X2) * (x - X2) + (y - Y2) * (y - Y2));
if (umax * time + 0.00000000001 > distance)
return 1;
else
return 0;
}
int main() {
cin >> X1 >> Y1 >> X2 >> Y2;
cin >> umax >> t;
cin >> ux >> uy >> wx >> wy;
x = X2 - X1;
y = Y2 - Y1;
long double l = 0, r = (long double)1e8;
for (int i = 0; i < 100; ++i) {
long double m = (l + r) / 2.0;
if (check(m))
r = m;
else
l = m;
}
cout << fixed << setprecision(10) << r << '\n';
return 0;
}
| 2,100 | CPP |
from math import floor
m,n=input().split()
m,n=int(m),int(n)
print(floor((m*n)/2)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
int N, M;
long long T[900000];
long double Dp[200000];
pair<long long, int> A[200000];
void Build(int v, int tl, int tr) {
if (tl == tr)
T[v] = A[tl].first;
else {
Build(v * 2, tl, (tl + tr) / 2);
Build(v * 2 + 1, (tl + tr) / 2 + 1, tr);
T[v] = max(T[v * 2], T[v * 2 + 1]);
}
}
long long Max(int v, int tl, int tr, int l, int r) {
if (l > r)
return 0;
else if (tl == l && tr == r)
return T[v];
else {
int tm = (tl + tr) / 2;
long long left = Max(v * 2, tl, tm, l, min(r, tm));
long long right = Max(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
return max(left, right);
}
}
void Update(int v, int tl, int tr, int pos, long double val) {
if (tl == tr)
T[v] = val;
else {
int tm = (tl + tr) / 2;
if (pos <= tm)
Update(v * 2, tl, tm, pos, val);
else
Update(v * 2 + 1, tm + 1, tr, pos, val);
T[v] = max(T[v * 2], T[v * 2 + 1]);
}
}
int main() {
std::ios::sync_with_stdio(false);
cin >> N;
long long r, h;
for (int i = 1; i <= N; i++) {
cin >> r >> h;
A[i].first = r * r * h;
A[i].second = -i;
}
sort(A, A + N + 1);
for (int i = 1; i <= N; i++) {
int ind = -A[i].second;
long long cur = A[i].first;
Dp[ind] = Max(1, 1, N, 1, ind) + cur;
Update(1, 1, N, ind, Dp[ind]);
}
cout << fixed << setprecision(9) << PI * Max(1, 1, N, 1, N) << endl;
return 0;
}
| 2,000 | CPP |
def solve(n, s):
ans = n
last = -1
for i in range(n):
if s[i] == '1':
ans = max(ans, i*2+2)
last = i
x, y = 1, 0
if s[0] == '1':
y = 2
ans = 2 * n
if last > 0:
ans = max(max(x, y) + last * 2, ans)
for i in range(2, n):
if s[i] == '1':
x, y = max(y+2, x+1), max(x+2, y+1)
else:
x, y = x+1, y+1
if i < last:
ans = max(max(x, y)+(last-i)*2, ans)
return max(ans, x, y)
t = int(input())
for _ in range(t):
n = int(input())
s = input()
ans = solve(n, s)
s = s[::-1]
ans = max(ans, solve(n, s))
print(ans) | 1,000 | PYTHON3 |
def solve(a,b,ans):
if a == b:
ans.append(0)
elif a < b:
diff = b-a
if diff%2 == 0:
ans.append(2)
else:
ans.append(1)
else:
diff = a-b
if diff%2 != 0:
ans.append(2)
else:
ans.append(1)
def main():
ans = []
t = int(input())
for i in range(t):
a,b = map(int,input().split())
solve(a,b,ans)
for i in ans:
print(i)
main()
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[1005];
int main() {
int n, ansa, ansb, i;
while (scanf("%d", &n) != EOF) {
ansa = ansb = 0;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++)
if (a[i] != i && ansa == 0) ansa = i;
for (i = n; i >= 1; i--)
if (a[i] != i && ansb == 0) ansb = i;
for (i = ansa; i <= ansb; i++) {
if (a[i] != ansa + ansb - i) {
ansa = ansb = 0;
break;
}
}
printf("%d %d\n", ansa, ansb);
}
return 0;
}
| 1,300 | CPP |
line=input()
print(line)
now = line.split()
n=int(input())
for i in range(n):
inp=input().strip()
line=inp.split()
for i in range(len(now)):
if now[i]==line[0]:
now[i]=line[1]
for x in now:
print(x,end=' ')
print()
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, sz, son[1111][11], val[1111], cur, len, dep[1111], x, ans;
int dp[555][555][22], beg[555], en[555], cnt, f[555][22], g[555][22];
char opt[555];
void prec(int i) {
beg[i] = ++cnt;
for (int j = 0; j < 10; j++) {
if (son[i][j]) prec(son[i][j]);
}
en[i] = cnt;
}
void dfs(int i) {
for (int j = 0; j < 10; j++) {
if (son[i][j]) dfs(son[i][j]);
}
for (int j = 1; j <= sz; j++) {
if (beg[j] <= beg[i] && en[j] >= en[i]) {
for (int h = 1; h <= k; h++) f[j][h] = 1e9;
f[j][0] = 0;
} else {
for (int h = 0; h <= k; h++) f[j][h] = 1e9;
}
}
for (int j = 0; j < 10; j++) {
if (!son[i][j]) continue;
int to = son[i][j];
for (int h = 1; h <= sz; h++) {
for (int s = 0; s <= k; s++) g[h][s] = 1e9;
}
for (int h = 1; h <= sz; h++) {
for (int s = 0; s <= k; s++) {
for (int t = 0; t <= k - s; t++) {
g[h][s + t] =
min(g[h][s + t], f[h][s] + min(dp[to][h][t], dp[to][to][t]));
}
}
}
for (int h = 1; h <= sz; h++) {
for (int s = 0; s <= k; s++) f[h][s] = g[h][s];
}
}
for (int h = 1; h <= sz; h++) {
if (beg[h] <= beg[i] && en[h] >= en[i]) {
for (int s = 0; s <= k; s++) {
f[h][s] += ((dep[i] - dep[h]) * val[i]);
}
}
if (i == h) {
if (i == 1) {
for (int s = 0; s <= k; s++) dp[i][h][s] = f[h][s];
} else {
dp[i][h][0] = 1e9;
for (int s = 1; s <= k; s++) dp[i][h][s] = f[h][s - 1];
}
} else {
for (int s = 0; s <= k; s++) dp[i][h][s] = f[h][s];
}
}
}
int main() {
scanf("%d%d", &n, &k);
sz = 1;
for (int i = 1; i <= n; i++) {
scanf("%s", opt);
len = strlen(opt);
cur = 1;
for (int j = 0; j < len; j++) {
if (son[cur][opt[j] - '0'])
cur = son[cur][opt[j] - '0'];
else {
++sz;
dep[sz] = dep[cur] + 1;
cur = son[cur][opt[j] - '0'] = sz;
}
}
scanf("%d", &x);
val[cur] += x;
}
prec(1);
dfs(1);
ans = 1e9;
for (int i = 0; i <= k; i++) ans = min(ans, dp[1][1][i]);
printf("%d\n", ans);
return 0;
}
| 2,800 | CPP |
d, sum_time = map(int, input().split())
limitations = []
for _ in range(d):
limitations.append(list(map(int, input().split())))
def cumsum(a):
sum = 0
cumsum = []
for x, _ in a[::-1]:
sum += x
cumsum = [sum] + cumsum
return cumsum
min_times = cumsum(limitations)
schedule = []
total_time = 0
def relu(x):
return x * (x > 0)
for i, (min_time, max_time) in enumerate(limitations):
time = min(min_time + relu(sum_time - min_times[i]), max_time)
schedule.append(time)
sum_time -= time
if sum_time == 0:
print('YES')
print(*schedule)
else:
print('NO') | 1,200 | PYTHON3 |
#include <bits/stdc++.h>
const int N = 30010;
const long long mod = 998244353;
using namespace std;
int n;
int a[N], a1[N], a2[N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
cout << y * 2 << endl;
}
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, ans = 0, level = 1;
cin >> n;
while (n > 1) {
ans += (n / 2) * level;
level *= 2;
n = ceil(n / 2.0);
}
cout << ans;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int a, b, c;
cin >> a >> b >> c;
cout << setprecision(20);
bool even = false;
if ((a + b + c) % 2 == 0) even = true;
long long int out = (a + b + c) / 2;
if (even)
cout << out << endl;
else
cout << (a + b + c - 1) / 2 << endl;
}
}
| 800 | CPP |
print(''.join('.'+l for l in input().lower() if l not in 'a,e,o,u,i,y')) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int g[55][55], id;
vector<pair<int, int> > res1, res2;
bool chk(bool f) {
if (f == 0) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j += 2)
if (g[i][j] != g[i][j + 1]) return false;
} else {
for (int i = 0; i < n; i += 2)
for (int j = 0; j < m; j++)
if (g[i][j] != g[i + 1][j]) return false;
}
return true;
}
void adjust(bool f, vector<pair<int, int> > &res) {
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < m - 1; j++)
if (f == 0) {
if (g[i][j] == g[i][j + 1] && g[i + 1][j] == g[i + 1][j + 1]) {
swap(g[i][j + 1], g[i + 1][j]);
res.push_back(make_pair(i + 1, j + 1));
}
} else {
if (g[i][j] == g[i + 1][j] && g[i][j + 1] == g[i + 1][j + 1]) {
swap(g[i][j + 1], g[i + 1][j]);
res.push_back(make_pair(i + 1, j + 1));
}
}
}
void proc(vector<pair<int, int> > &res) {
id = 0;
for (int i = 0; i < n; i++) {
char s[55];
scanf("%s", s);
for (int j = 0; j < m; j++) {
if (s[j] == 'U') g[i][j] = g[i + 1][j] = id++;
if (s[j] == 'L') g[i][j] = g[i][j + 1] = id++;
}
}
res.clear();
int f = m % 2;
while (!chk(f)) {
adjust(f, res);
adjust(1 - f, res);
}
}
int main() {
scanf("%d%d", &n, &m);
proc(res1);
proc(res2);
printf("%d\n", res1.size() + res2.size());
for (int i = 0; i < res1.size(); i++)
printf("%d %d\n", res1[i].first, res1[i].second);
for (int i = res2.size() - 1; i >= 0; i--)
printf("%d %d\n", res2[i].first, res2[i].second);
return 0;
}
| 2,700 | CPP |
t=int(input())
for i in range(0,t,1):
n,k=[int(x) for x in input().split(" ")]
s=input()
total=0
for i in range(0,k//2,1):
count=[0]*123
maxi=0
for j in range(0,n,k):
s1=j+i
s2=j+(k-1-i)
count[ord(s[s1])]+=1
count[ord(s[s2])]+=1
maxi=max(count)
req=2*(n//k)
total=total+(req-maxi)
if k%2!=0:
count=[0]*123
for i in range(k//2,n,k):
count[ord(s[i])]+=1
maxi=max(count)
total=total+(n//k-maxi)
print(total)
| 1,500 | PYTHON3 |
#import sys
#sys.setrecursionlimit(20000)
f = lambda: input()
n,m = map(int, f().split())
dp = [99999] * 10001
dp[n] = 0
def click():
for i in range(0, n+1):
dp[i] = n-i;
if i*2 <= 10000:
if dp[i*2] > dp[i]+1:
dp[i*2] = dp[i]+1
for i in range(n+1, 10001):
if dp[i] == 99999:
d = 1
while(i+d <= 10000 and dp[i+d] == 99999):
d+=1
if i+d <= 10000:
dp[i] = d + dp[i+d]
if i*2 <= 10000 and dp[i*2] > dp[i]+1:
dp[i*2] = dp[i]+1
click()
#print(dp)
print(dp[m])
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, p, x, y;
cin >> n >> k >> p >> x >> y;
vector<long long> v;
long long sum = 0;
for (long long i = 0; i < k; i++) {
long long x1;
cin >> x1;
v.push_back(x1);
sum += x1;
}
long long req = x - sum;
if ((n - k) <= req) {
vector<long long> chk;
for (long long i = 0; i < n - k; i++) {
chk.push_back(1);
req -= 1;
}
for (long long i = 0; i < n - k; i++) {
if ((req - (y - 1)) >= 0) {
chk[i] += (y - 1);
req = req - (y - 1);
} else {
chk[i] += req;
req = 0;
break;
}
}
for (long long i = 0; i < n - k; i++) v.push_back(chk[i]);
sort(v.begin(), v.end());
if (v[n / 2] >= y) {
for (long long i = 0; i < n - k; i++) cout << chk[i] << " ";
cout << "\n";
} else
cout << "-1\n";
} else {
cout << "-1\n";
}
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
double t, s = 1;
for (t = 2; t <= n; t++) {
s = s + (1 / t);
}
cout << fixed << setprecision(12) << s;
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using V = vector<T>;
template <typename T>
using VV = vector<V<T>>;
template <typename T>
istream &operator>>(istream &cin, V<T> &arr) {
for (T &val : arr) {
cin >> val;
}
return cin;
}
template <typename T>
ostream &operator<<(ostream &cout, VV<T> &arr) {
for (V<T> &val : arr) {
cout << val << endl;
}
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, V<T> &arr) {
for (T &val : arr) {
cout << val << " ";
}
return cout;
}
void update(vector<vector<long long>> &tree, long long v, long long l,
long long r, long long lb, long long rb, long long val) {
if (lb > rb) {
return;
}
if (l == lb && r == rb) {
tree[v][2] += val;
} else {
long long m = (l + r) / 2;
update(tree, v * 2, l, m, lb, min(rb, m), val);
update(tree, v * 2 + 1, m + 1, r, max(lb, m + 1), rb, val);
}
}
void build(vector<vector<long long>> &tree, vector<long long> &arr, long long v,
long long l, long long r) {
if (l == r)
tree[v] = {arr[l], arr[l]};
else {
long long m = (l + r) / 2;
build(tree, arr, v * 2, l, m);
build(tree, arr, v * 2 + 1, m + 1, r);
tree[v][0] = max(tree[v * 2][0], tree[v * 2 + 1][0]);
tree[v][1] = min(tree[v * 2][1], tree[v * 2 + 1][1]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, k;
cin >> n >> m;
vector<long long> arr(n);
cin >> arr;
vector<long long> razn(n - 1);
for (int i = 0; i < n - 1; i++) razn[i] = arr[i + 1] - arr[i];
sort(razn.begin(), razn.end());
long long ans = 0;
for (int i = 0; i < n - m; i++) ans += razn[i];
cout << ans;
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool a[2000][2000];
int m, n;
bool isEmptyRow(int r, int c1, int c2) {
for (int i = 0; i < m; ++i) {
if (a[r][i] && i != c1 && i != c2) return false;
}
return true;
}
bool isEmptyColumn(int c, int r1, int r2) {
for (int i = 0; i < n; ++i) {
if (a[i][c] && i != r1 && i != r2) return false;
}
return true;
}
int main() {
int xm, xM, ym, yM;
int x1, x2, y1, y2;
char ch;
cin >> n >> m;
for (int i = 0; i <= (n * m - 1); ++i) {
cin >> ch;
if (ch == '.')
a[i / m][i % m] = 0;
else if (ch == 'w')
a[i / m][i % m] = 1;
else
i--;
}
xm = xM = ym = yM = -1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == 1) {
if (xm == -1 || j < xm) xm = j;
if (j > xM) xM = j;
if (ym == -1 || i < ym) ym = i;
if (i > yM) yM = i;
}
}
}
if (xM - xm == yM - ym) {
x1 = xm;
x2 = xM;
y1 = ym;
y2 = yM;
} else if (xM - xm > yM - ym) {
x1 = xm;
x2 = xM;
y1 = ym;
if (ym + xM - xm < n && (isEmptyRow(yM, xm, xM) || ym == yM))
y2 = ym + xM - xm;
else if (yM - (xM - xm) >= 0 && (isEmptyRow(ym, xm, xM) || ym == yM)) {
y2 = yM;
y1 = yM - (xM - xm);
} else if (xM - xm < n) {
y1 = 0;
y2 = xM - xm;
} else
y2 = -1;
} else {
x1 = xm;
y1 = ym;
y2 = yM;
if (xm + yM - ym < m && (isEmptyColumn(xM, ym, yM) || xm == xM))
x2 = xm + yM - ym;
else if (xM - (yM - ym) >= 0 && (isEmptyColumn(xm, ym, yM) || xm == xM)) {
x2 = xM;
x1 = xM - (yM - ym);
} else if (yM - ym < m) {
x1 = 0;
x2 = yM - ym;
} else
x2 = -1;
}
if (x2 < 0 || y2 < 0) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] && !(((j == x1 || j == x2) && i <= y2 && i >= y1) ||
((i == y1 || i == y2) && j <= x2 && j >= x1))) {
cout << -1 << endl;
return 0;
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j])
cout << 'w';
else if (((j == x1 || j == x2) && i <= y2 && i >= y1) ||
((i == y1 || i == y2) && j <= x2 && j >= x1))
cout << '+';
else
cout << '.';
}
cout << endl;
}
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, cnt;
vector<int> v;
int main() {
cin >> n >> a >> b;
if (a > b) swap(a, b);
for (int i = 1; i <= n; i++) v.push_back(i);
while (v.size() != 2) {
cnt++;
for (int i = 0; i < v.size(); i += 2) {
if (v[i] == a && v[i + 1] == b) {
cout << cnt << endl;
return 0;
} else if (v[i] == a || v[i] == b)
v[i + 1] = 0;
else
v[i] = 0;
}
for (int i = 0; i < v.size(); i++)
if (v[i] == 0) {
for (int j = i; j < v.size() - 1; j++) v[j] = v[j + 1];
v.pop_back();
i--;
}
}
cout << "Final!" << endl;
return 0;
}
| 1,200 | CPP |
T = int(input())
for __ in range(T):
x,y = map(int, input().split())
print(x-1,y) | 1,100 | PYTHON3 |
import sys
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int,minp().split())
def solve():
n = mint()
a = list(mints())
b = [True]*n
for i in range(n-1):
j = i + 1
z = (a[i],i)
while j < n and b[j-1]:
z = min(z, (a[j], j))
j += 1
if z[0] < a[i]:
j = z[1] - 1
while j >= i:
a[j], a[j+1] = a[j+1], a[j]
b[j] = False
j -= 1
print(*a)
for i in range(mint()):
solve()
| 1,400 | PYTHON3 |
s=input()
k=len(s)
moves=0
for i in range(k):
if i!=0:
a=s[i]
b=s[i-1]
t=abs(ord(a)-ord(b))
if t>13:
t=26-t
moves+=t
else:
t=abs(ord(s[0])-ord('a'))
if t>13:
t=26-t
moves+=t
print(moves) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<string, int> mp1;
mp1["Tetrahedron"] = 4;
mp1["Cube"] = 6;
mp1["Octahedron"] = 8;
mp1["Dodecahedron"] = 12;
mp1["Icosahedron"] = 20;
int n;
string s;
cin >> n;
long r = 0;
for (int i = 0; i < n; i++) {
cin >> s;
r += mp1[s];
}
cout << r;
return 0;
}
| 800 | CPP |
n, k = map(int, input().split())
A = list(map(int, input().split()))
if A[k-1] > 0:
i = k-1
while(A[i]==A[k-1]):
i += 1
if i==n:
break
print(i)
else:
i = k-1
while(A[i] <= 0):
i-=1
if i == -1:
break
print(i+1)
| 800 | PYTHON3 |
n=int(input())
lis=input().split()
for i in range(n):
lis[i]=int(lis[i])
m=lis[0]
M=lis[0]
c=0
if n==1:
print('0')
else:
for i in range(1,n):
if lis[i]>M or lis[i]<m:
c+=1
if lis[i]>M:
M=lis[i]
else:
m=lis[i]
print(c)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
char adj[55][55];
bool V[55][55];
char F[111][111];
bool valid(int x, int y) { return (x <= n && y <= n && x >= 1 && y >= 1); }
void solve() {
scanf("%d", &n);
vector<pair<int, int> > piece, ans;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> adj[i][j];
if (adj[i][j] == 'o') {
piece.push_back({i, j});
}
}
}
for (int i = -50; i <= 50; i++) {
for (int j = -50; j <= 50; j++) {
bool ok = true;
bool f = false;
for (int k = 0; k < piece.size(); k++) {
int nx, ny;
nx = piece[k].first + i;
ny = piece[k].second + j;
if (valid(nx, ny)) {
f = true;
if (adj[nx][ny] == '.') {
ok = false;
}
}
}
if (f && ok) {
ans.push_back({i, j});
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (adj[i][j] == 'o')
for (int k = 0; k < ans.size(); k++) {
int nx, ny;
nx = i + ans[k].first;
ny = j + ans[k].second;
if (valid(nx, ny)) {
V[nx][ny] = 1;
}
}
}
}
bool ok = true;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (adj[i][j] == 'x' && !V[i][j]) {
ok = false;
}
}
}
if (ok) {
cout << "YES" << endl;
for (int i = 1; i < 2 * n; i++)
for (int j = 1; j < 2 * n; j++) F[i][j] = '.';
F[n][n] = 'o';
for (int i = 0; i < ans.size(); i++) {
int x, y;
x = n + ans[i].first;
y = n + ans[i].second;
F[x][y] = 'x';
}
F[n][n] = 'o';
for (int i = 1; i < 2 * n; i++) {
for (int j = 1; j < 2 * n; j++) {
cout << F[i][j];
}
cout << endl;
}
} else {
cout << "NO" << endl;
}
}
int main() {
int t;
t = 1;
while (t--) solve();
return 0;
}
| 1,800 | CPP |
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 19
MOD = 10 ** 9 + 7
for _ in range(INT()):
N = INT()
S = list(map(int, input()))
T = list(map(int, input()))
ans = []
l = 0
r = N - 1
flip = 0
rev = 0
for i in range(N-1, -1, -1):
if not rev:
if S[l]^flip != T[i]:
ans.append(i+1)
flip ^= 1
rev ^= 1
l += 1
else:
if l >= r:
break
ans.append(1)
S[l] ^= 1
ans.append(i+1)
flip ^= 1
rev ^= 1
l += 1
else:
if S[r]^flip != T[i]:
ans.append(i+1)
flip ^= 1
rev ^= 1
r -= 1
else:
if l >= r:
break
ans.append(1)
S[r] ^= 1
ans.append(i+1)
flip ^= 1
rev ^= 1
r -= 1
ans.insert(0, len(ans))
print(*ans)
| 1,300 | PYTHON3 |
from math import floor, sqrt
def sigma(n):
return n * (n - 1) // 2
def sigma_inv(n):
f = 1 / 2 + sqrt(2 * n - 2 + 1 / 4)
return floor(f)
n = int(input())
for _ in range(n):
s, k = map(int, input().split())
ans = ["a"] * s
b2 = k - sigma(sigma_inv(k))
b1 = floor(sigma_inv(k)) + 1
ans[-b2] = 'b'
ans[-b1] = 'b'
print(*ans, sep='')
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct qq {
long long x, m;
bool operator<(const qq &X) const { return x < X.x; }
} a[100005];
long long b[100005], man;
long long n, m, A, cf, cm, pre[100005], i, sum, ans, temm, L, R, mid, chuang;
int main() {
scanf("%I64d%I64d%I64d%I64d%I64d", &n, &A, &cf, &cm, &m);
for (i = 1; i <= n; ++i) {
scanf("%I64d", &a[i].x);
a[i].m = i;
}
sort(a + 1, a + n + 1);
for (i = 1; i <= n; ++i) pre[i] = a[i].x + pre[i - 1];
if (m + pre[n] >= A * n) {
printf("%I64d\n", cf * n + A * cm);
for (i = 0; i < n; ++i) {
printf("%I64d%c", A, i == n - 1 ? '\n' : ' ');
}
return 0;
}
ans = -1;
for (i = n + 1; i; --i) {
sum += a[i].x;
if (m + sum < A * (n - i + 1)) break;
temm = m - A * (n - i + 1) + sum;
if (pre[i - 1] + temm >= (i - 1) * a[i - 1].x) {
if (ans < cf * (n - i + 1) + min(A, (pre[i - 1] + temm) / (i - 1)) * cm) {
ans = cf * (n - i + 1) + min(A, (pre[i - 1] + temm) / (i - 1)) * cm;
man = i;
chuang = min(A, (pre[i - 1] + temm) / (i - 1));
}
continue;
}
L = 1;
R = i - 1;
while (L < R) {
mid = 1 + ((L + R) >> 1);
if (pre[mid] + temm >= (mid)*a[mid].x) {
L = mid;
} else {
R = mid - 1;
}
}
if (ans < cf * (n - i + 1) + min(A, (pre[L] + temm) / L) * cm) {
ans = cf * (n - i + 1) + min(A, (pre[L] + temm) / L) * cm;
man = i;
chuang = min(A, (pre[L] + temm) / L);
}
}
for (i = n; i >= man; --i) a[i].x = A;
for (i = 1; i <= n; ++i) {
if (a[i].x <= chuang) {
b[a[i].m] = chuang;
} else {
b[a[i].m] = a[i].x;
}
}
printf("%I64d\n", ans);
for (i = 1; i <= n; ++i) {
printf("%I64d%c", b[i], i == n ? '\n' : ' ');
}
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 3e5 + 69;
const long long MOD = 1e9 + 7;
vector<long long> g[MAXN], gr[MAXN];
long long cnt[MAXN];
bool ok[MAXN];
long long n;
long long cl[MAXN];
vector<long long> a;
long long c = 0;
void dfs(long long v, long long dl) {
bool kek = 0;
c++;
for (long long to : gr[v]) {
dfs(to, dl);
kek = 1;
}
}
void dfs1(long long v) {
cl[v] = 1;
for (long long to : g[v]) {
if (v == to) {
a.push_back(1);
continue;
}
if (cl[to] == 0)
dfs1(to);
else if (cl[to] == 1) {
a.push_back(2);
}
}
cl[v] = 2;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long i = 0; i < n; ++i) {
long long fr, to;
cin >> fr >> to;
g[fr - 1].push_back(to - 1);
gr[to - 1].push_back(fr - 1);
ok[to - 1] = 1;
}
for (long long i = 0; i < 2 * n; ++i)
if (ok[i] && g[i].size() == 0) {
cnt[i] = 1;
c = 0;
dfs(i, 0);
a.push_back(c);
}
long long cnt = 0;
for (long long i = 0; i < 2 * n; ++i)
if (g[i].size() == 1 && cl[i] == 0) {
dfs1(i);
}
long long ans = 1;
for (long long i : a) {
ans = (ans * i) % MOD;
}
cout << ans;
return 0;
}
| 2,100 | CPP |
n=int(input())
a=input()
L=list(a)
b=0
for i in range(len(L)-1):
if L[i]==L[i+1]:
b+=1
print(b)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void get_check(string s, vector<vector<bool>> &check) {
for (int i = 0; i <= (int)((s).size()) - 1; i++) {
check[i][i] = 1;
}
for (int l = 2; l <= (int)((s).size()); l++) {
for (int i = 0; i <= (int)((s).size()) - l; i++) {
int j = i + l - 1;
if (s[i] == s[j])
if ((check[i + 1][j - 1]) || (i + 1 == j)) {
check[i][j] = true;
}
}
}
}
vector<int> z_array(string s) {
vector<int> ans((int)((s).size()));
ans[0] = -1;
int l = 0, r = 0;
for (int i = 1; i < s.size(); i++) {
if (i > r) {
l = i;
r = i;
while ((r < s.size()) && (s[r] == s[r - i])) {
r++;
}
r--;
ans[i] = r - l + 1;
} else {
int k = i - l;
if (ans[k] + i <= r) {
ans[i] = ans[k];
} else {
l = i;
while ((r < s.size()) && (s[r] == s[r - i])) {
r++;
}
r--;
ans[i] = r - l + 1;
}
}
}
return ans;
}
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
string s;
cin >> s;
vector<vector<int>> rep((int)((s).size()), vector<int>((int)((s).size()), 0));
for (int i = 0; i <= (int)((s).size()) - 1; i++) {
string imps = s.substr(i, (int)((s).size()) - i) + "*" + s;
vector<int> imparr = z_array(imps);
for (int j = i; j <= (int)((s).size()) - 1; j++) {
rep[i][j] = imparr[j + (int)((s).size()) - i + 1];
}
}
vector<vector<int>> order((int)((s).size()),
vector<int>((int)((s).size()), 0));
vector<int> ans((int)((s).size()), 0);
for (int i = 0; i <= (int)((s).size()) - 1; i++) {
order[i][i] = 1;
ans[0]++;
}
for (int l = 2; l <= (int)((s).size()); l++) {
for (int i = 0; i <= (int)((s).size()) - l; i++) {
int j = i + l - 1;
if (s[i] == s[j]) {
if (order[i + 1][j - 1]) {
int mid = (i + j + 2) / 2;
if (rep[i][mid] >= l / 2)
order[i][j] = order[mid][j] + 1;
else {
order[i][j] = 1;
}
ans[order[i][j] - 1]++;
}
if (i + 1 == j) {
order[i][j] = 2;
ans[order[i][j] - 1]++;
}
}
}
}
for (int i = (int)((s).size()) - 2; i >= 0; i--) {
ans[i] = ans[i + 1] + ans[i];
};
for (int i = 0; i < (int)((s).size()); i++) cout << ans[i] << ' ';
;
cout << "\n";
}
| 1,900 | CPP |
n = int(input())
a = list(map(int, input().split()))
a.sort()
ans = 0
while len(a) > 0:
k = a.pop(0)
a = [i for i in a if i % k != 0]
ans += 1
print(ans)
| 800 | PYTHON3 |
n,m=map(int,input().split())
s=input()
for i in range(m):
l,r,c1,c2=input().split()
l=int(l)
r=int(r)
if c1 in s[l-1:r]:
s=s[:l-1]+s[l-1:r].replace(c1,c2)+s[r:]
print(s) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 10;
int n;
int arr[MAX];
int main() {
scanf("%d", &n);
for (int i = (0); i <= (n - 1); ++i) {
scanf("%d", &arr[i]);
}
int one_num = 0, two_num = 0, four_num = 0, three_num = 0;
int sum = 0;
for (int i = (0); i <= (n - 1); ++i) {
if (arr[i] == 4) ++four_num;
if (arr[i] == 3) ++three_num;
if (arr[i] == 1) ++one_num;
if (arr[i] == 2) ++two_num;
sum += arr[i];
}
if (sum < 3 || sum == 5) {
printf("-1\n");
return 0;
}
if (one_num == 0 && two_num == 0) {
printf("%d\n", 0);
} else if (two_num == 0) {
if (one_num == 1 && four_num && three_num == 0) {
printf("%d\n", 2);
} else {
printf("%d\n", 2 * (one_num / 3) + (one_num % 3));
}
} else if (one_num == 0) {
if (two_num == 1 && four_num) {
printf("%d\n", 1);
} else if (two_num == 1 && !four_num && three_num >= 2) {
printf("%d\n", 2);
} else {
if (two_num % 3 == 0) {
printf("%d\n", 2 * (two_num / 3));
} else if (two_num % 3 == 1) {
if (four_num) {
printf("%d\n", 2 * (two_num / 3) + 1);
} else {
printf("%d\n", 2 * (two_num / 3) + 2);
}
} else {
printf("%d\n", 2 * (two_num / 3) + 2);
}
}
} else {
if (one_num == two_num) {
printf("%d\n", one_num);
} else if (one_num > two_num) {
int tmp = one_num - two_num;
printf("%d\n", two_num + 2 * (tmp / 3) + tmp % 3);
} else {
int tmp = two_num - one_num;
int r = tmp % 3;
if (r == 0) {
printf("%d\n", one_num + 2 * (tmp / 3));
} else if (r == 1) {
if (four_num) {
printf("%d\n", one_num + 2 * (tmp / 3) + 1);
} else {
printf("%d\n", one_num + 2 * (tmp / 3) + 2);
}
} else {
printf("%d\n", one_num + 2 * (tmp / 3) + 2);
}
}
}
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
struct SegmentTree {
int n;
vector<int> Tree, LazyTree;
SegmentTree(int n) {
this->n = n;
Tree.assign(4 * n, 0);
LazyTree.assign(4 * n, 0);
}
void update(int c, int s, int e, int l, int r, int v) {
if (s > r or e < l) {
return;
} else if (s >= l and e <= r) {
Tree[c] += v;
LazyTree[c] += v;
} else {
int m = (s + e) / 2;
Tree[2 * c] += LazyTree[c];
LazyTree[2 * c] += LazyTree[c];
Tree[2 * c + 1] += LazyTree[c];
LazyTree[2 * c + 1] += LazyTree[c];
LazyTree[c] = 0;
update(2 * c, s, m, l, r, v);
update(2 * c + 1, m + 1, e, l, r, v);
Tree[c] = min(Tree[2 * c], Tree[2 * c + 1]);
}
}
int query(int c, int s, int e) {
if (Tree[c] >= 0) {
return -1;
} else if (s == e) {
return s;
} else {
Tree[2 * c] += LazyTree[c];
LazyTree[2 * c] += LazyTree[c];
Tree[2 * c + 1] += LazyTree[c];
LazyTree[2 * c + 1] += LazyTree[c];
LazyTree[c] = 0;
int m = (s + e) / 2;
if (Tree[2 * c + 1] < 0) {
return query(2 * c + 1, m + 1, e);
} else {
return query(2 * c, s, m);
}
}
}
} S(N);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
S.update(1, 1, N, 1, a[i], -1);
}
vector<int> b(m + 1);
for (int i = 1; i <= m; i++) {
cin >> b[i];
S.update(1, 1, N, 1, b[i], 1);
}
int q;
cin >> q;
while (q--) {
int t, i, x;
cin >> t >> i >> x;
if (t & 1) {
S.update(1, 1, N, 1, a[i], 1);
a[i] = x;
S.update(1, 1, N, 1, a[i], -1);
} else {
S.update(1, 1, N, 1, b[i], -1);
b[i] = x;
S.update(1, 1, N, 1, b[i], 1);
}
cout << S.query(1, 1, N) << '\n';
}
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1E9 + 7;
const double eps = 1e-6;
template <typename T>
T abs(T val) {
return val > 0 ? val : -val;
}
inline int max2(int a, int b) { return ((a > b) ? a : b); }
inline int min2(int a, int b) { return ((a < b) ? a : b); }
inline int max3(int a, int b, int c) { return max2(a, max2(b, c)); }
inline int min3(int a, int b, int c) { return min2(a, min2(b, c)); }
template <class T>
inline void read(T &ret) {
char c;
ret = 0;
while ((c = getchar()) < '0' || c > '9')
;
while (c >= '0' && c <= '9') ret = ret * 10 + (c - '0'), c = getchar();
}
template <class T>
inline void out(T x) {
if (x > 9) out(x / 10);
putchar(x % 10 + '0');
}
int n, w, h;
struct Node {
int x, y, g;
Node(int x = 0, int y = 0, int g = 0) : x(x), y(y), g(g) {}
} node[100005], ans[100005];
vector<int> stat[100005 << 1];
vector<int> xs, ys;
void solve() {
for (int i = 0; i <= 2E5; i++) stat[i].clear();
for (int i = 1; i <= n; i++) {
int tmp = node[i].x + node[i].y + 1E5;
stat[tmp].push_back(i);
}
for (int s = 0; s <= 2E5; s++) {
if (stat[s].size() == 0) continue;
xs.clear(), ys.clear();
for (auto id : stat[s]) {
if (node[id].g == 2)
ys.push_back(node[id].y);
else
xs.push_back(node[id].x);
}
sort(xs.begin(), xs.end());
sort(ys.begin(), ys.end());
sort(stat[s].begin(), stat[s].end(), [](int a, int b) {
if (node[a].g != node[b].g)
return (node[a].g == 2);
else
return node[a].g == 2 ? node[a].y > node[b].y : node[a].x < node[b].x;
});
for (int j = 0; j < xs.size(); j++) {
ans[stat[s][j]] = Node(xs[j], h);
}
for (int j = 0; j < ys.size(); j++) {
ans[stat[s][j + xs.size()]] = Node(w, ys[ys.size() - 1 - j]);
}
}
for (int i = 1; i <= n; ++i) printf("%d %d\n", ans[i].x, ans[i].y);
}
int main() {
while (~scanf("%d%d%d", &n, &w, &h)) {
int g, p, t;
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &g, &p, &t);
if (g == 1)
node[i] = Node(p, -t, g);
else
node[i] = Node(-t, p, g);
}
solve();
}
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[11111];
int out[11111];
int temp[11111];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = (1); i < (n); ++i) arr[i] = 1;
arr[n] = 0;
int qtd = 0;
int ct = 5;
while (arr[1] != n - 1) {
memcpy(temp, arr, sizeof arr);
out[qtd++] = n;
int j = n - 1;
int qt = 0;
while (j >= 1 && arr[j] == n - j) {
j--;
qt++;
out[qtd++] = n;
}
int act = qt;
while (j >= 1 && qt) {
arr[j] += temp[j + act];
out[qtd++] = j + act;
j--;
qt--;
}
while (j >= 1) {
arr[j] += temp[j + 1];
out[qtd++] = j + 1;
j--;
}
for (int i = qtd - 1; i >= 0; --i) printf("%d ", out[i]);
printf("\n");
k--;
qtd = 0;
ct--;
}
while (k--) {
for (int i = (0); i < (n); ++i) printf("%d ", n);
printf("\n");
}
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
int main() {
int n;
cin >> n;
int arr[n + 1];
for (int i = 1; i < n + 1; i++) cin >> arr[i];
int vis[10005] = {0};
int ans = 0;
for (int i = 1; i < n + 1; i++) {
if (vis[arr[i]] == 0) {
ans++;
vis[arr[i]] = 1;
vis[arr[arr[i]]] = 1;
}
}
cout << ans << endl;
return (0);
}
| 1,300 | CPP |
n=int(input())
a=[int(x) for x in input().split()]
for i in range(0,n):
minj=i
for j in range(i,n):
if a[minj]>a[j]:
minj=j
while minj>i:
print(minj,minj+1)
t=a[minj]
a[minj]=a[minj-1]
a[minj-1]=t
minj-=1
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int arr[101] = {0};
int main() {
int c = 0;
while (~scanf("%d", &c)) {
for (int i = 0; i < c; ++i) {
scanf("%d", &arr[i]);
}
sort(arr, arr + c);
if (c == 1) {
printf("%d\n", arr[0]);
} else {
printf("%d\n", arr[c / 2]);
}
}
}
| 800 | CPP |
#include <bits/stdc++.h>
int n;
struct camel {
int x, d;
inline bool operator<(const camel& a) const { return x < a.x; }
} c[105];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d", &c[i].x, &c[i].d);
std::sort(c, c + n);
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++)
if ((c[i].x + c[i].d == c[j].x) && (c[j].x + c[j].d == c[i].x)) {
puts("YES");
return 0;
}
puts("NO");
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int D = 50;
vector<int> g[N], rg[N];
vector<int> G[N];
vector<int> topSort, topSortSCC;
bool used[N];
int comp[N];
void dfsTopSort(int v) {
used[v] = true;
for (int u : g[v]) {
if (!used[u]) dfsTopSort(u);
}
topSort.push_back(v);
}
void dfsTopSortSCC(int v) {
used[v] = true;
for (int u : G[v]) {
if (!used[u]) dfsTopSortSCC(u);
}
topSortSCC.push_back(v);
}
void dfsSCC(int v) {
used[v] = true;
for (int u : rg[v]) {
if (!used[u]) {
comp[u] = comp[v];
dfsSCC(u);
}
}
}
int dp[N][D], calc[N][D];
int mark[N], dist[N], distR[N];
bool usedR[N];
int subG[N];
char s[N][D];
bool cycle[N][D];
int INF = 1e9;
vector<int> SCC[N];
void dfsIn(int v, int d) {
used[v] = true;
for (int u : g[v]) {
if (comp[u] != comp[v]) continue;
if (!used[u]) {
dist[u] = dist[v] + 1;
dfsIn(u, d);
}
for (int i = 0; i < d; ++i) cycle[v][(i + 1) % d] |= cycle[u][i];
}
}
void dfsInR(int v) {
usedR[v] = true;
for (int u : rg[v]) {
if (!usedR[u] && comp[u] == comp[v]) {
distR[u] = distR[v] + 1;
dfsInR(u);
}
}
}
int gcd(int a, int b) {
while (b != 0) {
a %= b;
swap(a, b);
}
return a;
}
int main() {
int n, m, d;
scanf("%d%d%d", &n, &m, &d);
while (m--) {
static int u, v;
scanf("%d%d", &u, &v);
--u;
--v;
g[u].push_back(v);
rg[v].push_back(u);
}
for (int v = 0; v < n; ++v) used[v] = false;
for (int v = 0; v < n; ++v) {
if (!used[v]) dfsTopSort(v);
}
reverse(topSort.begin(), topSort.end());
for (int v = 0; v < n; ++v) used[v] = false;
int sz = 0;
for (int v : topSort) {
if (!used[v]) {
mark[sz] = v;
comp[v] = sz++;
dfsSCC(v);
}
}
for (int v = 0; v < n; ++v) SCC[comp[v]].push_back(v);
for (int v = 0; v < n; ++v) {
for (int u : g[v])
if (comp[u] != comp[v]) G[comp[v]].push_back(comp[u]);
}
for (int v = 0; v < n; ++v) used[v] = false;
for (int c = 0; c < sz; ++c) {
if (!used[c]) dfsTopSortSCC(c);
}
reverse(topSortSCC.begin(), topSortSCC.end());
for (int v = 0; v < n; ++v) used[v] = usedR[v] = false;
mark[comp[0]] = 0;
for (int c : topSortSCC) {
static int s;
s = mark[c];
dist[s] = distR[s] = 0;
for (int v : SCC[c])
for (int i = 0; i < d; ++i) cycle[v][i] = false;
cycle[s][0] = true;
dfsIn(s, d);
dfsInR(s);
static int g;
g = d;
for (int i = 0; i < d; ++i)
if (cycle[s][i]) g = gcd(g, i);
subG[c] = g;
}
for (int c = 0; c < sz; ++c) {
for (int i = 0; i < d; ++i) {
dp[c][i] = -INF;
calc[c][i] = 0;
}
}
for (int v = 0; v < n; ++v) scanf("%s", s[v]);
for (int c = 0; c < sz; ++c) {
for (int i = 0; i < d; ++i) {
for (int v : SCC[c]) {
int cur = 0;
for (int x = 0; x < d; ++x)
cur += ((s[v][x] == '1') && (x - dist[v] - i) % subG[c] == 0);
calc[c][i] += cur > 0;
}
}
}
int c0 = comp[0];
for (int i = 0; i < d; ++i)
dp[c0][(i * subG[c0]) % d] = calc[c0][(i * subG[c0]) % d];
for (int c : topSortSCC) {
for (int v : SCC[c]) {
for (int u : rg[v]) {
if (comp[u] == comp[v]) continue;
for (int i = 0; i < d; ++i) {
for (int j = 0; j < d; ++j) {
int delt = (i - distR[v] - 1 - (j + dist[u]));
if (delt % subG[c] == 0 && delt % subG[comp[u]] == 0)
dp[c][i] = max(dp[c][i], dp[comp[u]][j] + calc[c][i]);
}
}
}
}
for (int i = subG[c]; i < d; ++i)
dp[c][i] = max(dp[c][i], dp[c][i - subG[c]]);
for (int i = d - subG[c] - 1; i >= 0; --i) dp[c][i] = dp[c][i + subG[c]];
}
int ans = 0;
for (int c = 0; c < sz; ++c) {
if ((int)G[c].size()) continue;
for (int i = 0; i < d; ++i) ans = max(ans, dp[c][i]);
}
printf("%d", ans);
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using max_heap = priority_queue<T>;
template <typename T>
ostream &operator<<(ostream &os, min_heap<T> H) {
while (!H.empty()) {
os << H.top() << " ";
H.pop();
}
os << "\n";
return os << "";
}
template <typename T>
ostream &operator<<(ostream &os, max_heap<T> H) {
while (!H.empty()) {
os << H.top() << " ";
H.pop();
}
os << "\n";
return os << "";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, pair<F, S> P) {
return os << P.first << " " << P.second;
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> arr) {
for (int i = 0; i < (int)arr.size(); i++) {
os << arr[i] << " ";
}
return os << "";
}
template <typename T>
ostream &operator<<(ostream &os, vector<vector<T>> matrix) {
os << "\n";
for (int i = 0; i < (int)matrix.size(); i++) {
for (int j = 0; j < (int)matrix[i].size(); j++) {
os << matrix[i][j] << " ";
}
os << "\n";
}
return os << "";
}
template <typename T>
ostream &operator<<(ostream &os, set<T> S) {
for (auto s : S) {
os << s << " ";
}
return os << "";
}
template <typename T>
ostream &operator<<(ostream &os, multiset<T> S) {
for (auto s : S) {
os << s << " ";
}
return os << "";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, map<F, S> M) {
os << "\n";
for (auto m : M) {
os << m << "\n";
}
return os << "";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, multimap<F, S> M) {
os << "\n";
for (auto m : M) {
os << m << "\n";
}
return os << "";
}
void solve() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> vals(n);
vector<vector<int>> arr(n, vector<int>(m));
for (int i = 0; i < (int)n; i++) {
for (int j = 0; j < (int)m; j++) {
cin >> arr[i][j];
}
vals[i] = {arr[i][0], i};
}
sort((vals).begin(), (vals).end());
vector<vector<int>> matrix(n, vector<int>(m));
for (int i = 0; i < (int)n; i++) {
matrix[i] = arr[vals[i].second];
}
vector<vector<int>> min_pre(n, vector<int>(m, 1e9));
vector<vector<int>> max_pre(n, vector<int>(m, 0));
vector<vector<int>> min_suf(n, vector<int>(m, 1e9));
vector<vector<int>> max_suf(n, vector<int>(m, 0));
for (int i = 0; i < (int)n; i++) {
min_pre[i][0] = matrix[i][0];
max_pre[i][0] = matrix[i][0];
for (int j = 1; j < (int)m; j++) {
min_pre[i][j] = min(matrix[i][j], min_pre[i][j - 1]);
max_pre[i][j] = max(matrix[i][j], max_pre[i][j - 1]);
}
}
for (int i = (int)n - 1; i >= 0; i--) {
min_suf[i][m - 1] = matrix[i][m - 1];
max_suf[i][m - 1] = matrix[i][m - 1];
for (int j = (int)m - 2; j >= 0; j--) {
min_suf[i][j] = min(min_suf[i][j + 1], matrix[i][j]);
max_suf[i][j] = max(max_suf[i][j + 1], matrix[i][j]);
}
}
auto sub = [&](int cut) -> int {
vector<int> min_left(n);
vector<int> max_left(n);
for (int i = 0; i < (int)n; i++) {
min_left[i] = min_pre[i][cut];
max_left[i] = max_pre[i][cut];
}
vector<int> min_right(n);
vector<int> max_right(n);
for (int i = 0; i < (int)n; i++) {
min_right[i] = min_suf[i][cut + 1];
max_right[i] = max_suf[i][cut + 1];
}
vector<int> mxlt(n);
mxlt[0] = max_left[0];
for (int i = 1; i < (int)n; i++) {
mxlt[i] = max(mxlt[i - 1], max_left[i]);
}
vector<int> mnrt(n);
mnrt[0] = min_right[0];
for (int i = 1; i < (int)n; i++) {
mnrt[i] = min(mnrt[i - 1], min_right[i]);
}
vector<int> mxrt(n);
mxrt[n - 1] = max_right[n - 1];
for (int i = (int)n - 2; i >= 0; i--) {
mxrt[i] = max(mxrt[i + 1], max_right[i]);
}
vector<int> mnlt(n);
mnlt[n - 1] = min_left[n - 1];
for (int i = (int)n - 2; i >= 0; i--) {
mnlt[i] = min(mnlt[i + 1], min_left[i]);
}
for (int i = 0; i < (int)n - 1; i++) {
int a = mxlt[i];
int b = mnrt[i];
int c = mnlt[i + 1];
int d = mxrt[i + 1];
if (c > a && b > d) {
return i;
}
}
return -1;
};
for (int i = 0; i < (int)m - 1; i++) {
int ans = sub(i);
if (ans != -1) {
cout << "YES"
<< "\n";
vector<char> color(n, 'R');
for (int j = 0; j <= (int)ans; j++) {
color[vals[j].second] = 'B';
}
for (int j = 0; j < (int)n; j++) {
cout << color[j];
}
cout << " ";
cout << i + 1 << "\n";
return;
}
}
cout << "NO"
<< "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int no_of_testcases = 1;
cin >> no_of_testcases;
for (int i = 1; i <= no_of_testcases; i++) {
solve();
}
return 0;
}
| 2,400 | CPP |
t = int(input())
for i in range(t):
n = int(input())
arr = list(map(int,input().split()))
c = 0
for j in range(0,n):
if(j>0 and arr[j-1]==j and arr[j]!=j+1 and c ==1):
c = 2
if(arr[j]!=j+1 and c==0 ):
c = 1
print(c)
| 1,500 | PYTHON3 |
import collections, heapq
def main():
T = int(input().strip())
for _ in range(T):
n = int(input().strip())
aStr = input().strip()
a = [int(x) for x in aStr.split(" ")]
s = sum(a)
zeros = a.count(0)
s += zeros
if s != 0:
print(zeros)
else:
print(zeros+1)
main() | 800 | PYTHON3 |
n,k = map(int,input().split())
res = list(map(int,input().split()))
res.sort()
i=0
while i<n and res[i]<0 and k>0:
res[i]=-res[i]
i+=1
k-=1
if k%2==1:
res.sort()
res[0]=-res[0]
print(sum(res)) | 1,200 | PYTHON3 |
n = list(map(int, input().strip().split(' ')))
a = int(n[1] - ((n[2]*(n[2]+1))/2)*n[0])
if a < 0:
print(abs(a))
else:
print(0)
| 800 | PYTHON3 |
import sys
input=sys.stdin.buffer.readline
t=int(input())
ans=list(map(int,input().split()))
ans=set(ans[1:])
t-=1
while t:
t-=1
arr=list(map(int,input().split()))
arr=set(arr[1:])
ans=ans.intersection(arr)
for x in ans:
print(x,end=' ')
| 800 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:136777216")
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
if (n + k < m)
puts("0");
else if (k >= m)
puts("1");
else {
double res = 1;
for (int i = n + 1; i <= n + k + 1; i++) res /= i;
for (int i = m - k - 1 + 1; i <= m; i++) res *= i;
printf("%.4lf\n", 1 - res);
}
return 0;
}
| 2,400 | CPP |
from sys import stdin
class V:
def __init__(self):
self.vertices = list()
self.vertices.append(tuple())
def add_interval(self, a, b):
edges = set()
for i in range (1, len(self.vertices)):
c = self.vertices[i][0]
d = self.vertices[i][1]
if (c < a and a < d) or (c < b and b < d):
edges.add(i)
if (a < c and c < b) or (a < d and d < b):
self.vertices[i][2].add(len(self.vertices))
tup = (a, b, edges)
self.vertices.append(tup)
def connected(self, s, d):
visited = [False]*len(self.vertices)
queue = []
queue.append(s)
visited[s] = True
while queue:
n = queue.pop(0)
if n == d:
return True
for vertex in self.vertices[n][2]:
if visited[vertex] == False:
queue.append(vertex)
visited[vertex] = True
return False
queries = int(input().strip())
graph = V()
for i in range(queries):
query = list(input().strip().split())
if int(query[0]) == 1:
graph.add_interval(int(query[1]), int(query[2]))
else:
if graph.connected(int(query[1]), int(query[2])):
print("YES")
else:
print ("NO") | 3,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
int n;
pair<long long, long long> a[maxn];
long long f[maxn][2 * maxn];
bool cmp(pair<long long, long long> x, pair<long long, long long> y) {
if (x.first != y.first) return x.first < y.first;
return x.second > y.second;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].second >> a[i].first;
a[i].second++;
}
for (int i = 1; i < 2 * maxn; i++) {
f[0][i] = 1000000009;
f[0][i] *= f[0][i];
}
for (int i = 1; i <= n; i++)
for (int j = 0; j <= n; j++) {
if (j >= a[i].second)
f[i][j] = min(f[i - 1][j - a[i].second] + a[i].first, f[i - 1][j]);
else
f[i][j] = min(f[i - 1][j], a[i].first);
}
cout << f[n][n] << endl;
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
void start() {}
void sober() {
long long int n;
cin >> n;
long long int* a = new long long int[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
int i = 0;
for (i = 0; i < n; i++) {
if (a[i] < i) {
i--;
break;
}
}
if (i >= 0) {
for (; i < n; i++) {
if (a[i] < n - i - 1) break;
}
if (i == n) {
cout << "Yes\n";
return;
}
cout << "No\n";
}
}
int main() {
start();
int t = 1;
cin >> t;
while (t--) sober();
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 100;
int ecnt, nxt[N << 1], to[N << 1], head[N], p[N], f[N], dep[N], pt[N << 1],
id[N << 1];
long long g[N << 1], val[N];
void addedge(int x, int y, long long w, int i) {
nxt[ecnt] = head[x];
head[x] = ecnt;
g[ecnt] = w;
id[ecnt] = i;
to[ecnt++] = y;
}
int find(int x) { return p[x] = (x == p[x] ? x : find(p[x])); }
void up(int x) { p[x] = f[x]; }
void dfs(int u) {
dep[u] = dep[f[u]] + 1;
for (int i = head[u]; ~i; i = nxt[i]) {
int v = to[i];
if (v == f[u]) continue;
f[v] = u;
val[v] = g[i];
pt[id[i]] = v;
dfs(v);
}
}
long long slove(int u, int v, long long w) {
u = find(u);
v = find(v);
while (u != v) {
if (dep[u] < dep[v]) swap(u, v);
w /= val[u];
u = find(f[u]);
if (w == 0) return w;
}
return w;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; ++i) head[i] = -1;
for (int i = 1; i < n; ++i) {
int u, v;
long long w;
scanf("%d%d%I64d", &u, &v, &w);
addedge(u, v, w, i);
addedge(v, u, w, i);
}
dfs(1);
for (int i = 0; i <= n; ++i) p[i] = i;
for (int i = 2; i <= n; ++i) {
if (val[i] == 1) up(i);
}
while (m--) {
int t, u, v;
long long w;
scanf("%d%d", &t, &u);
if (t == 1) {
scanf("%d%I64d", &v, &w);
printf("%I64d\n", slove(u, v, w));
} else {
scanf("%I64d", &w);
v = pt[u];
val[v] = w;
if (w == 1) up(v);
}
}
return 0;
}
| 2,400 | CPP |
t = int(input())
for _ in range(0,t):
s = list(map(int,input()))
one_indices = []
i = 0
while(i<len(s)):
if(s[i]==1):
one_indices.append(i)
i+=1
m = 0
for i in range(0,len(one_indices)-1):
m += one_indices[i+1]-one_indices[i]-1
print(m)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int i = 0; i < q; i++) {
long long n, k, a, b;
cin >> k >> n >> a >> b;
long long l = -1, r = n + 1, m;
while (r - l > 1) {
m = (r + l) / 2;
if (a * m + b * (n - m) < k)
l = m;
else
r = m;
}
cout << l << endl;
}
}
| 1,400 | CPP |
import sys
input = sys.stdin.readline
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input().strip()
def listStr():
return list(input().strip())
import collections as col
"""
"""
M = 10**9+7
def solve():
N = getInt()
S = listStr()
# this is the base case. With no characters,
dp = [[1,0,0,0]]
#0th element initialises, 1st is instances of a, 2nd is instances of ab, 3rd is instances of abc
#string is abc
#a: dp is [1,1,0,0]
#b: dp is [1,1,1,0]
#c: dp is [1,1,1,1]
#string is abbcbc
#[1,1,0,0], [1,1,1,0], [1,1,2,0], [1,1,2,2], [1,1,3,2], [1,1,3,5]
ref = {'a': 1, 'b': 2, 'c': 3}
#string is ac?b?c
#[1,1,0,0], [1,1,0,0], [3,4,1,0], [3,4,5,0], [9,15,19,5], [9,15,19,24]
for s in S:
tmp = list(dp[-1])
if s == '?':
for i in range(4):
#we have all the existing possibilities multiplied by 3
tmp[i] *= 3
tmp[i] %= M
for i in range(1,4):
#each possible value a,b,c, we also add the previous number ending with letter prior to that
tmp[i] += dp[-1][i-1]
tmp[i] %= M
else:
x = ref[s]
#same logic as above but for only one value
tmp[x] += dp[-1][x-1]
tmp[x] %= M
dp.append(tmp)
#print(dp)
return dp[-1][3]
print(solve())
| 2,000 | PYTHON3 |
n=int(input())
m=int(input())
if n>=27:
print(m)
else:
k=(2**n)
print((m%k)) | 900 | PYTHON3 |
a,b,c=map(int,input().split())
ans=0
mod=998244353
fact=[1]
z=max(a,b,c)
for i in range(1,z+1):
fact.append((fact[-1]*i)%mod)
z=min(a,b)
ans1=0
def power(i,a,b):
return pow(i,a,b)
for i in range(z+1):
ans1=(ans1+(fact[a]*fact[b]*power(fact[i],mod-2,mod)*power(fact[i],mod-2,mod)*power(fact[a-i],mod-2,mod)*power(fact[b-i],mod-2,mod)*fact[i])%mod)%mod
z=min(b,c)
ans2=0
for i in range(z+1):
ans2=(ans2+(fact[c]*fact[b]*power(fact[i],mod-2,mod)*power(fact[i],mod-2,mod)*power(fact[c-i],mod-2,mod)*power(fact[b-i],mod-2,mod)*fact[i])%mod)%mod
z=min(a,c)
ans3=0
for i in range(z+1):
ans3=(ans3+(fact[c]*fact[a]*power(fact[i],mod-2,mod)*power(fact[i],mod-2,mod)*power(fact[c-i],mod-2,mod)*power(fact[a-i],mod-2,mod)*fact[i])%mod)%mod
print((ans1*ans2*ans3)%mod) | 1,800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[105];
int minn = (1 << 30), maxx = 0;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
maxx = max(maxx, a[i]);
}
for (int i = 1; i <= maxx + m + 3; i++) {
int cnt = 0;
bool flag = 0;
for (int j = 1; j <= n; j++) {
if (a[j] > i) {
flag = 1;
break;
}
cnt += i - a[j];
}
if (flag) continue;
if (cnt >= m) {
cout << i << " ";
break;
}
}
cout << maxx + m;
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 35;
double dp[205][N][N];
int n, k, a[N];
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
memset(dp, 0, sizeof(dp));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (a[i] > a[j])
dp[0][i][j] = 1.0;
else
dp[0][i][j] = 0.0;
}
double tot = n * (n + 1) / 2.0;
for (int p = 0; p < k; p++) {
for (int l = 0; l < n; l++) {
for (int r = l; r < n; r++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int ii = i, jj = j;
if (i >= l && i <= r) ii = r - i + l;
if (j >= l && j <= r) jj = r - j + l;
dp[p + 1][i][j] += dp[p][ii][jj] / tot;
}
}
}
}
}
double ans = 0;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
ans += dp[k][i][j];
}
printf("%.10f\n", ans);
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 17;
vector<int> lucky;
int Q[2 * N];
void add(int pos, int x) {
pos += N;
while (pos) {
Q[pos] += x;
pos >>= 1;
}
}
int sum(int L, int R) {
int res = 0;
for (L += N, R += N; L < R; L >>= 1, R >>= 1) {
if (L & 1) res += Q[L++];
if (R & 1) res += Q[--R];
}
return res;
}
int find(int x) {
if (Q[1] < x) return N - 1;
int v = 1;
while (v < N) {
if (Q[2 * v] >= x)
v = 2 * v;
else {
x -= Q[2 * v];
v = 2 * v + 1;
}
}
return v - N;
}
int n, m;
int a[N];
char buf[1 << 4];
vector<int> T[N], D[N];
vector<pair<int, int> > Ch[30];
int res[N];
int main() {
lucky.push_back(4);
lucky.push_back(7);
for (int i = 0; i < lucky.size(); ++i) {
int x = lucky[i] * 10 + 4;
int y = lucky[i] * 10 + 7;
if (x <= (int)1e4) lucky.push_back(x);
if (y <= (int)1e4) lucky.push_back(y);
}
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
vector<int> qL, qR, q;
for (int i = 0; i < m; ++i) {
scanf("%s", buf);
int L, R, d;
scanf("%d%d", &L, &R);
L--;
if (buf[0] == 'a') {
scanf("%d", &d);
T[L].push_back(i);
D[L].push_back(d);
T[R].push_back(i);
D[R].push_back(-d);
} else {
qL.push_back(L);
qR.push_back(R);
q.push_back(i);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < T[i].size(); ++j) add(T[i][j], D[i][j]);
for (int j = 0; j < lucky.size(); ++j) {
if (lucky[j] < a[i]) continue;
int pos = find(lucky[j] - a[i]);
if (sum(0, pos + 1) != lucky[j] - a[i]) continue;
Ch[j].push_back(make_pair(pos, i));
Ch[j].push_back(make_pair(find(lucky[j] - a[i] + 1), i));
}
}
for (int i = 0; i < 30; ++i) {
memset(Q, 0, sizeof(Q));
sort(Ch[i].begin(), Ch[i].end());
int p = 0;
for (int j = 0; j < q.size(); ++j) {
while (p < Ch[i].size() && Ch[i][p].first <= q[j]) {
if (sum(Ch[i][p].second, Ch[i][p].second + 1) == 1)
add(Ch[i][p].second, -1);
else
add(Ch[i][p].second, 1);
++p;
}
res[q[j]] += sum(qL[j], qR[j]);
}
}
for (int i = 0; i < q.size(); ++i) printf("%d\n", res[q[i]]);
return 0;
}
| 2,400 | CPP |
def solve(A,B):
ans = 1
if A < B:
for i in range(1,A+1):
ans *= i
else:
for i in range(1,B+1):
ans *= i
return ans
A, B = [int(c) for c in input().split()]
print(solve(A,B))
| 800 | PYTHON3 |
n,m,a = map(int, input().split())
if(n%a == 0):
x = n//a
else:
x = n//a + 1
if(m%a == 0):
y = m//a
else:
y = m//a + 1
print(y*x)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long Inf = 1ll << 60ll;
namespace io {
char buf[(1 << 23)], *p1 = buf, *p2 = buf, c;
int f;
template <typename T>
T read() {
T x = 0;
f = 0;
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, (1 << 23), stdin), p1 == p2)
? EOF
: *p1++);
while (!isdigit(c))
(c == '-') && (f = 1),
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, (1 << 23), stdin),
p1 == p2)
? EOF
: *p1++);
while (isdigit(c))
x = x * 10 + (c & 15),
c = (p1 == p2 &&
(p2 = (p1 = buf) + fread(buf, 1, (1 << 23), stdin), p1 == p2)
? EOF
: *p1++);
return f ? -x : x;
}
} // namespace io
const int N = 1000005;
int pre[N], suf[N], a[N], b[N];
int ans[N];
void solve(int la, int ra, int lb, int rb) {
if (lb > rb) return;
int mid = lb + rb >> 1;
pre[la] = 0;
for (int i = la + 1; i <= ra; ++i) pre[i] = pre[i - 1] + (a[i - 1] > b[mid]);
suf[ra] = 0;
for (int i = ra - 1; i >= la; --i) suf[i] = suf[i + 1] + (a[i] < b[mid]);
int mn = inf, pos = -1;
for (int i = la; i <= ra; ++i) {
if (pre[i] + suf[i] < mn) {
mn = pre[i] + suf[i];
pos = i;
}
}
ans[mid] = pos;
solve(la, pos, lb, mid - 1);
solve(pos, ra, mid + 1, rb);
}
int c[N * 2];
bool cmp(int A, int B) { return c[A] != c[B] ? c[A] > c[B] : A > B; }
int t[N * 2], tot;
void update(int x, int v) {
while (x <= tot) {
t[x] += v;
x += x & (-x);
}
}
int query(int x) {
int res = 0;
while (x) {
res += t[x];
x -= x & (-x);
}
return res;
}
int n, m, id[N * 2];
int main() {
int T = io::read<int>();
while (T--) {
n = io::read<int>();
m = io::read<int>();
for (int i = 1; i <= n; ++i) a[i] = io::read<int>();
for (int i = 1; i <= m; ++i) b[i] = io::read<int>();
sort(b + 1, b + m + 1);
solve(1, n + 1, 1, m);
int it = 0;
tot = 0;
for (int i = 1; i <= n; ++i) {
while (it < m && ans[it + 1] <= i) {
++it;
c[++tot] = b[it];
}
c[++tot] = a[i];
}
while (it < m) {
++it;
c[++tot] = b[it];
}
for (int i = 1; i <= tot; ++i) id[i] = i, t[i] = 0;
sort(id + 1, id + tot + 1, cmp);
long long res = 0;
for (int i = 1; i <= tot; ++i) {
update(id[i], 1);
res += query(id[i] - 1);
}
printf("%lld\n", res);
}
return 0;
}
| 2,300 | CPP |
a=int(input())
b=int(input())
c=int(input())
list=[]
list.append(a+(b*c))
list.append((a+b)*c)
list.append((a*b)+c)
list.append(a*(b+c))
list.append(a+b+c)
list.append(a*b*c)
list.sort()
print(list[5]) | 1,000 | PYTHON3 |
import sys
text: str = sys.stdin.readline()
last = text[0]
print(last, end='')
for pos, character in enumerate(text[1:], start=1):
if character != last:
last = character
else:
if last == 'a':
if pos == (len(text) - 1) or text[pos + 1] != 'b':
last = 'b'
else:
last = 'c'
elif last == 'b':
if pos == (len(text) - 1) or text[pos + 1] != 'a':
last = 'a'
else:
last = 'c'
else:
if pos == (len(text) - 1) or text[pos + 1] != 'b':
last = 'b'
else:
last = 'a'
print(last, end='')
| 1,300 | PYTHON3 |
t = int(input().strip())
for _ in range(t):
#a,b = map(int,input().strip().split())
n = int(input().strip())
if n == 1:
print(-1)
else:
#nums = [int(i) for i in input().strip().split()]
print('2' + ''.join('7' for i in range(n-1)))
| 1,000 | PYTHON3 |
t=int(input())
a=""
l=[];
for i in range(t):
b=int(input())
a=list(input())
n=0;
while(1):
k=0
n=n+1
j=0
while(j<=b-2):
if(a[j]=='A' and a[j+1]=='P'):
a[j+1]=a[j]
j=j+2
k=1
else:
j=j+1
if(k==0):
l.append(n-1)
break
for i in l:
print(i)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
int n, t, sz[200010], cen;
vector<int> g[200010], v;
bool mark[200010];
int dfs(int pos, int par) {
sz[pos] = (int)mark[pos];
bool ok = true;
for (int i = 0; i < g[pos].size(); i++)
if (g[pos][i] != par) {
sz[pos] += dfs(g[pos][i], pos);
if (sz[g[pos][i]] > t) ok = false;
}
if (ok && sz[pos] >= t) cen = pos;
return sz[pos];
}
void dfs2(int pos, int par) {
if (mark[pos]) v.push_back(pos);
for (int i = 0; i < g[pos].size(); i++)
if (g[pos][i] != par) dfs2(g[pos][i], pos);
}
int main() {
cin >> n >> t;
int x, y;
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 0; i < t + t; i++) {
scanf("%d", &x);
mark[x] = true;
}
dfs(1, 0);
for (int i = 0; i < g[cen].size(); i++) dfs2(g[cen][i], cen);
if (mark[cen]) v.push_back(cen);
cout << 1 << endl << cen << endl;
for (int i = 0; i < t; i++) printf("%d %d %d\n", v[i], v[i + t], cen);
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, t[1010], id[1010], vis[1010];
struct node {
int id, p, d;
} a[1010];
bool cmp1(node a, node b) { return a.d > b.d; }
bool cmp2(node a, node b) { return a.id < b.id; }
int main() {
scanf("%d%d%d", &n, &x, &y);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].p, &a[i].d);
a[i].id = i;
}
sort(a + 1, a + 1 + n, cmp1);
int now = x, d = 0, be = 0, cnt = 0;
for (int i = 0;; i++) {
now -= d;
now += y;
now = min(now, x);
if (now <= 0) {
printf("YES\n%d %d\n", i, cnt);
for (int j = 0; j < cnt; j++) printf("%d %d\n", t[j], id[j]);
return 0;
}
for (int j = 1; j <= n; j++) {
if (vis[j] || a[j].p * x < now * 100) continue;
vis[j] = 1;
d += a[j].d;
t[cnt] = i;
id[cnt++] = a[j].id;
break;
}
if (be == d && d <= y) break;
be = d;
}
printf("NO\n");
return 0;
}
| 1,800 | CPP |
a, b, c, d, e, f = map(int, input().split())
x = (a << 1) - 1
s = 0
for i in range(b + c):
if i < b:
x += 1
elif i > b:
x -= 1
if i < f:
x += 1
elif i > f:
x -= 1
s += x
print(s)
| 1,600 | PYTHON3 |
#
# Author: eloyhz
# Date: Sep/11/2020
#
#
#
#
if __name__ == '__main__':
colors = 'ROYGBIV'
n = int(input())
m = n % 7
d = n // 7
ans = ''
if m == 1 or m == 2 or m == 3:
ans = colors[:4] + colors[:m] + colors[4:]
else:
ans = colors + colors[:m]
ans += colors * (d - 1)
print(ans)
| 1,200 | PYTHON3 |
import sys
inf = float("inf")
# sys.setrecursionlimit(10000000)
# abc='abcdefghijklmnopqrstuvwxyz'
# abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod, MOD = 1000000007, 998244353
# words = {1:'one',2:'two',3:'three',4:'four',5:'five',6:'six',7:'seven',8:'eight',9:'nine',10:'ten',11:'eleven',12:'twelve',13:'thirteen',14:'fourteen',15:'quarter',16:'sixteen',17:'seventeen',18:'eighteen',19:'nineteen',20:'twenty',21:'twenty one',22:'twenty two',23:'twenty three',24:'twenty four',25:'twenty five',26:'twenty six',27:'twenty seven',28:'twenty eight',29:'twenty nine',30:'half'}
# vow=['a','e','i','o','u']
# dx,dy=[0,1,0,-1],[1,0,-1,0]
# import random
# from collections import deque, Counter, OrderedDict,defaultdict
# from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
# from math import ceil,floor,log,sqrt,factorial,pi,gcd
# from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()
n = int(input())
Arr = get_array()
Arr.sort()
flag = 0
for i in range(n-1,-1,-1):
if Arr[i]>1:
Arr[i] = 1
flag = 1
break
if flag==1:
Arr.sort()
print(*Arr)
else:
Arr[-1] = 2
Arr.sort()
print(*Arr)
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "URDL";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
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) { return y ? gcd1(y, x % y) : x; }
int len, a[100035];
int dp[100035][105], sdp[100035], ps[100035][105];
bool full(int x, int l, int r) {
return ps[r][x] - ps[l - 1][x] + ps[r][0] - ps[l - 1][0] == r - l + 1;
}
void fmain(int tid) {
scanf("%d%d%d", &n, &k, &len);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d", a + i);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
for (int(j) = 0; (j) < (int)(k + 1); (j)++) ps[i][j] += ps[i - 1][j];
int t = a[i] == -1 ? 0 : a[i];
ps[i][t]++;
}
sdp[0] = 1;
for (int(i) = 1; (i) <= (int)(n); (i)++) {
if (a[i] == -1) {
for (int(j) = 1; (j) <= (int)(k); (j)++) {
addmod(dp[i][j], sdp[i - 1]);
}
} else {
addmod(dp[i][a[i]], sdp[i - 1]);
}
if (i >= len) {
for (int(j) = 1; (j) <= (int)(k); (j)++)
if (full(j, i - len + 1, i)) {
addmod(dp[i][j],
(998244353 - sdp[i - len] + dp[i - len][j]) % 998244353);
}
}
for (int(j) = 1; (j) <= (int)(k); (j)++) addmod(sdp[i], dp[i][j]);
}
printf("%d\n", sdp[n]);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 2,400 | CPP |
n,k=map(int,input().split())
string=input()
lists=list(input().split(" "))
ans=0
index=0
for i in range(n):
if string[i] in lists:
index+=1
if not string[i] in lists:
if index>0:
ans+=index*(index+1)//2
index=0
elif index==0:
index=0
if i==n-1:
ans+=index*(index+1)//2
print(ans) | 1,200 | PYTHON3 |
n,k=map(int,input().split())
id=list(map(int,input().split()))
ids=set()
from collections import deque
c=deque()
lol=set()
for j in range(n):
m1=len(ids)
ids.add(id[j])
m2=len(ids)
if(m2>m1):
c.appendleft(id[j])
if(len(c)>k):
f=c.pop()
lol.add(f)
#print(c)
#print("LOL:",lol)
ids=ids.difference(lol)
#print(c)
#print(ids)
print(len(c))
for j in range(len(c)):
print(c[j],end=" ")
print("") | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
auto rng = bind(uniform_int_distribution<int>(1, 1000), mt19937(time(0)));
template <class T>
bool umin(T &a, const T &b) {
return (a > b ? a = b, 1 : 0);
}
template <class T>
bool umax(T &a, const T &b) {
return (a < b ? a = b, 1 : 0);
}
const int M = 998244353;
void add(int &a, int b) {
a += b;
if (a >= M)
a -= M;
else if (a < 0)
a += M;
}
int mult(int a, int b) { return 1ll * a * b % M; }
int binpow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = mult(ans, a);
b >>= 1;
a = mult(a, a);
}
return ans;
}
const int N = 3e5 + 1;
bool used[N];
int lft[N], rgt[N];
bool isr[N];
vector<int> pos[N];
bool bad[N];
vector<int> lengs;
int ways[N];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, m, k;
cin >> n >> m >> k;
vector<vector<int>> vc(n, vector<int>());
for (int i = 0; i < n; i++) {
int c;
cin >> c;
vector<int> a(c);
for (int j = 0; j < c; j++) {
cin >> a[j], used[a[j]] = 1;
if ((int)pos[a[j]].size() && pos[a[j]].back() == i) {
bad[a[j]] = 1;
}
pos[a[j]].push_back(i);
}
vc[i] = a;
for (int j = 0; j < c; j++) {
if (j > 0) {
if (!lft[a[j]] || lft[a[j]] == a[j - 1]) {
lft[a[j]] = a[j - 1];
} else
bad[a[j]] = 1;
}
if (j + 1 < c) {
if (!rgt[a[j]] || rgt[a[j]] == a[j + 1]) {
rgt[a[j]] = a[j + 1];
continue;
} else
bad[a[j]] = 1;
}
}
}
queue<int> q;
for (int i = 1; i <= k; i++) {
if (bad[i]) q.push(i);
}
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto &j : pos[x]) {
if (isr[j]) continue;
isr[j] = 1;
for (auto &v : vc[j]) {
if (!bad[v]) {
bad[v] = 1;
q.push(v);
}
}
}
}
for (int i = 1; i <= k; i++) {
if (bad[i]) continue;
if (!lft[i]) {
int v = i;
int cnt = 0;
while (v) {
cnt++;
v = rgt[v];
}
lengs.push_back(cnt);
ways[cnt]++;
}
}
if (!(int)lengs.size()) {
cout << 0;
return 0;
}
vector<int> dp(m + 1, 0);
sort(lengs.begin(), lengs.end());
lengs.erase(unique(lengs.begin(), lengs.end()), lengs.end());
dp[0] = 1;
for (int i = 1; i <= m; i++) {
for (auto &j : lengs) {
if (i >= j) add(dp[i], mult(ways[j], dp[i - j]));
}
}
cout << dp[m];
return 0;
}
| 2,700 | CPP |
def read_array():
s = input()
return [int(x) for x in s.split(' ')]
num = read_array()
n = num[0]
m = num[1]
a = num[2]
q = 0
q1 = 0
if n % a != 0:
q = n // a + 1
else:
q = n // a
if m % a != 0:
q1 = m // a + 1
else:
q1 = m // a
print(q * q1)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200008;
const int mo = 1e9 + 7;
int n, cur, tmp;
int a[2][N];
void solve(int len) {
cur ^= 1;
for (int i = 1; i <= len; ++i) a[cur][i] = 0;
for (int j = 1; j <= len; ++j) {
++tmp;
if (tmp & 1)
a[cur][j] = a[cur ^ 1][j] + a[cur ^ 1][j + 1];
else
a[cur][j] = a[cur ^ 1][j] + mo - a[cur ^ 1][j + 1];
a[cur][j] %= mo;
}
}
int mi[N], ni[N];
int power(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = (long long)res * x % mo;
x = (long long)x * x % mo;
y >>= 1;
}
return res;
}
int C(int x, int y) { return (long long)mi[x] * ni[y] % mo * ni[x - y] % mo; }
int main() {
mi[0] = ni[0] = 1;
for (int i = 1; i < N; ++i)
mi[i] = (long long)mi[i - 1] * i % mo, ni[i] = power(mi[i], mo - 2);
cin.sync_with_stdio(0);
cin >> n;
cur = tmp = 0;
for (int i = 1; i <= n; ++i) cin >> a[cur][i];
if (n <= 4) {
for (int i = 2; i <= n; ++i) solve(n - i + 1);
cout << a[cur][1] << endl;
return 0;
}
int num = (n - 1) / 4 * 4 + 1;
for (int i = n; i > num; --i) solve(i - 1);
int ans = 0;
for (int i = 1; i <= num; i += 2) {
int j = (i + 1) / 2;
ans = (ans + (long long)C((num - 1) / 2, j - 1) * a[cur][i]) % mo;
}
cout << ans << endl;
}
| 2,200 | CPP |
cnt1, cnt2, x, y = map(int, input().split())
l = 0
r = (cnt1 // (x - 1) + 1) * x + (cnt2 // (y - 1) + 1) * y + 5
while r - l != 1:
m = l + (r - l) // 2
t_cnt1 = m // y - m // (x * y)
t_cnt2 = m // x - m // (x * y)
if max(0, cnt1 - t_cnt1) + max(0, cnt2 - t_cnt2) <= m - (m // x + m // y - m // (x * y)):
r = m
else:
l = m
print(r)
| 1,800 | PYTHON3 |
for i in range(int(input())):
j = list(map(int,input().split(' ')))
a = ((24-j[0])*60)-j[1]
#min = a*60
#ans = min-j[1]
print(a) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> v;
int main() {
ios_base::sync_with_stdio(0), ios::sync_with_stdio(0), cin.tie(0),
cout.tie(0);
;
int l, n;
cin >> l >> n;
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
v.push_back({x, y});
}
int mx = v[0].first - 1 + v[0].second;
mx = max(mx, l - v.back().first + v.back().second);
for (int i = 0; i < n - 1; ++i) {
if ((v[i + 1].first - v[i].first) < abs(v[i + 1].second - v[i].second))
return cout << "IMPOSSIBLE\n", 0;
int val = v[i].second;
mx = max(mx, v[i].second);
for (int j = v[i].first + 1; j < v[i + 1].first; ++j) {
int _1 = val + 1;
int _2 = val;
int _3 = val - 1;
int dis = v[i + 1].first - j;
if (abs(_1 - v[i + 1].second) <= dis) {
mx = max(mx, _1);
val = _1;
} else if (abs(_2 - v[i + 1].second) <= dis)
val = _2;
else if (_3 >= 0 && abs(_3 - v[i + 1].second) <= dis)
val = _3;
else
return cout << "IMPOSSIBLE\n", 0;
}
}
cout << mx << "\n";
return 0;
}
| 1,600 | CPP |
n=int(input())
A=list(map(int,input().split()))
B=[int(x) for x in A if x%2==0]
if len(B)==1:
print(A.index(B[0])+1)
else:
C=[int(x) for x in A if x not in B]
print(A.index(C[0])+1) | 1,300 | PYTHON3 |
import math
def get_prime_set(ub):
from itertools import chain
from math import sqrt
if ub < 4:
return ({}, {}, {2}, {2, 3})[ub]
ub, ub_sqrt = ub+1, int(sqrt(ub))+1
primes = {2, 3} | set(chain(range(5, ub, 6), range(7, ub, 6)))
du = primes.difference_update
for n in chain(range(5, ub_sqrt, 6), range(7, ub_sqrt, 6)):
if n in primes:
du(range(n*3, ub, n*2))
return primes
if __name__ == "__main__":
n, b = map(int, input().split())
primes = get_prime_set(int(math.sqrt(b))+1)
pf = dict()
for p in filter(lambda x: b % x == 0, primes):
pf[p] = 0
while b % p == 0:
b //= p
pf[p] += 1
if b > 1:
pf[b] = 1
ans = 10**18
for p, count in pf.items():
subtotal = 0
_p = p
while _p <= n:
subtotal += n // _p
_p *= p
subtotal //= count
if ans > subtotal:
ans = subtotal
print(ans) | 1,700 | PYTHON3 |
Subsets and Splits