solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, a[1100][1100], b[1100][1100], op, x, y, L[1100][1100],
R[1100][1100], L1[1100][1100], R1[1100][1100], mm1[1100], mm2[1100];
void recalc(int n, int m, int a[1100][1100], int x, int L[1100][1100],
int R[1100][1100]) {
int pre = m + 1;
for (int i = m; i; i--) {
if (!a[x][i]) pre = i;
R[x][i] = pre;
}
pre = 0;
for (int i = 1; i <= m; i++) {
if (!a[x][i]) pre = i;
L[x][i] = pre;
}
}
int query(int n, int m, int x, int y, int L[1100][1100], int R[1100][1100]) {
int ans = 0;
mm1[x] = mm2[x] = R[x][y];
for (int i = x + 1; i <= n; i++) mm2[i] = min(mm2[i - 1], R[i][y]);
for (int i = x - 1; i; i--) mm1[i] = min(mm1[i + 1], R[i][y]);
int q = 1, h = n;
for (int i = y; i <= R[x][y]; i++) {
while (mm1[q] < i) q++;
while (mm2[h] < i) h--;
ans = max(ans, (h - q + 1) * (i - y));
}
mm1[x] = mm2[x] = L[x][y];
for (int i = x + 1; i <= n; i++) mm2[i] = max(mm2[i - 1], L[i][y]);
for (int i = x - 1; i; i--) mm1[i] = max(mm1[i + 1], L[i][y]);
q = 1, h = n;
for (int i = y; i >= L[x][y]; i--) {
while (mm1[q] > i) q++;
while (mm2[h] > i) h--;
ans = max(ans, (h - q + 1) * (y - i));
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]), b[j][i] = a[i][j];
for (int i = 1; i <= n; i++) recalc(n, m, a, i, L, R);
for (int i = 1; i <= m; i++) recalc(m, n, b, i, L1, R1);
while (q--) {
scanf("%d%d%d", &op, &x, &y);
if (op == 1)
a[x][y] = 1 - a[x][y], b[y][x] = 1 - b[y][x], recalc(n, m, a, x, L, R),
recalc(m, n, b, y, L1, R1);
else
printf("%d\n", max(query(n, m, x, y, L, R), query(m, n, y, x, L1, R1)));
}
}
| 2,000 | CPP |
char = str(input())
result = char[0].upper()+char[1:]
print(result)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
int a[200005], bil[200005];
long long n, jumlah, b;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
jumlah += a[i];
}
for (int i = 1; i <= n; i++) {
if ((jumlah - a[i]) / (n - 1) == a[i] && (jumlah - a[i]) % (n - 1) == 0) {
++b;
bil[b] = i;
}
}
printf("%d\n", b);
for (int i = 1; i <= b; ++i) {
if (i == b) {
printf("%d\n", bil[i]);
} else {
printf("%d ", bil[i]);
}
}
}
| 1,200 | CPP |
n=int(input())
a=input().split()
s=input()
if("1" not in s):
print(0)
else:
ls=[0 for i in range(n)]
prefix=[0 for i in range(n)]
valid=[0 for i in range(n)]
for i in range(n):
if(i==0):
if(s[i]=="1"):
ls[0]=int(a[i])
valid[i]=1
prefix[0]=int(a[i])
else:
if(s[i]=="1"):
ls[i]=ls[i-1]+int(a[i])
valid[i]=1
else:
ls[i]=ls[i-1]
prefix[i]=prefix[i-1]+int(a[i])
new_ls=[ls[n-1]]
for i in range(1,n):
if(valid[i]):
new_ls.append(prefix[i-1]+ls[n-1]-ls[i])
print(max(new_ls)) | 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 203600;
int a[N], b[N], n;
int pos[N];
bool vis[N];
int main() {
while (cin >> n) {
memset(vis, 0, sizeof(vis));
for (int i = (1); i <= (int)(n); i++) cin >> a[i];
for (int i = (1); i <= (int)(n); i++) {
int first;
cin >> first;
b[first] = i;
}
for (int i = (1); i <= (int)(n); i++) a[i] = b[a[i]];
for (int i = (1); i <= (int)(n); i++) pos[a[i]] = i;
int ans = 0;
int s = 1, e = n;
for (int s = 1, i = 1; s <= n; s++) {
if (vis[s]) continue;
if (a[i] == s) {
i++;
continue;
}
int p = pos[s];
while (e >= p) {
ans++;
vis[a[e]] = true;
e--;
}
}
cout << ans << endl;
}
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
namespace ywy {
inline int get() {
int n = 0;
char c;
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9') break;
if (c == '-') goto s;
}
n = c - '0';
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
n = n * 10 + c - '0';
else
return (n);
}
s:
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
n = n * 10 - c + '0';
else
return (n);
}
}
typedef struct _n {
int s;
int t;
int v;
int lim;
} node;
node ints[300001];
int pos[444];
int mx[444][444];
inline int Tanxin(int x, long long v) {
if (mx[ints[x].s][ints[x].t] * (long long)ints[x].v > v) return (0);
int cur = ints[x].s;
int tot = 0;
while (cur != ints[x].t && tot <= ints[x].lim) {
if ((long long)ints[x].v * (pos[ints[x].t] - pos[cur]) <= v) return (1);
int ans = cur + 1, l = cur + 1, r = ints[x].t - 1;
while (l <= r) {
int mid = (l + r) >> 1;
if ((long long)ints[x].v * (pos[mid + 1] - pos[cur]) > v)
ans = mid, r = mid - 1;
else
l = mid + 1;
}
tot++;
cur = ans;
}
if (tot > ints[x].lim) return (0);
return (1);
}
void ywymain() {
srand(19260817);
int n = get(), m = get();
for (register int i = 1; i <= n; i++) pos[i] = get();
for (register int i = 1; i <= m; i++) {
ints[i].s = get();
ints[i].t = get();
ints[i].v = get();
ints[i].lim = get();
}
for (register int i = 1; i <= n; i++) {
int maxn = 0;
for (register int j = i + 1; j <= n; j++)
maxn = max(maxn, pos[j] - pos[j - 1]), mx[i][j] = maxn;
}
random_shuffle(ints + 1, ints + 1 + m);
long long maxn = 0;
for (register int i = 1; i <= m; i++) {
if (Tanxin(i, maxn)) continue;
long long ans = ints[i].v * (long long)(pos[ints[i].t] - pos[ints[i].s]);
long long l = max((long long)mx[ints[i].s][ints[i].t] * ints[i].v,
maxn + 1),
r = ans;
while (l <= r) {
long long mid = (l + r) >> 1;
if (Tanxin(i, mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
maxn = max(maxn, ans);
}
cout << maxn << endl;
}
} // namespace ywy
int main() {
ywy::ywymain();
return (0);
}
| 2,400 | CPP |
n=int(input())
m=input().split()
for i in range(len(m)):
m[i]=int(m[i])
mi=min(m)
ma=max(m)
if (ma-mi)%2==0:
d=(ma-mi)//2
l=set()
l.add(mi+d)
for i in m:
if i<mi+d:
l.add(i+d)
elif i>mi+d:
l.add(i-d)
if len(l)<=1:
print(d)
exit(0)
l=set()
d=ma-mi
l.add(ma)
for i in m:
if i<ma:
l.add(i+d)
if len(l)<=1:
print(d)
exit(0)
print(-1)
| 1,200 | PYTHON3 |
from sys import stdin
input = stdin.readline
t=int(input())
for i in range(t):
n=int(input())
for i in range(n):
print(4*n-2*i,end=" ")
print() | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int ansA = 0, ansB = 0;
int MAIN() {
int n;
cin >> n;
vector<int> mids;
for (int i = 1; i <= n; i++) {
int s;
cin >> s;
for (int j = 1; j <= s; j++) {
int t;
cin >> t;
if (s % 2 == 0) {
if (j <= s / 2)
ansA += t;
else
ansB += t;
} else {
if (j <= s / 2)
ansA += t;
else if (j > s / 2 + 1)
ansB += t;
else
mids.push_back(t);
}
}
}
sort(mids.begin(), mids.end());
reverse(mids.begin(), mids.end());
for (int i = 0; i < mids.size(); i++)
if (i % 2 == 0)
ansA += mids[i];
else
ansB += mids[i];
cout << ansA << " " << ansB << endl;
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
return MAIN();
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
const int N = 5010;
int a[N], b[N], p[N], q[N];
int idx[N];
inline void fix(int i, int j) {
if (a[i] == (p[i] ^ q[i]))
return;
else if (q[i] == (p[i] ^ a[j])) {
swap(q[i], q[j]);
swap(p[i], p[j]);
swap(idx[p[i]], idx[p[j]]);
} else if (q[i] == (p[j] ^ a[i])) {
swap(p[i], p[j]);
swap(idx[p[i]], idx[p[j]]);
} else if (q[i] == (p[j] ^ a[j])) {
swap(q[i], q[j]);
} else {
int t = idx[a[i] ^ q[i]];
swap(idx[p[t]], idx[p[i]]);
swap(p[t], p[i]);
swap(q[t], q[i]);
swap(q[t], q[j]);
swap(q[i], q[j]);
fix(t, j);
}
}
int main() {
cin >> n;
n = 1 << n;
int tot = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
idx[i] = p[i] = q[i] = i;
tot ^= b[i];
}
if (tot) {
puts("Fou");
return 0;
} else {
puts("Shi");
for (int i = 0; i + 1 < n; i++) {
a[i + 1] ^= (a[i] ^ b[i]);
a[i] = b[i];
fix(i, i + 1);
}
for (int i = 0; i < n; i++) printf("%d ", p[i]);
puts("");
for (int i = 0; i < n; i++) printf("%d ", q[i]);
puts("");
}
}
| 3,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 3;
const int Maxm = 301;
const int Inf = 1000000000;
int n;
int a[Maxn];
bool dp[Maxm][Maxm];
int rc[Maxm][Maxm];
bool diag[Maxm][Maxm];
bool win;
bool Win1() { return a[0]; }
bool Win2() {
for (int i = 0; i <= a[0]; i++)
for (int j = 0; j <= a[1]; j++) {
int mn = min(i, j);
for (int l = 1; l <= mn && !dp[i][j]; l++) dp[i][j] = !dp[i - l][j - l];
for (int l = 1; l <= i && !dp[i][j]; l++) dp[i][j] = !dp[i - l][j];
for (int l = 1; l <= j && !dp[i][j]; l++) dp[i][j] = !dp[i][j - l];
}
return dp[a[0]][a[1]];
}
bool Win3() {
fill((int*)rc, (int*)rc + Maxm * Maxm, Inf);
bool win;
for (int i = 0; i <= a[0]; i++)
for (int j = 0; j <= a[1]; j++)
for (int k = 0; k <= a[2]; k++) {
int i2 = i, j2 = j, k2 = k;
if (i2 > j2) swap(i2, j2);
if (j2 > k2) swap(j2, k2);
if (i2 > j2) swap(i2, j2);
win = rc[i2][j2] < k2 || rc[i2][k2] < j2 || rc[j2][k2] < i2 ||
diag[j2 - i2][k2 - j2];
if (!win) {
rc[i2][j2] = min(rc[i2][j2], k2);
rc[i2][k2] = min(rc[i2][k2], j2);
rc[j2][k2] = min(rc[j2][k2], i2);
diag[j2 - i2][k2 - j2] = true;
}
}
return win;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
if (n == 1)
win = Win1();
else if (n == 2)
win = Win2();
else
win = Win3();
printf("%s\n", win ? "BitLGM" : "BitAryo");
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long res = 0, fl = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fl = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
res = res * 10 + (c ^ 48);
c = getchar();
}
return res * fl;
}
const int N = 1000010, SQ = 10010;
int n, m;
int main() {
int cas = read();
while (cas--) {
int x = read();
string S;
cin >> S;
string st = "", ed = "";
int i = 0;
while (S[i] == '0') st += "0", i++;
int j = S.size() - 1;
while (j >= 0 && S[j] == '1') ed += "1", j--;
string rest = "";
for (int k = i; k <= j; ++k) rest += S[k];
if (rest.empty())
cout << st + ed << endl;
else
cout << st + "0" + ed << endl;
}
return 0;
}
| 1,200 | CPP |
a=set(input())
# print(a)
if len(a)%2==0:
print("CHAT WITH HER!",end="")
else:
print("IGNORE HIM!",end="") | 800 | PYTHON3 |
n = int(input())
s = ''.join(str(x) for x in range(1, 1001))
print(s[n-1])
| 800 | PYTHON3 |
n,t=map(int,input().split())
a=input()
a=list(a)
j=0
while (j<t):
i=0
while (i<n-1):
if a[i]=='B' and a[i+1]=='G':
a[i],a[i+1]=a[i+1],a[i]
i=i+2
else:
i=i+1
j=j+1
print(''.join(a))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long k;
long long a[200005];
long long s1;
long long s2;
long long inv[200005];
long long p;
long long ans;
long long quick_pow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % 1000000007;
x = x * x % 1000000007;
n >>= 1;
}
return res;
}
int main() {
scanf("%lld %lld", &n, &k);
inv[1] = inv[0] = 1LL;
for (long long i = 2; i <= n; i++)
inv[i] = (1000000007 - 1000000007 / i) * inv[1000000007 % i] % 1000000007;
for (long long i = 1; i <= n; ++i) inv[i] = inv[i - 1] * inv[i] % 1000000007;
for (long long i = 1; i <= n; ++i) scanf("%lld", a + i);
for (long long i = 0; i <= k; ++i) {
long long fg = 1;
if (i & 1) fg = -1;
(s1 += fg * inv[i] * inv[k - i] % 1000000007 * quick_pow(k - i, n) %
1000000007) %= 1000000007;
(s2 += fg * inv[i] * inv[k - i] % 1000000007 * quick_pow(k - i, n - 1) %
1000000007) %= 1000000007;
}
p = (s1 + s2 * (n - 1) % 1000000007) % 1000000007;
p = (p + 1000000007) % 1000000007;
for (long long i = 1; i <= n; ++i)
ans = (ans + a[i] * p % 1000000007) % 1000000007;
printf("%lld\n", ans);
return 0;
}
| 2,700 | CPP |
import math
n = int(input())
print(math.ceil(n/2.0 -1)) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
namespace thecold {
inline int read() {
int res = 0;
bool flag = false;
char c = getchar();
while (!isdigit(c)) flag = (c == '-'), c = getchar();
while (isdigit(c)) res = res * 10 + (c ^ 48), c = getchar();
return !flag ? res : -res;
}
const int Max_n = 3e5 + 5;
int head[Max_n], n, m, tot, sum[Max_n], xi[Max_n], yi[Max_n];
int in[Max_n], cnt, ans;
bool nope[Max_n];
struct node {
int nex, to;
node(int a, int b) { nex = a, to = b; }
node() {}
} edge[Max_n];
inline void add_edge(const int x, const int y) {
edge[++tot] = node(head[x], y), head[x] = tot, ++in[y];
}
queue<int> zzz;
inline void work() {
cnt = 0;
for (int i = 1; i <= n; ++i)
if (!in[i]) zzz.push(i), ++cnt;
while (zzz.size()) {
int now = zzz.front(), siz = zzz.size();
zzz.pop();
if (siz == 1)
sum[now] += n - cnt;
else if (siz == 2) {
int tmp = zzz.front(), all = 0;
for (int i = head[tmp]; i; i = edge[i].nex)
if (in[edge[i].to] == 1) nope[now] = true, ++all;
sum[now] += n - (cnt + all);
} else
nope[now] = true;
for (int i = head[now]; i; i = edge[i].nex) {
int nex = edge[i].to;
--in[nex];
if (!in[nex]) zzz.push(nex), ++cnt;
}
}
}
inline void main() {
n = read(), m = read();
for (int i = 1; i <= m; ++i)
xi[i] = read(), yi[i] = read(), add_edge(xi[i], yi[i]);
work();
memset(head, 0, sizeof(head)), memset(in, 0, sizeof(in));
tot = 0;
for (int i = 1; i <= m; ++i) add_edge(yi[i], xi[i]);
work();
for (int i = 1; i <= n; ++i)
if (!nope[i] && sum[i] >= n - 2) ++ans;
printf("%d\n", ans);
}
} // namespace thecold
int main() {
thecold::main();
return 0;
}
| 2,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 9;
long long c[3][3];
long long n;
long long dp[N][3][3];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr << "";
for (int i = 0; i < (3); i++)
for (int j = 0; j < (3); j++) cin >> c[i][j];
cin >> n;
for (long long i = 1; i <= n; i++) {
for (int x = 0; x < (3); x++) {
for (int y = 0; y < (3); y++) {
long long z;
for (int e = 0; e < (3); e++)
if (x != e && y != e) z = e;
dp[i][x][y] = ((dp[i - 1][x][z] + c[x][y] + dp[i - 1][z][y]) <
(dp[i - 1][x][y] + c[x][z] + dp[i - 1][y][x] +
c[z][y] + dp[i - 1][x][y])
? (dp[i - 1][x][z] + c[x][y] + dp[i - 1][z][y])
: (dp[i - 1][x][y] + c[x][z] + dp[i - 1][y][x] +
c[z][y] + dp[i - 1][x][y]));
}
}
}
cout << dp[n][0][2];
}
| 0 | CPP |
from sys import stdin
from collections import deque
mod = 10**9 + 7
import sys
import random
# sys.setrecursionlimit(10**6)
from queue import PriorityQueue
# def rl():
# return [int(w) for w in stdin.readline().split()]
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt,factorial,gcd,log2,inf,ceil
# map(int,input().split())
# # l = list(map(int,input().split()))
# from itertools import permutations
import heapq
# input = lambda: sys.stdin.readline().rstrip()
input = lambda : sys.stdin.readline().rstrip()
from sys import stdin, stdout
from heapq import heapify, heappush, heappop
from itertools import permutations
from math import factorial as f
# def ncr(x, y):
# return f(x) // (f(y) * f(x - y))
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
from collections import defaultdict
from heapq import heappop, heappush, heapify
t = int(input())
for _ in range(t):
a,b = map(int,input().split())
z = b*ceil(a/b)
print(abs(z-a))
| 1,500 | PYTHON3 |
def answer(arr,n,k):
arr.sort()
sum1=sum(arr)
if sum1<=k:
return 0
minimum=sum1-k
ans=minimum
total=0
for i in range(n-1,0,-1):
total+=arr[i]-arr[0]
rem=minimum-total
if rem<=0:
ans=min(ans,n-i)
return ans
f=(rem+(n-i))//(n-i+1)
v=f+n-i
if v<=ans:
ans=v
return ans
t=int(input())
for K in range(t):
inp=input().split()
n=int(inp[0])
k=int(inp[1])
arr=[]
inp=input().split()
for i in inp:
arr.append(int(i))
print(answer(arr,n,k))
| 1,600 | PYTHON3 |
n = int(input())
y = 0
x = 0
for i in range(n):
s =input()
k = int(s[:s.find(' ')])
d = s[s.find(' ')+1:]
if d == 'South':
if (y <= 20000 and y+k > 20000) or (y>= 20000 and y-k< 20000):
print("NO")
exit(0)
if y>= 20000:
y-=k
else:
y+=k
if d == 'North':
if (y <= 20000 and y-k <0) or (y>= 20000 and y+k> 40000):
print("NO")
exit(0)
if y>= 20000:
y+=k
else:
y-=k
y%=40000
if (d == 'West' or d == 'East') and (y == 20000 or y == 0):
print("NO")
exit(0)
if y == 0:
print("YES")
else:
print("NO")
| 1,300 | PYTHON3 |
t = int(input())
for i in range(t):
n = int(input())
ni=int(n/2)
if(ni%2!=0):
print("NO")
else:
print("YES")
l = []
for j in range(ni):
l.append((j+1)*2)
for k in range(ni-1):
l.append((k+1)*2-1)
l.append((ni*2-1)+ni)
print(*l, sep=' ')
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
vector<vector<int> > v(n, vector<int>(7, 0));
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < 7; j++) v[i][j] = s[j] - '0';
}
vector<int> cnt(7, 0);
for (int i = 0; i < 7; i++) {
for (int j = 0; j < n; j++) cnt[i] += v[j][i];
}
int m = 0;
for (int i = 0; i < 7; i++) {
if (cnt[i] > m) m = cnt[i];
}
cout << m;
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool check(char c) {
if (c == 'A' || c == 'H' || c == 'I' || c == 'M' || c == 'O' || c == 'T' ||
c == 'U' || c == 'V' || c == 'W' || c == 'X' || c == 'Y')
return true;
return false;
}
int main() {
string s;
cin >> s;
bool fl = 0;
for (int i = 0; i < (s.size() / 2); i++)
if (s[i] != s[s.size() - i - 1] || !check(s[i])) {
fl = 1;
break;
}
if (!check(s[s.size() / 2])) fl = 1;
if (fl == 0)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1,000 | CPP |
def s():
s = list(map(int,input().split()))
c = list(map(int,input().split()))
n = int(input())
r = 0
for _ in range(n):
v = list(map(int,input().split()))
a = [c[0]-1 if v[0]<0 else s[0]-c[0], c[1]-1 if v[1]<0 else s[1]-c[1]]
t = min(a[0]//abs(v[0]) if v[0]else 10**9,a[1]//abs(v[1]) if v[1] else 10**9)
r += t
c[0] += t * v[0]
c[1] += t * v[1]
print(r)
s()
| 1,300 | PYTHON3 |
# -*- coding: utf-8 -*-
# @Date : 2019-06-06 09:38:34
# @Author : raj lath (oorja.halt@gmail.com)
# @Link : link
# @Version : 1.0.0
import sys
sys.setrecursionlimit(10**5+1)
inf = int(10 ** 20)
max_val = inf
min_val = -inf
RW = lambda : sys.stdin.readline().strip()
RI = lambda : int(RW())
RMI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
RWI = lambda : [x for x in sys.stdin.readline().strip().split()]
nb_test = RI()
for _ in range(nb_test):
lens, k = RMI()
arrs = sorted(RMI())
ans = arrs[0]
max_diff = arrs[-1] - arrs[0]
for i in range(lens - k):
curr = arrs[i+k] - arrs[i]
if curr <= max_diff:
max_diff = curr
ans = (arrs[i + k] + arrs[i]) // 2
print(ans)
| 1,600 | PYTHON3 |
for _ in range(int(input())):
n,k=list(map(int, input().split()))
if(n==k):
print('0')
elif(k>n):
c=k-n
print(c)
else:
if((n-k)%2==0):
print('0')
else:
print('1') | 900 | PYTHON3 |
n=int(input())
if (((1+8*n)**0.5)-1)%2==0:
print('YES')
else:
print('NO') | 800 | PYTHON3 |
cor = [0, 0]
for i in range(5):
row = list(map(int, input().split()))
if 1 in row:
cor[0] = i
cor[1] = row.index(1)
print(abs(cor[0]-2) + abs(cor[1]-2))
| 800 | PYTHON3 |
for iiioi in range(int(input())):
input()
l=list(map(int,input().split()))
ans=[l[0]]
inc=(True,False)[l[0]>l[1]]
num=l[1]
# l.append(l[len(l)-1])
for i in range(0,len(l)-1):
if (inc ^ (l[i+1]>num)) and (num != l[i+1]):
ans.append(l[i])
inc= not inc
num=l[i+1]
# print(i,l[i])
if ans[-1] != l[-1]:
ans.append(l[-1])
print(len(ans))
print(*ans)
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int m = 500;
const int M = 510;
int n, p, x[310000], y[310000];
vector<int> route[310000];
long long a[310000], ans[310000];
long long f[600][600], pos;
inline int prepos(const int &pos, const int &k) {
return ((pos - k) % M + M) % M;
}
inline void nexpos() { pos = (pos + 1) % M; }
void work() {
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (int i = 1; i <= n; i++) route[i].clear();
scanf("%d", &p);
for (int i = 1; i <= p; i++) {
scanf("%d%d", &x[i], &y[i]);
if (y[i] > m) {
ans[i] = 0LL;
for (int k = x[i]; k <= n; k += y[i]) ans[i] += a[k];
} else
route[x[i]].push_back(i);
}
pos = 0;
for (int i = n; i >= 1; i--) {
for (int j = 1; j <= m; j++) {
f[pos][j] = a[i];
if (i + j > n) continue;
f[pos][j] += f[prepos(pos, j)][j];
}
if (!route[i].empty()) {
int size = route[i].size();
for (int k = 0; k < size; k++) ans[route[i][k]] = f[pos][y[route[i][k]]];
}
nexpos();
}
for (int i = 1; i <= p; i++) printf("%I64d\n", ans[i]);
}
int main() {
while (scanf("%d", &n) != EOF) work();
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int gcd(int a, int b) { return (!b) ? a : gcd(b, a % b); }
void cv(vector<long> a) {
cout << "--"
<< "\n";
for (int i = 0; i < (int)a.size(); i++)
cout << a[i] << " "
<< "\n";
cout << "//"
<< "\n";
}
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i += 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
bool isPal(string str) {
int l = 0;
int h = str.size() - 1;
while (h > l) {
if (str[l++] != str[h--]) return false;
}
return true;
}
int main() {
fast();
int n;
cin >> n;
vector<int> v(n);
for (int& x : v) cin >> x;
for (int i = 0, a = 0; i < n; i++) {
if (v[i] - a > 15) {
cout << a + 15 << "\n";
return 0;
}
if (i == n - 1) {
cout << min(v[i] + 15, 90) << "\n";
}
a = v[i];
}
return 0;
}
| 800 | CPP |
n,h=map(int,input().split(" "))
a=list(map(int,input().split(" ")))
c=0
w=0
for i in range(len(a)):
if a[i]>h:
c=c+1
w=c*2+(n-c)
print(w) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int caseno = 1;
typedef long long LL;
typedef unsigned long long ULL;
typedef long long int64;
typedef unsigned long long uint64;
template <class T>
inline void SWAP(T &a, T &b) {
T t = a;
a = b;
b = t;
}
const double PI = 2 * acos(0.0);
const double EPS = 1e-11;
const int SIZE = 100 + 10;
int ar[SIZE];
int main() {
int tcases, I, J, K, N, n, m, cnt = 0, len;
scanf("%d", &n);
for (I = 0; I < n; I++) scanf("%d", &ar[I]);
for (I = 0; I < n; I++) {
for (K = 0; K < n - 1;) {
if (ar[K] > ar[K + 1]) {
printf("%d %d\n", K + 1, K + 2);
SWAP(ar[K], ar[K + 1]);
}
K++;
}
}
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<long long int> points = {1};
long long int pos2;
long long int area[1005];
area[1] = 0;
area[2] = 0;
cout << "2 1 2 3" << endl;
long long int sgn;
cin >> sgn;
if (sgn == 1) {
points.push_back(2);
points.push_back(3);
pos2 = 1;
} else {
points.push_back(3);
points.push_back(2);
pos2 = 2;
}
cout << "1 1 2 3" << endl;
cin >> area[3];
for (long long int i = 4; i <= n; i++) {
cout << "2 1 2 " << i << endl;
cin >> sgn;
cout << "1 1 2 " << i << endl;
cin >> area[i];
long long int point1 = -1, point2 = -1;
long long int start = (sgn == 1) ? (pos2 + 1) : 1;
long long int finish = (sgn == 1) ? (i - 1) : pos2;
if (sgn == -1) pos2++;
if (start == finish) {
points.insert(points.begin() + start, i);
continue;
}
long long int maxArea = 0;
long long int maxInd = 0;
for (long long int j = start; j < finish; j++) {
if (point1 == -1 && area[points[j]] >= area[i]) point1 = j;
if (point1 != -1 && point2 == -1 &&
(j == finish - 1 || area[points[j + 1]] <= area[i]))
point2 = j;
if (maxArea < area[points[j]]) {
maxArea = area[points[j]];
maxInd = j;
}
}
if (maxArea < area[i]) {
cout << "2 1 " << points[maxInd] << " " << i << endl;
cin >> sgn;
if (sgn == 1)
points.insert(points.begin() + maxInd + 1, i);
else
points.insert(points.begin() + maxInd, i);
continue;
}
cout << "2 1 " << points[point1] << " " << i << endl;
cin >> sgn;
if (sgn < 0)
points.insert(points.begin() + point1, i);
else
points.insert(points.begin() + point2 + 1, i);
}
cout << "0 ";
for (long long int point : points) cout << point << " ";
return 0;
}
| 2,300 | CPP |
n = int(input())
boy = [int(i) for i in input().split()]
m = int(input())
girl = [int(i) for i in input().split()]
boy = sorted(boy)
girl = sorted(girl)
count = 0
for i in range(len(boy)):
j=0
while j < len(girl):
if abs(boy[i]-girl[j])<=1:
del girl[j]
count+=1
break
j+=1
print(count)
| 1,200 | PYTHON3 |
n, s, m = input(), str(input()), {}
for c in s:
m[c] = 1
print(-1 if len(s) > 26 else len(s) - len(m)) | 1,000 | PYTHON3 |
for _ in range(int(input())):
l,r = map(int,input().split())
a = (r+1)/2
if l >= a:
print('YES')
else:
print('NO') | 800 | PYTHON3 |
k = int(input())
ans = ""
for ch in "abcdefghijklmnopqrstuvwxyz":
cost = 0
while k-cost>=0:
k-=cost
cost+=1
ans+=ch
if not k:
break
print(ans) | 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1001000;
int n, mod;
int a[maxn];
int S[maxn], st;
int lp[maxn], rp[maxn];
double f[maxn];
inline int read() {
int res = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) res = (res << 3) + (res << 1) + ch - '0', ch = getchar();
return res;
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read();
st = 0;
for (int i = 1; i <= n; ++i) {
while (st && a[i] < a[S[st]]) --st;
lp[i] = S[st] + 1;
S[++st] = i;
}
st = 0;
S[st] = n + 1;
for (int i = n; i; --i) {
while (st && a[i] <= a[S[st]]) --st;
rp[i] = S[st] - 1;
S[++st] = i;
}
for (int i = 1; i <= n; ++i) {
if (i - lp[i] < rp[i] - i) {
for (int j = i; j >= lp[i]; --j) {
f[i - j + 1] += a[i];
f[rp[i] - j + 2] -= a[i];
}
} else {
for (int j = i; j <= rp[i]; ++j) {
f[j - i + 1] += a[i];
f[j - lp[i] + 2] -= a[i];
}
}
}
for (int i = 1; i <= n; ++i) {
f[i] += f[i - 1];
f[i - 1] /= n - i + 2;
}
int T = read();
while (T--) {
printf("%.9lf\n", f[read()]);
}
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int X, Y, m, k;
char maps[1001][10][10];
int G[1001][1001];
int w[1001];
int taken[1001], padre[1001];
struct cmp {
bool operator()(pair<int, int> a, pair<int, int> b) {
return G[a.first][a.second] > G[b.first][b.second];
}
};
int main() {
while (cin >> Y >> X >> m >> k) {
memset(G, 0, sizeof(G)), memset(taken, 0, sizeof(taken));
for (int i = (1); i < (m + 1); i++) {
for (int y = (0); y < (Y); y++)
for (int x = (0); x < (X); x++) {
cin >> maps[i][x][y];
for (int j = (1); j < (i); j++)
if (maps[i][x][y] != maps[j][x][y]) G[i][j] += k, G[j][i] += k;
}
G[0][i] = X * Y;
G[i][0] = X * Y;
padre[i] = 0;
}
priority_queue<pair<int, int>, vector<pair<int, int> >, cmp> q;
taken[0] = true;
for (int i = (1); i < (m + 1); i++) q.push(make_pair(0, i));
vector<pair<int, int> > r;
int mcost = 0;
while (((int)q.size())) {
pair<int, int> v = q.top();
q.pop();
if (!taken[v.second]) {
taken[v.second] = 1;
r.push_back(make_pair(v.second, v.first));
mcost += G[v.first][v.second];
for (int i = (1); i < (m + 1); i++)
if (i != v.second && !taken[i]) {
q.push(make_pair(v.second, i));
}
}
}
cout << mcost << endl;
for (typeof((r).begin()) it = (r).begin(); it != (r).end(); ++it)
cout << it->first << ' ' << it->second << endl;
r.clear();
}
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
inline int getint() {
char c = getchar();
int x = 0, mi = 1;
while (c != EOF && c != '-' && !isdigit(c)) c = getchar();
if (c == '-') {
mi = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
return x * mi;
}
inline long long getll() {
long long x;
scanf("%lld", &x);
return x;
}
inline double getdb() {
static double x;
scanf("%lf", &x);
return x;
}
void prln() { printf("\n"); }
void pr(const char* s = " ") { printf("%s", s); }
void pr(char const& x) { putchar(x); }
void pr(bool const& x) { printf("%d", x); }
void pr(int const& x) { printf("%d", x); }
void pr(long long const& x) { printf("%lld", x); }
void pr(double const& x) { printf("%.2f", x); }
void pr(long double const& x) { printf("%.2f", (double)x); }
template <typename T>
void pr(pair<T, T> x) {
pr("(");
pr(x.first);
pr(",");
pr(x.second);
pr(")");
}
template <typename T>
void pr(T const t[], int len, const char* h = "", const char* c = "\n") {
printf("%s", h);
for (decltype(len - 1) i = 0, lim__lim = (len - 1); i <= lim__lim; i++)
pr(t[i]), pr();
printf("%s", c);
}
template <typename T>
void updmax(T& a, T const& b) {
a = max(a, b);
}
template <typename T>
void updmin(T& a, T const& b) {
a = min(a, b);
}
template <typename T>
int Descr(T* from, T* to) {
sort(from, to);
return (int)(unique(from, to) - from);
}
template <typename T>
int LBound(T* from, T* to, T const& val) {
return (int)(lower_bound(from, to, val) - from);
}
template <typename T>
int UBound(T* from, T* to, T const& val) {
return (int)(upper_bound(from, to, val) - from);
}
time_point<system_clock> timing;
void TBegin() { timing = system_clock::now(); }
double TEnd(const char* c = "time: ") {
auto end = system_clock::now();
auto d = duration_cast<microseconds>(end - timing);
auto dt =
double(d.count()) * microseconds::period::num / microseconds::period::den;
printf("%s%.10f", c, dt);
return dt;
}
void TTick(const char* c = "time:") {
TEnd(c);
TBegin();
}
const int mxn = 1e5 + 50;
int v[10][mxn];
int loc[10][mxn];
bool cov[mxn];
int main() {
int n = getint();
int m = getint();
for (decltype(m - 1) t = 0, lim__lim = (m - 1); t <= lim__lim; t++)
for (decltype(n - 1) i = 0, lim__lim = (n - 1); i <= lim__lim; i++)
v[t][i] = getint() - 1;
for (decltype(m - 1) t = 0, lim__lim = (m - 1); t <= lim__lim; t++)
for (decltype(n - 1) i = 0, lim__lim = (n - 1); i <= lim__lim; i++)
loc[t][v[t][i]] = i;
long long ans = 0;
for (decltype(n - 1) l = 0, lim__lim = (n - 1); l <= lim__lim; l++)
if (!cov[l]) {
int p[10];
for (decltype(m - 1) i = 0, lim__lim = (m - 1); i <= lim__lim; i++)
p[i] = loc[i][v[0][l]];
int len = 0;
while (true) {
bool able = true;
for (decltype(m - 1) i = 0, lim__lim = (m - 1); i <= lim__lim; i++)
if (p[i] >= n) {
able = false;
break;
}
if (!able) break;
for (decltype(m - 1) i = 0, lim__lim = (m - 1); i <= lim__lim; i++)
if (v[i][p[i]] != v[0][p[0]]) {
able = false;
break;
}
if (!able) break;
len += 1;
for (decltype(m - 1) i = 0, lim__lim = (m - 1); i <= lim__lim; i++)
p[i] += 1;
}
ans += 1LL * (len + 1) * len / 2;
for (decltype(l + len - 1) i = l, lim__lim = (l + len - 1); i <= lim__lim;
i++) {
cov[i] = true;
}
}
pr(ans);
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int a, b;
scanf("%d%d", &a, &b);
if (b > a) swap(a, b);
int moves = (a - b + 9) / 10;
printf("%d\n", moves);
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
solve();
}
}
| 800 | CPP |
from collections import defaultdict
graph = defaultdict(list)
n=int(input())
arr=list(map(int,input().split()))
for i in range(1,n+1):
graph[i]=(arr[i-1])
flag=False
for i in range(1,n+1):
if graph[graph[graph[i]]]==i:
print('YES')
flag=True
break
if not flag:
print('NO')
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int *fences;
int paintInterval(int first, int last, int height) {
if (first >= last) return 0;
int minHeight = first;
for (int i = first; i < last; i++)
if (fences[minHeight] > fences[i]) minHeight = i;
return min(last - first,
fences[minHeight] - height +
paintInterval(first, minHeight, fences[minHeight]) +
paintInterval(minHeight + 1, last, fences[minHeight]));
}
int main() {
int n;
cin >> n;
fences = new int[n];
for (int i = 0; i < n; i++) cin >> fences[i];
cout << paintInterval(0, n, 0);
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(char c) { return to_string(string(1, c)); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
void solve(const int &test_id) {
int n, m;
cin >> n >> m;
vector<string> x(n);
for (auto &e : x) cin >> e;
vector<vector<int> > rc(n, vector<int>(26)), cc(m, vector<int>(26));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) rc[i][x[i][j] - 'a']++, cc[j][x[i][j] - 'a']++;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (rc[i][x[i][j] - 'a'] == 1 && cc[j][x[i][j] - 'a'] == 1)
cout << x[i][j];
}
void solve_cases() {
int test_cases = 1;
for (int i = 1; i <= test_cases; i++) solve(i);
}
void fast_io() {
ios::sync_with_stdio(false);
srand(time(NULL));
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(15);
cerr << fixed << setprecision(15);
}
int main() {
fast_io();
solve_cases();
return EXIT_SUCCESS;
}
| 1,100 | CPP |
def check(n):
if n%2==0:
return int(n/2)
return -(int(n/2)+1)
def main():
# n=input()
# cnt=0
# for i in range(int(n)):
# m, n = map(int, input().split())
# cnt+=check(m,n)
# print(cnt)
n=int(input())
# print(type(n))
ans=check(n)
print(ans)
# m, n = map(int, input().split())
main() | 800 | PYTHON3 |
n, h, m = list(map(int, input().split()))
h2 = h**2
c = [h2]*n
for _ in range(m):
l, r, x = list(map(int, input().split()))
x2 = x**2
for i in range(l-1, r):
if c[i] > x2: c[i] = x2
print(sum(c))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[3005], b[3005], df[3005];
long long F[3005][3005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
a[i] = a[i] - i;
b[i] = a[i];
}
sort(b + 1, b + n + 1);
int m = 0;
b[0] = b[1] - 1;
for (int i = 1; i <= n; ++i) {
if (b[i] > b[i - 1]) df[++m] = b[i];
}
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= m; ++j) {
F[i][j] = 1e18;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
F[i][j] = min(F[i][j - 1], F[i - 1][j] + abs(a[i] - df[j]));
}
}
long long rs = 1e18;
for (int i = 1; i <= m; ++i) rs = min(rs, F[n][i]);
cout << rs;
return 0;
}
| 2,300 | CPP |
n = int(input().split()[0])
st = str(input())
m = 1
for i in range(2,1+n//2):
if st[:i] == st[i:2*i]:
m = i
print(n-m+1) | 1,400 | PYTHON3 |
def isround(n):
n = str(n)
if len(n)==1: return True
n = n[1:]
if int(n) == 0: return True
return False
def solve(ls):
for n in ls:
temp=[]
i=1
for _ in range(len(str(n))):
if isround(n): temp.append(n); break
if n%(10**i)!=0: temp.append(n%(10**i))
n=(10**i)*(n//10**i)
i+=1
print(len(temp))
for i in temp: print(i,end=' ')
print()
if __name__ == '__main__':
t = int(input())
#ls = [5009,7,9876,10100,10,0,909090010]
ls = []
for i in range(t): ls.append(int(input()))
solve(ls)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
const int mod = 998244353;
using namespace std;
void no(int p = -1) {
cout << "NIE"
<< "\n";
}
int n, m, q, p, x, y = 1, ans = 0;
bool t = false;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < int(n); i++)
for (int j = 0; j < int(m); j++) {
cin >> q;
if (j == 0) {
p = q;
ans ^= q;
} else if (p != q) {
t = true;
x = i;
y = j + 1;
}
}
if (ans > 0) {
cout << "TAK"
<< "\n";
for (int i = 0; i < int(n); i++) cout << "1 ";
} else if (t) {
cout << "TAK"
<< "\n";
for (int i = 0; i < n; i++) {
if (i == x)
cout << y << " ";
else
cout << "1 ";
}
} else
no();
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
const int inf = (1 << 30) - 1;
const int N = 1e5 + 5;
struct num {
int a, b;
num() : a(), b() {}
num(int x) : a(x % mod), b() {}
num(int a, int b) : a(a % mod), b(b % mod) {}
bool operator==(const num &n) const { return a == n.a && b == n.b; }
num operator+(const num &n) const { return num(a + n.a, b + n.b); }
num operator-(const num &n) const {
return num(a - n.a + mod, b - n.b + mod);
}
num operator*(const num &n) const {
return num((long long)a * n.a % mod + 5ll * b % mod * n.b % mod,
(long long)a * n.b % mod + (long long)b * n.a % mod);
}
void operator*=(const num &n) {
long long A = (long long)a * n.a % mod + 5ll * b % mod * n.b % mod;
long long B = (long long)a * n.b % mod + (long long)b * n.a % mod;
this->a = A % mod;
this->b = B % mod;
}
num const operator%(int mod) const { return num(a, b); }
};
int binpow(int a, int n, int mod) {
int res = 1;
while (n) {
if (n & 1) res = (long long)res * a % mod;
a = (long long)a * a % mod;
n >>= 1;
}
return res;
}
num binpow(num a, int n, int mod) {
num res = num(1, 0);
while (n) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
const int s5 = binpow(5, mod - 2, mod);
const int s2 = binpow(2, mod - 2, mod);
const num A = num(0, s5);
const num B = num(0, mod - s5);
const num E = num(1, 0);
const num Z = num(0, 0);
const num C[2] = {num(s2, s2), num(s2, mod - s2)};
num f[N][2], toMult[2][4 * N], sum[2][4 * N];
int n, m;
void build(int v, int l, int r) {
if (l == r) {
for (int i = 0; i < 2; i++) sum[i][v] = f[l][i], toMult[i][v] = E;
return;
}
build(v + v, l, ((l + r) >> 1));
build(v + v + 1, ((l + r) >> 1) + 1, r);
for (int i = 0; i < 2; i++) {
sum[i][v] = sum[i][v + v] + sum[i][v + v + 1];
toMult[i][v] = E;
}
}
void push(int v) {
if (toMult[0][v] == E) return;
for (int i = 0; i < 2; i++) {
if (v + v < 4 * N) toMult[i][v + v] *= toMult[i][v];
if (v + v + 1 < 4 * N) toMult[i][v + v + 1] *= toMult[i][v];
sum[i][v] *= toMult[i][v];
toMult[i][v] = E;
}
}
void update(int v, int l, int r, int L, int R, num x[2]) {
push(v);
if (R < l || r < L) return;
if (L <= l && r <= R) {
for (int i = 0; i < 2; i++) toMult[i][v] *= x[i];
push(v);
return;
}
update(v + v, l, ((l + r) >> 1), L, R, x);
update(v + v + 1, ((l + r) >> 1) + 1, r, L, R, x);
for (int i = 0; i < 2; i++) sum[i][v] = sum[i][v + v] + sum[i][v + v + 1];
}
int get(int v, int l, int r, int L, int R) {
push(v);
if (R < l || r < L) return 0;
if (L <= l && r <= R) {
num res = sum[0][v] + sum[1][v];
assert(res.b == 0);
return res.a;
}
return (get(v + v, l, ((l + r) >> 1), L, R) +
get(v + v + 1, ((l + r) >> 1) + 1, r, L, R)) %
mod;
}
void print(int v, int l, int r, int tab = 0) {
for (int i = 0; i < tab; i++) putchar('\t');
printf("[%d %d] sum=%d\n", l, r, (sum[0][v].a + sum[1][v].a) % mod);
if (l == r) return;
print(v + v, l, ((l + r) >> 1), tab + 1);
print(v + v + 1, ((l + r) >> 1) + 1, r, tab + 1);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1, x; i <= n; i++) {
scanf("%d", &x);
x %= mod - 2;
f[i][0] = A * binpow(C[0], x, mod);
f[i][1] = B * binpow(C[1], x, mod);
}
build(1, 1, n);
int ty, l, r, x;
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &ty, &l, &r);
if (ty == 1) {
scanf("%d", &x);
x %= mod - 2;
num qx[2] = {binpow(C[0], x, mod), binpow(C[1], x, mod)};
update(1, 1, n, l, r, qx);
} else {
printf("%d\n", get(1, 1, n, l, r));
}
}
return 0;
}
| 2,300 | CPP |
from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var)+"\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def smp(): return map(str, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def remadd(x, y): return 1 if x%y else 0
def ceil(a,b): return (a+b-1)//b
def isprime(x):
if x<=1: return False
if x in (2, 3): return True
if x%2 == 0: return False
for i in range(3, int(sqrt(x))+1, 2):
if x%i == 0: return False
return True
a, b = mp()
c = l1d(3)
for i in range(1, 7):
ai = abs(a-i)
bi = abs(b-i)
if ai>bi: c[2]+=1
elif ai==bi: c[1]+=1
else: c[0]+=1
print(*c) | 800 | PYTHON3 |
n=int(input())
s=input()
a=0
b=0
for i in s:
if i=='A':
a=a+1
elif i=='D':
b=b+1
if a>b:
print('Anton')
elif a==b:
print('Friendship')
else:
print('Danik') | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
const int mod = 1e9 + 7;
int sum[N][N], x[N], y[N], b[N], n, m, r;
int C[N][N];
void init() {
C[0][0] = 1;
for (int i = 1; i <= n; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
}
}
int cal(int l1, int r1, int l2, int r2) {
if (l1 > l2 || r1 > r2) return 0;
l1 = max(l1, 1);
r1 = max(r1, 1);
l2 = min(l2, 1000);
r2 = min(r2, 1000);
return sum[l2][r2] - sum[l2][r1 - 1] - sum[l1 - 1][r2] + sum[l1 - 1][r1 - 1];
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(3);
cin >> n >> m >> r;
init();
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i] >> b[i];
sum[x[i]][y[i]]++;
}
for (int i = 1; i <= 1000; i++) {
for (int j = 1; j <= 1000; j++) {
sum[i][j] =
(sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + sum[i][j]);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int v = 1ll * b[i] * b[j] % mod;
int XIL = x[i] - r;
int XIR = x[i] + r;
int YIL = y[i] - r;
int YIR = y[i] + r;
int XJL = x[j] - r;
int XJR = x[j] + r;
int YJL = y[j] - r;
int YJR = y[j] + r;
int ni = C[n - cal(XIL, YIL, XIR, YIR)][m];
int nj = C[n - cal(XJL, YJL, XJR, YJR)][m];
int inter =
n - cal(XIL, YIL, XIR, YIR) - cal(XJL, YJL, XJR, YJR) +
cal(max(XIL, XJL), max(YIL, YJL), min(XIR, XJR), min(YIR, YJR));
int nij = C[inter][m];
int nn = ni + nj - nij;
ans = (ans + 1ll * (C[n][m] - nn) * v % mod) % mod;
}
}
cout << (ans + mod) % mod << '\n';
return 0;
}
| 2,300 | CPP |
n = int(input())
s = input()
for i in range(len(s)-1):
if s[i] != s[i+1]:
print('YES')
print(s[i]+s[i+1])
break
else:print('NO')
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 7e5;
char s[1000010];
int t, now, n, ans = 0, f[maxn], pr[2], l[2], r[2], q[2], cnt[2];
int main() {
scanf("%d", &n);
t = 0;
now = 1;
for (int i = 1; i <= n; i++) {
scanf(" %c", &s[i]);
s[i + n] = s[i];
if (s[i] == '(') cnt[0]++;
if (s[i] == ')') cnt[1]++;
if (cnt[0] - cnt[1] < now) {
now = cnt[0] - cnt[1];
t = (i % n + 1);
}
}
if (cnt[0] != cnt[1]) {
printf("0\n");
printf("1 1\n");
return 0;
}
f[t - 1] = 0;
cnt[0] = cnt[1] = 0;
q[0] = q[1] = 0;
pr[0] = pr[1] = t;
l[0] = r[0] = l[1] = r[1] = 1;
for (int i = t; i <= t + n; i++) {
if (s[i] == '(') f[i] = f[i - 1] + 1;
if (s[i] == ')') f[i] = f[i - 1] - 1;
if (f[i] == 2) cnt[1]++;
if (f[i] == 1) {
cnt[0]++;
if (q[1] < cnt[1]) {
q[1] = cnt[1];
l[1] = pr[1];
r[1] = i;
}
cnt[1] = 0;
pr[1] = i + 1;
}
if (f[i] == 0) {
if (q[0] < cnt[0]) {
q[0] = cnt[0];
l[0] = pr[0];
r[0] = i;
}
cnt[0] = 0;
pr[0] = i + 1;
ans++;
}
}
l[0] = (l[0] - 1) % n + 1;
l[1] = (l[1] - 1) % n + 1;
r[0] = (r[0] - 1) % n + 1;
r[1] = (r[1] - 1) % n + 1;
if (ans + q[1] > q[0]) {
printf("%d\n", ans + q[1]);
printf("%d %d\n", l[1], r[1]);
return 0;
}
if (ans + q[1] <= q[0]) {
printf("%d\n", q[0]);
printf("%d %d\n", l[0], r[0]);
return 0;
}
}
| 2,500 | CPP |
from sys import maxsize, stdout, stdin
mod = int(1e9 + 7)
def I(): return int(stdin.readline())
def lint(): return [int(x) for x in stdin.readline().split()]
def S(): return input().strip()
def grid(r, c): return [lint() for i in range(r)]
from math import factorial
n = I()
print(factorial(n-1)//(n//2)) | 1,300 | PYTHON3 |
n=int(input())
a=list(map(int,input().split()))
x=a[0]
if(a.count(x)==n):
print(0)
else:
r=[[a[i],i] for i in range(n)]
r.sort()
f={}
mv=0
ans=[]
for i in a:
if(i in f):
f[i]+=1
else:
f[i]=1
x=max(f.values())
ind=0
for i in f.keys():
if(f[i]==x):
ind=i
break
i=a.index(ind)
for j in range(i+1,n):
if(a[j]>a[j-1]):
a[j]=a[j-1]
ans.append([2,j+1,j])
mv+=1
elif (a[j]<a[j-1]):
a[j]=a[j-1]
ans.append([1,j+1,j])
mv+=1
for j in range(i-1,-1,-1):
if(a[j]>a[j+1]):
a[j]=a[j+1]
ans.append([2,j+1,j+2])
mv+=1
elif (a[j]<a[j+1]):
a[j]=a[j+1]
ans.append([1,j+1,j+2])
mv+=1
print(mv)
for i in ans:
print(*i) | 1,400 | PYTHON3 |
# Contest: Educational Codeforces Round 77 (Rated for Div. 2) (https://codeforces.com/contest/1260)
# Problem: C: Infinite Fence (https://codeforces.com/contest/1260/problem/C)
def rint():
return int(input())
def rints():
return list(map(int, input().split()))
from math import gcd
t = rint()
for _ in range(t):
r, b, k = rints()
if r == b:
print('OBEY')
continue
g = gcd(r, b)
r //= g
b //= g
if r < b:
r, b = b, r
print('REBEL' if (r - 2) // b + 1 >= k else 'OBEY')
| 1,700 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int ans;
char s[1000];
int main() {
scanf("%d%s", &ans, s);
for (int i = 0; s[i];) {
int j = i + 1, ret = s[i] - '0';
while (isdigit(s[j])) {
ret = ret * 10 + s[j] - '0';
j++;
}
if (s[i] == '+')
ans += ret;
else
ans -= ret;
i = j;
}
cout << ans << endl;
}
| 2,400 | CPP |
import math
t=list(map(int,input().split()))
t.sort()
def facto(a):
x=1
for i in range (a):
x=a*x
a=a-1
return x
print(facto(t[0])) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s, s1 = "", s2 = "";
cin >> n >> s;
reverse(s.begin(), s.end());
for (int i = 0; i < s.size(); ++i) {
if (i % 2 == 0)
s1 += s[i];
else
s2 += s[i];
}
reverse(s1.begin(), s1.end());
cout << s2 << s1;
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010, inf = 0x7ffffff;
int n, a[maxn], pos[maxn], sum1[maxn << 2], sum2[maxn << 2], min1[maxn << 2],
tag[maxn << 2], min2[maxn << 2];
long long ans;
void solve(int o, int v, int c) {
if (v < min1[o]) {
min2[o] = min1[o];
sum2[o] = sum1[o];
min1[o] = v;
sum1[o] = c;
} else if (v == min1[o])
sum1[o] += c;
else if (v < min2[o]) {
min2[o] = v;
sum2[o] = c;
} else if (v == min2[o])
sum2[o] += c;
}
void pushup(int o) {
sum1[o] = sum1[o * 2];
min1[o] = min1[o * 2];
sum2[o] = sum2[o * 2];
min2[o] = min2[o * 2];
solve(o, min2[o * 2 + 1], sum2[o * 2 + 1]);
solve(o, min1[o * 2 + 1], sum1[o * 2 + 1]);
}
void pushdown(int o) {
if (tag[o]) {
tag[o * 2] += tag[o];
tag[o * 2 + 1] += tag[o];
min1[o * 2] += tag[o];
min1[o * 2 + 1] += tag[o];
min2[o * 2] += tag[o];
min2[o * 2 + 1] += tag[o];
tag[o] = 0;
}
}
void build(int o, int l, int r) {
min1[o] = 0;
sum1[o] = (r - l + 1);
min2[o] = inf;
sum2[o] = 0;
if (l == r) return;
int mid = (l + r) >> 1;
build(o * 2, l, mid);
build(o * 2 + 1, mid + 1, r);
pushup(o);
}
void update(int o, int l, int r, int x, int y, int v) {
if (x <= l && r <= y) {
min1[o] += v;
min2[o] += v;
tag[o] += v;
return;
}
pushdown(o);
int mid = (l + r) >> 1;
if (x <= mid) update(o * 2, l, mid, x, y, v);
if (y > mid) update(o * 2 + 1, mid + 1, r, x, y, v);
pushup(o);
}
void query(int o, int l, int r, int x, int y) {
if (x <= l && r <= y) {
if (min1[o] <= 2) ans += sum1[o];
if (min2[o] <= 2) ans += sum2[o];
return;
}
pushdown(o);
int mid = (l + r) >> 1;
if (x <= mid) query(o * 2, l, mid, x, y);
if (y > mid) query(o * 2 + 1, mid + 1, r, x, y);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
build(1, 1, n);
for (int i = 1; i <= n; i++) {
int l = -1, r = -1;
if (pos[i] > 1 && i >= a[pos[i] - 1]) l = a[pos[i] - 1];
if (pos[i] < n && i >= a[pos[i] + 1]) r = a[pos[i] + 1];
if (l > r) swap(l, r);
if (r == -1)
update(1, 1, n, 1, i, 1);
else if (l == -1)
update(1, 1, n, r + 1, i, 1);
else {
update(1, 1, n, r + 1, i, 1);
update(1, 1, n, 1, l, -1);
}
query(1, 1, n, 1, i);
}
cout << ans - n << endl;
return 0;
}
| 2,900 | CPP |
n = int(input())
if (n % 4 == 0):
print(4)
else:
print(0)
# 1513432087840
| 1,200 | PYTHON3 |
import re
s = input()
vowels = ['a','e','i','o','u','y','A','E','I','O','U','Y']
s = re.sub('|'.join(vowels), "", s)
lst = list(s)
n = len(lst)
counter = 0
while counter < n:
lst.insert(counter, '.')
counter += 2
n = len(lst)
print(''.join(lst).lower()) | 1,000 | PYTHON3 |
import math
t=int(input())
while t :
a,b = list(map(int,input().split()))
m=math.ceil(a/b)
d=m*b
print(d-a)
t=t-1
| 1,500 | PYTHON3 |
t = int(input())
for i in range(0, t):
pic = []
n, m = map(int, input().split())
for j in range(0, n):
pic.append(input())
minRow = [0]
minSqaresR = 5000000
for j in range(0, n):
squares = pic[j].count('.')
if squares < minSqaresR:
minSqaresR = squares
minRow = [j]
elif squares == minSqaresR:
minRow.append(j)
minCol = [0]
minSqaresC = 5000000
transp = list(zip(*pic))
for j in range(0, m):
squares = transp[j].count('.')
if squares < minSqaresC:
minSqaresC = squares
minCol = [j]
elif squares == minSqaresC:
minCol.append(j)
modifier = 0
for j in range(0, len(minRow)):
if modifier == -1:
break
for k in range(0, len(minCol)):
if pic[minRow[j]][minCol[k]]=='.':
modifier = -1
break
print (minSqaresR + minSqaresC + modifier) | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, const string& delim = " ") {
vector<string> res;
string t;
for (int i = 0; i != s.size(); i++) {
if (delim.find(s[i]) != string::npos) {
if (!t.empty()) {
res.push_back(t);
t = "";
}
} else {
t += s[i];
}
}
if (!t.empty()) {
res.push_back(t);
}
return res;
}
vector<int> splitInt(const string& s, const string& delim = " ") {
vector<string> tok = split(s, delim);
vector<int> res;
for (int i = 0; i != tok.size(); i++) res.push_back(atoi(tok[i].c_str()));
return res;
}
template <typename T>
void print(T a) {
cerr << a;
}
static void print(long long a) { cerr << a << "L"; }
static void print(string a) { cerr << '"' << a << '"'; }
template <typename T>
void print(vector<T> a) {
cerr << "{";
for (int i = 0; i != a.size(); i++) {
if (i != 0) cerr << ", ";
print(a[i]);
}
cerr << "}" << endl;
}
int main() {
int n, m;
while (cin >> n >> m) {
int res = 0;
if (n <= 1 || m <= 1) res = m * n;
if (n == 2 || m == 2) {
int x = max(m, n);
res = max(res, x / 4 * 4 + min((x % 4) * 2, 4));
}
int x = m * n / 2;
int y = m * n - x;
res = max(max(res, x), y);
res = min(res, m * n);
cout << res << endl;
}
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t xl, xr, yb, yt, x, y;
cin >> xl >> yb >> xr >> yt;
x = xr - xl + 1, y = yt - yb + 1;
cout << x * (y / 2) + (x + 1) / 2 * (y & 1);
return 0;
}
| 1,900 | CPP |
string=input()
u=0
l=0
for ch in string:
if(ch.isupper()):
u=u+1
else:
l=l+1
if(u>l):
print(string.upper())
else:
print(string.lower())
| 800 | PYTHON3 |
t=int(input())
for T in range(t):
x=input()
n,m=x.split(" "); n=int(n); m=int(m)
ans=0
for i in range(n):
s=input()
if(i!=n-1):
if(s[-1]=='R'):
ans+=1
else:
for i in s:
if(i=='D'):
ans+=1
print(ans) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000021, base = 907, sz = 1e6 + 5;
int tc, casee = 1;
long long Hash[sz], mp[sz], Hash1[sz];
string s, x, y, z;
void pre() {
mp[0] = 1;
for (int i = 1; i < sz; i++) {
mp[i] = (mp[i - 1] * base) % mod;
}
}
void compute_hash(string s) {
long long hash_val = 0;
for (int i = 0; i < s.size(); i++) {
hash_val = (hash_val * base + (s[i] - 'a' + 1)) % mod;
Hash[i + 1] = hash_val;
}
}
long long compare(int l, int r) {
long long rht = Hash[r], lft = (Hash[l - 1] * mp[r - l + 1]) % mod;
return (rht - lft + mod) % mod;
}
void compute_hash1(string s) {
long long hash_val = 0;
for (int i = 0; i < s.size(); i++) {
hash_val = (hash_val * base + (s[i] - 'a' + 1)) % mod;
Hash1[i + 1] = hash_val;
}
}
long long compare1(int l, int r) {
long long rht = Hash1[r], lft = (Hash1[l - 1] * mp[r - l + 1]) % mod;
return (rht - lft + mod) % mod;
}
string call(string s, int l, int r) {
string ans = "";
while (l <= r) ans += s[l++];
return ans;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
pre();
cin >> tc;
while (tc--) {
x = "", y = "", z = "";
cin >> s;
if (s.size() == 1) {
cout << s << "\n";
continue;
}
int l = 0, r = s.size() - 1;
while (l <= r) {
if (l == r) {
x += s[l];
l++, r--;
} else if (s[l] == s[r]) {
x += s[l], y += s[r];
l++, r--;
} else
break;
}
z = "";
while (l <= r) z += s[l++];
s = z;
reverse(z.begin(), z.end());
compute_hash(s);
compute_hash1(z);
pair<int, int> fin = {-1, -1}, fin1 = {-1, -1};
string temp = "", temp1 = "";
int len = s.size();
for (int i = 0; i < s.size(); i++) {
if (compare(1, i + 1) == compare1((len - i), len)) {
fin = {0, i};
}
}
reverse(y.begin(), y.end());
for (int i = 0; i < s.size(); i++) {
if (compare1(1, i + 1) == compare((len - i), len)) {
fin1 = {0, i};
}
}
string mid = "";
if (fin.first != -1 &&
abs(fin.first - fin.second) >= abs(fin1.first - fin1.second))
mid = call(s, fin.first, fin.second);
else if (fin1.first != -1)
mid = call(z, fin1.first, fin1.second);
cout << x + mid + y << "\n";
}
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[110];
int ans[110];
bool use[110];
int main() {
cin >> n >> k;
for (int i = 0; i < k; i++) cin >> a[i];
int cur = 0;
for (int i = 0; i < k; i++) {
int lea = a[i] % (n - i);
for (int j = 0; j < lea; j++) {
if (++cur >= n) cur = 0;
while (use[cur]) {
if (++cur >= n) cur = 0;
}
}
ans[i] = cur + 1;
use[cur] = true;
if (i + 1 < n) {
while (use[cur]) {
if (++cur >= n) cur = 0;
}
}
cout << ans[i] << " ";
}
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[30][2], k;
cin >> n;
k = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < 2; j++) cin >> a[i][j];
for (int i = 0; i < n; i++) {
for (int z = 0; z < n; z++)
if (a[i][0] == a[z][1]) k++;
}
cout << k;
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 6e5 + 10, LG = 21;
int n, m, k, t;
int p[N], in[N], out[N], L[N][LG];
vector<vector<int>> tree(N, vector<int>());
int find_set(int x) { return x == p[x] ? x : p[x] = find_set(p[x]); }
void add_edge(int u, int v) {
tree[u].push_back(v);
tree[v].push_back(u);
}
void dfs(int x, int p) {
static int timer = 0;
in[x] = ++timer;
if (~p) L[x][0] = p;
for (int i = 1; i < LG; ++i) {
L[x][i] = L[L[x][i - 1]][i - 1];
}
for (int to : tree[x]) {
if (to != p) {
dfs(to, x);
}
}
out[x] = ++timer;
}
bool isAnc(int x, int y) { return !x || (in[x] <= in[y] && out[x] >= out[y]); }
int LCA(int x, int y) {
if (isAnc(x, y)) return x;
if (isAnc(y, x)) return y;
for (int i = LG - 1; i >= 0; --i) {
if (!isAnc(L[x][i], y)) {
x = L[x][i];
}
}
return L[x][0];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k >> t;
vector<vector<pair<int, int>>> edges(n + 1, vector<pair<int, int>>());
for (int i = 1; i <= m; ++i) {
int u, v, w;
cin >> u >> v >> w;
edges[u].push_back({v, w});
edges[v].push_back({u, w});
}
priority_queue<vector<ll>> q;
for (int i = 1; i <= k; ++i) {
q.push(vector<ll>{0, i, i});
}
vector<bool> vis(n + 1);
vector<ll> dist(n + 1), cent(n + 1);
while (!q.empty()) {
vector<ll> p = q.top();
q.pop();
ll distance = -p[0];
ll cur_vertex = p[1];
ll central = p[2];
if (vis[cur_vertex]) continue;
vis[cur_vertex] = 1;
dist[cur_vertex] = distance;
cent[cur_vertex] = central;
for (pair<int, int> p : edges[cur_vertex]) {
vector<ll> next = {-distance - p.second, p.first,
p.first <= k ? p.first : central};
q.push(next);
}
}
vector<vector<ll>> v;
for (int i = 1; i <= n; ++i) {
for (pair<int, int> p : edges[i]) {
int to = p.first;
if (cent[i] != cent[to]) {
v.push_back(
vector<ll>{dist[i] + dist[to] + p.second, cent[i], cent[to]});
}
}
}
sort(v.begin(), v.end());
for (int i = 0; i < N; ++i) p[i] = i;
int fake = n + 1;
vector<ll> weight;
for (vector<ll> edge : v) {
int u = edge[1];
int v = edge[2];
ll cost = edge[0];
u = find_set(u);
v = find_set(v);
if (u == v) continue;
weight.push_back(cost);
add_edge(u, fake);
add_edge(v, fake);
p[u] = p[v] = fake;
++fake;
}
dfs(fake - 1, -1);
for (int i = 0; i < t; ++i) {
int a, b;
cin >> a >> b;
int th = LCA(a, b) - n - 1;
cout << weight[th] << '\n';
}
}
| 2,500 | CPP |
from math import ceil, log, floor, sqrt
import math
k = 1
def mod_expo(n, p, m):
"""find (n^p)%m"""
result = 1
while p != 0:
if p%2 == 1:
result = (result * n)%m
p //= 2
n = (n * n)%m
return result
def is_prime(n):
m = 2
while m*m <= n:
if n%m == 0:
return False
m += 1
return True
def find_sum(n, a):
a.insert(0, 0)
for i in range(1, n+1):
prev = a[i] & a[i-1]
cur = a[i] | a[i-1]
a[i-1] = prev
a[i] = cur
return sum(m*m for m in a)
def prin_abc(x, y, z):
l = [x, y, z]
l.sort()
if l[1] < l[2]:
print("NO")
return
a = b = l[0]
c = l[2]
print("YES")
print(a, b, c)
t = 1
t = int(input())
while t:
t = t - 1
points = []
#n = int(input())
x, y, z = map(int, input().split())
#print(discover())
# = map(int, input().split())
#a = list(map(int, input().strip().split()))[:n]
#w = list(map(int, input().strip().split()))[:k]
#for i in range(3):
# x, y = map(int, input().split())
# points.append((x, y))
#s = input()
#if happy_guests(a, b, n, m):
# print("Yes")
# else:
# print("No")
prin_abc(x, y, z)
#print(find_sum(n, a))
| 800 | PYTHON3 |
import sys
n = int(sys.stdin.readline().strip())
print('YES' if (n > 2) and not (n % 2) else 'NO')
| 800 | PYTHON3 |
n,l = map(int,input().split())
d = [int(i) for i in input().split()]
d = list(set(d))
d.sort()
dd= [2*(d[0]-0),2*(l-d[len(d)-1])]
for i in range(len(d)-1):
dd.append(d[i+1]-d[i])
dd.sort()
print(dd[len(dd)-1]/2)
| 1,200 | PYTHON3 |
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
n=int(input())
l=[]
for i in range(n):
l.append(list(map(int,input().split())))
l.sort()
b=0
ans=0
for i in l:
if i[1]<b:
ans+=1
b=max(b,i[1])
print(ans)
| 1,500 | PYTHON3 |
n=int(input())
if n%2>0:
print((-1)**n*(n+1)//2)
else:
print(n//2)
| 800 | PYTHON3 |
s=input()
t=input()
s_c = 0
# t_c = 0
for k in t:
if k == s[s_c]:
s_c += 1
print(s_c + 1) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long mnx = 2e9, mny = 2e9, mxx = -2e9, mxy = -2e9;
long long n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
mnx = min(mnx, x);
mxx = max(mxx, x);
mny = min(mny, y);
mxy = max(mxy, y);
}
cout << max((mxx - mnx), (mxy - mny)) * max((mxx - mnx), (mxy - mny)) << endl;
return 0;
}
| 1,300 | CPP |
def f(k, c):
e = s = 0
for i in range(n):
if (i-c)%k != 0:
if a[i] == 1:
e += 1
else:
s += 1
#print(k, c, e,s)
return abs(e-s)
read = lambda: map(int, input().split())
n, k = read()
a = list(read())
mx = 0
for c in range(0, k):
mx = max(mx, f(k,c))
print(mx) | 1,000 | PYTHON3 |
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
inp = lambda: list(map(int,sys.stdin.readline().rstrip("\r\n").split()))
mod = 10**9+7; Mod = 998244353; INF = float('inf')
#______________________________________________________________________________________________________
# from math import *
# from bisect import *
# from heapq import *
# from collections import defaultdict as dd
# from collections import OrderedDict as odict
# from collections import Counter as cc
# from collections import deque
# sys.setrecursionlimit(2*10**5+100) #this is must for dfs
# ______________________________________________________________________________________________________
# segment tree for range minimum query
# n = int(input())
# a = list(map(int,input().split()))
# st = [float('inf') for i in range(4*len(a))]
# def build(a,ind,start,end):
# if start == end:
# st[ind] = a[start]
# else:
# mid = (start+end)//2
# build(a,2*ind+1,start,mid)
# build(a,2*ind+2,mid+1,end)
# st[ind] = min(st[2*ind+1],st[2*ind+2])
# build(a,0,0,n-1)
# def query(ind,l,r,start,end):
# if start>r or end<l:
# return float('inf')
# if l<=start<=end<=r:
# return st[ind]
# mid = (start+end)//2
# return min(query(2*ind+1,l,r,start,mid),query(2*ind+2,l,r,mid+1,end))
# ______________________________________________________________________________________________________
# Checking prime in O(root(N))
# def isprime(n):
# if (n % 2 == 0 and n > 2) or n == 1: return 0
# else:
# s = int(n**(0.5)) + 1
# for i in range(3, s, 2):
# if n % i == 0:
# return 0
# return 1
# def lcm(a,b):
# return (a*b)//gcd(a,b)
# ______________________________________________________________________________________________________
# nCr under mod
# def C(n,r,mod):
# if r>n:
# return 0
# num = den = 1
# for i in range(r):
# num = (num*(n-i))%mod
# den = (den*(i+1))%mod
# return (num*pow(den,mod-2,mod))%mod
# ______________________________________________________________________________________________________
# For smallest prime factor of a number
# M = 2*(10**5)+10
# pfc = [i for i in range(M)]
# def pfcs(M):
# for i in range(2,M):
# if pfc[i]==i:
# for j in range(i+i,M,i):
# if pfc[j]==j:
# pfc[j] = i
# return
# pfcs(M)
# ______________________________________________________________________________________________________
def flush():
sys.stdout.flush()
tc = 1
tc, = inp()
for _ in range(tc):
n, = inp()
a = inp()
Min = 0
for i in range(n):
if a[i]<Min:
print("NO")
break
if i+1<n:
a[i+1]+= a[i]-Min
Min+=1
else:
print("YES") | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return (b == 0 ? a : gcd(b, a % b)); }
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
int GCD = ar[0];
if (n == 1) {
cout << "Yes\n";
} else {
for (int i = 1; i < n; i++) {
GCD = gcd(GCD, ar[i]);
}
for (int i = 0; i < n; i++) {
ar[i] /= GCD;
}
for (int i = 0; i < n; i++) {
if (ar[i] == 1) {
continue;
} else {
if (ar[i] % 2 == 0) {
while (ar[i] % 2 == 0) ar[i] /= 2;
}
if (ar[i] % 3 == 0) {
while (ar[i] % 3 == 0) ar[i] /= 3;
}
}
}
bool ans = true;
for (int i = 0; i < n; i++) {
if (ar[i] != 1) {
cout << "No\n";
ans = false;
break;
}
}
if (ans) {
cout << "Yes\n";
}
}
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010, M = 1000010, P = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const int INF = 0xcfcfcfcf;
const double eps = 1e-9, pi = asin(1) * 2;
long long read();
int ADD(int a, int b) { return a + b >= P ? a + b - P : a + b; }
int MINUS(int a, int b) { return a - b < 0 ? a - b + P : a - b; }
int n, k, odd = 0, even = 0;
long long read() {
long long s = 0;
bool flag = false;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') flag = true;
for (; '0' <= ch && ch <= '9'; ch = getchar())
s = (s << 3) + (s << 1) + (ch ^ '0');
if (flag) return -s;
return s;
}
int main() {
n = read(), k = read();
for (int i = 1; i <= n; i++) {
int x = read();
if (x & 1)
odd++;
else
even++;
}
if (k == 0) {
printf("Daenerys\n");
return 0;
}
if (k == n) {
if (odd & 1)
printf("Stannis\n");
else
printf("Daenerys\n");
return 0;
}
if (n - k & 1) {
if (odd > even) {
if (even <= n - k >> 1) {
if ((odd + even) - (n - k) & 1)
printf("Stannis\n");
else
printf("Daenerys\n");
} else
printf("Stannis\n");
} else {
if (odd <= n - k >> 1)
printf("Daenerys\n");
else
printf("Stannis\n");
}
} else {
if (odd >= even) {
if (even <= (n - k >> 1)) {
if ((odd + even) - (n - k) & 1)
printf("Stannis\n");
else
printf("Daenerys\n");
} else
printf("Daenerys\n");
} else
printf("Daenerys\n");
}
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T power(T N, T P) {
return (P == 0) ? 1 : N * power(N, P - 1);
}
template <class T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
int dx[] = {0, 1, 0, -1, -1, 1, 1, -1};
int dy[] = {1, 0, -1, 0, 1, 1, -1, -1};
int xx[] = {-1, 1, 2, 2, 1, -1, -2, -2};
int yy[] = {2, 2, 1, -1, -2, -2, -1, 1};
int main() {
int n, k, i, ans, maxi, cnt, beg, end, mid;
string st;
while (scanf("%d %d", &n, &k) == 2) {
cin >> st;
ans = 1000000;
cnt = maxi = 0;
for (i = 0; i < st.size(); i++) {
if (st[i] == '0') {
if (cnt == 0) beg = i;
cnt++;
}
if (cnt == k + 1) {
end = i;
mid = (beg + end) / 2;
while (st[mid] != '0') mid++;
maxi = max(mid - beg, end - mid);
ans = min(ans, maxi);
mid = (beg + end) / 2;
while (st[mid] != '0') mid--;
maxi = max(mid - beg, end - mid);
ans = min(ans, maxi);
cnt--;
beg++;
while (st[beg] != '0') beg++;
}
}
printf("%d\n", ans);
}
return 0;
}
| 1,600 | CPP |
n,m=map(int,input().split())
p,q,c=0,0,0
for i in range(n):
v=input()
for j in range(m):
if(v[j]=='B'):
p+=i;q+=j;c+=1;
print(p//c+1,q//c+1); | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
if (s.length() == 1 || s.length() == 2) {
cout << s << endl;
return 0;
}
for (int i = 0; i < s.length() - 2; i++) {
if (s[i + 1] == s[i]) {
if (s[i + 2] == s[i]) {
s.erase(i, 1);
i--;
} else if (s.length() - i >= 4) {
if (s[i + 2] == s[i + 3]) {
s.erase(i + 2, 1);
i--;
}
}
}
}
cout << s << endl;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
#pragma GCC target("pclmul")
using ul = std::uint32_t;
using ull = std::uint64_t;
using li = std::int32_t;
using ll = std::int64_t;
using uss = std::uint8_t;
const ul maxlen = 2e5;
class sam_t {
public:
ul las;
class node {
public:
ul ch[26];
ul len = 0;
ul fa = 0;
ul cnt = 0;
node() { std::memset(ch, 0, sizeof(ch)); }
};
std::vector<node> st = std::vector<node>(maxlen + maxlen);
void add(ul c) {
ul p = las;
ul np = las = st.size();
st.push_back(node());
st[np].len = st[p].len + 1;
for (; p && !st[p].ch[c]; p = st[p].fa) {
st[p].ch[c] = np;
}
if (!p) {
st[np].fa = 1;
} else {
ul q = st[p].ch[c];
if (st[q].len == st[p].len + 1) {
st[np].fa = q;
} else {
ul nq = st.size();
st.push_back(node());
st[nq] = st[q];
st[nq].len = st[p].len + 1;
st[q].fa = st[np].fa = nq;
for (; p && st[p].ch[c] == q; p = st[p].fa) {
st[p].ch[c] = nq;
}
}
}
}
void init() {
las = 1;
st.resize(0);
st.resize(2);
}
};
sam_t samt;
sam_t samr;
char str[maxlen + 2];
ul tlas[maxlen + 1];
ul rlas[maxlen + 2];
ul n;
ul ord[maxlen + maxlen];
int main() {
std::scanf("%s", str + 1);
ul len = std::strlen(str + 1);
samt.init();
samr.init();
tlas[0] = 1;
for (ul i = 1; i <= len; ++i) {
samt.add(str[i] - 'a');
tlas[i] = samt.las;
}
rlas[len + 1] = 1;
for (ul i = len; i >= 1; --i) {
samr.add(str[i] - 'a');
rlas[i] = samr.las;
}
std::scanf("%u", &n);
for (ul i = 1; i <= n; ++i) {
std::scanf("%s", str + 1);
ul len = std::strlen(str + 1);
ul curr = 1;
for (ul i = 1; i <= len; ++i) {
curr = samt.st[curr].ch[str[i] - 'a'];
}
if (curr) {
++samt.st[curr].cnt;
}
curr = 1;
for (ul i = len; i >= 1; --i) {
curr = samr.st[curr].ch[str[i] - 'a'];
}
if (curr) {
++samr.st[curr].cnt;
}
}
for (ul i = 1; i != samt.st.size(); ++i) {
ord[i] = i;
}
std::sort(ord + 1, ord + samt.st.size(),
[&](ul a, ul b) { return samt.st[a].len < samt.st[b].len; });
for (ul it = 2; it != samt.st.size(); ++it) {
ul i = ord[it];
samt.st[i].cnt += samt.st[samt.st[i].fa].cnt;
}
for (ul i = 1; i != samr.st.size(); ++i) {
ord[i] = i;
}
std::sort(ord + 1, ord + samr.st.size(),
[&](ul a, ul b) { return samr.st[a].len < samr.st[b].len; });
for (ul it = 2; it != samr.st.size(); ++it) {
ul i = ord[it];
samr.st[i].cnt += samr.st[samr.st[i].fa].cnt;
}
ull ans = 0;
for (ul i = 0, j = 1; i <= len; ++i, ++j) {
ans += ull(samt.st[tlas[i]].cnt) * ull(samr.st[rlas[j]].cnt);
}
std::printf("%llu\n", ans);
return 0;
}
| 2,400 | CPP |
s = input().lower()
t = ""
for i in range(len(s)):
if s[i] in "aeiouy":
continue
else:
t+='.'
t+=s[i]
print(t)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int num[200];
int main() {
int n;
cin >> n;
string name[3] = {"Kuro", "Shiro", "Katie"};
int cnt[3];
string s[3];
cin >> s[0] >> s[1] >> s[2];
int len = s[0].length();
int fuck[3];
for (int i = 0; i < 3; i++) {
memset(num, 0, sizeof(num));
for (int j = 0; j < len; j++) {
num[s[i][j]]++;
}
int tmp = 0;
for (int j = 'A'; j <= 'z'; j++) {
if (num[j] == len && n == 1)
num[j] = len - 1;
else
num[j] += n;
if (num[j] > len) num[j] = len;
tmp = max(tmp, num[j]);
}
cnt[i] = tmp;
fuck[i] = cnt[i];
}
sort(fuck, fuck + 3);
if (fuck[2] == fuck[1])
cout << "Draw" << endl;
else if (cnt[0] > cnt[1] && cnt[0] > cnt[2])
cout << name[0] << endl;
else if (cnt[1] > cnt[0] && cnt[1] > cnt[2])
cout << name[1] << endl;
else
cout << name[2] << endl;
return 0;
}
| 1,800 | CPP |
n=int(input())
a=[int(i) for i in input().split()]
b=[int(i) for i in input().split()]
c=[0]*(n+1)
p=0
for i in range(n):
c[a[i]]=i+1
for i in range(n):
if c[b[i]]>p:
print(c[b[i]]-p,end=' ')
p=c[b[i]]
else:
print(0,end=' ')
| 1,000 | PYTHON3 |
n = int(input())
res = 0
for i in range(n):
a = list(map(int, input().split()))
res += (sum(a) > 1)
print(res) | 800 | PYTHON3 |
import math;
def printDivisors(n) :
arr = [];
i = 1;
while i <= math.sqrt(n):
if (n % i == 0) :
# If divisors are equal, print only one
if (n / i == i) :
arr.append(i)
else :
# Otherwise print both
arr.append(i);
arr.append(n//i);
i = i + 1
return arr;
t = int(input());
for test in range(t):
n,k = map(int,input().split());
arr = printDivisors(n);
arr.sort();
#print(arr);
print(n+arr[1] + 2*(k-1));
| 900 | PYTHON3 |
ns = list(map(int, str.split(input())))
top = min(ns[1], ns[-1])
middle = max(ns[1], ns[-1]) - top
down = ns[1] + ns[2] - top - middle
triangles = (1 + ns[0] * 2 + top - 1) * top
triangles += middle * (ns[0] + top) * 2
triangles += (1 + ns[3] * 2 + down - 1) * down
print(triangles)
| 1,600 | PYTHON3 |
t = int(input())
for i in range(t):
a = input().split()
a = [int(x) for x in a]
e = 0
o = 0
for j in a:
if j%2 ==0:
e+=1
else:
o+=1
if o<=1:
print("Yes")
else:
if 0 in a[:-1]:
if o>1:
print("No")
else:
print("Yes")
else:
if o == 2:
print("No")
else:
print("Yes")
| 1,000 | PYTHON3 |