solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
n, m = map(int, input().split())
L = list(map(int, input().split()))
T = [0 for _ in range(m)]
for k in range(n):
T[L[k]-1]+=1
r = 0
for i in range(m-1):
for j in range(i+1,m):
r+= T[i]*T[j]
print(r)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void guan() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
const int maxn = 2234567;
const int mod = 1e9 + 7;
const long long MAXX = (1ll << 62) - 1 + (1ll << 62);
long long dp[1010][1010];
void init() {
dp[1][0] = 1;
dp[1][1] = 1;
dp[2][0] = 3;
dp[2][1] = 3;
dp[2][2] = 1;
int n = 1005;
for (int i = 3; i <= n; i++) {
dp[i][0] = 0;
for (int j = 0; j <= i - 2; j++) dp[i][0] += dp[i - 1][j];
dp[i][0] += i;
dp[i][0] %= mod;
dp[i][1] = dp[i][0];
long long sum = dp[i][0];
for (int j = 2; j <= i; j++) {
sum = sum - dp[i - 1][j - 2];
if (j % 2 == 0) sum -= 1;
sum += mod + mod;
sum %= mod;
dp[i][j] = sum;
}
}
}
int ans = 0;
int vis[maxn];
int cnt = 0;
void dfs(int l, int n, int u, int fa) {
if (l + 1 <= n - 1) dfs(l + 1, n - 1, ++cnt, u);
if (l > 0) dfs(l - 1, n - 1, ++cnt, u);
if (l + n == 6) {
}
if (fa != -1 && !vis[u] && !vis[fa]) {
vis[u] = vis[fa] = 1;
ans++;
}
}
int main() {
guan();
int T = 1;
int n, k, m;
int x;
string s;
init();
dfs(0, 6, 0, -1);
while (cin >> n) {
cout << dp[n][0] << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, i, x, j, k1;
vector<int> d[100010];
vector<pair<int, int> > ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> x, d[x].push_back(i);
for (i = 1; i < n; i++) {
k1 = k - 1 + (i == 1);
for (j = 0; j < d[i].size(); j++) {
if (!k1 && !d[i - 1].empty()) k1 = k - 1 + (i == 1), d[i - 1].pop_back();
if (!k1 || d[i - 1].empty()) {
cout << -1 << endl;
return 0;
}
k1--;
ans.push_back({d[i - 1].back(), d[i][j]});
}
}
if (ans.size() != n - 1) {
cout << -1 << endl;
return 0;
} else {
cout << n - 1 << endl;
for (i = 0; i < n - 1; i++)
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
| 9 | CPP |
def next(char):
return chr((ord(char) - ord('a') + 1) % 26 + ord('a'))
def generate_curr_from_prev(prev: str, k: int):
if(k == 200):
return prev
else:
return prev[:k] + next(prev[k]) + "a"*(200-k-1)
def solve():
n = int(input().strip())
a = list(map(int, input().strip().split()))
curr = "a"*200
print(curr)
prev = curr
for i in range(n):
curr = generate_curr_from_prev(prev, a[i])
print(curr)
prev = curr
t = int(input().strip())
for _ in range(t):
solve()
| 7 | PYTHON3 |
import sys
import math
import itertools
import collections
def sieve(n):
prime = [True for i in range(n + 1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 1
prime[0] = prime[1] = False
r = [p for p in range(n + 1) if prime[p]]
return r
def divs(n, start=1):
r = []
for i in range(start, int(math.sqrt(n) + 1)):
if (n % i == 0):
if (n / i == i):
r.append(i)
else:
r.extend([i, n // i])
return r
def cdiv(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def wr(arr): return ''.join(map(str, arr))
def revn(n): return str(n)[::-1]
def prime(n):
if n == 2: return True
if n % 2 == 0 or n <= 1: return False
sqr = int(math.sqrt(n)) + 1
for d in range(3, sqr, 2):
if n % d == 0: return False
return True
def convn(number, base=3):
newnumber = ''
while number > 0:
newnumber = str(number % base) + newnumber
number //= base
return newnumber
t = ii()
for _ in range(t):
x, y = mi()
if x == y or x > 3 or x == 2 and y <= 3 or x == 3 and y <= 3:
print('YES')
else:
print('NO')
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
long long a,cnt=1,j=0;
cin>>a;
while(a>=1)
{
cnt*=2;
a/=2;
}
cout<<cnt-1;
}
| 0 | CPP |
n, total = map(int, input().split())
time = list(map(int, input().split()))
final = [0]
new = [time[0]]
till_now = time[0]
for i in range(1,n):
till_now+=time[i]
if till_now<=total:
final.append(0)
else:
new.sort(reverse = True)
count = 0
pres = till_now
while(pres>total):
# print(pres, count)
pres-=new[count]
count+=1
final.append(count)
new.append(time[i])
for q in final:
print(q, end=" ")
print() | 9 | PYTHON3 |
s = str(input())
if len(s)>1:
if str.upper(s)==s:
print(str.lower(s))
elif str.upper(s[1:])==s[1:]:
print('{}{}'.format(str.upper(s[0]),str.lower(s[1:])))
else:
print(s)
else:
print('{}'.format(str.swapcase(s))) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
const int MAXN = 1e3 + 10;
int n, m;
char g[MAXN][MAXN];
int row[MAXN], column[MAXN];
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 1; i <= n; ++i) {
scanf("%s", g[i] + 1);
}
memset(row, 0, sizeof(row));
memset(column, 0, sizeof(column));
int num = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (g[i][j] == '*') {
++row[i];
++column[j];
++num;
}
}
}
bool yes = false;
for (int i = 1; i <= n && !yes; ++i) {
for (int j = 1; j <= m; ++j) {
if (g[i][j] == '*' && row[i] + column[j] - 1 == num ||
g[i][j] != '*' && row[i] + column[j] == num) {
printf("YES\n%d %d\n", i, j);
yes = true;
break;
}
}
}
if (!yes) printf("NO\n");
}
return 0;
}
| 8 | CPP |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Dec 3 16:20:22 2019
@author: wwy
"""
p = input()
if "H" in p or "Q" in p or "9" in p:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string A, B;
cin >> A >> B;
B.pop_back();
cout << (A == B ? "Yes\n" : "No\n");
return 0;
} | 0 | CPP |
def main():
n = int(input())
existing = set()
for _ in range(n):
n = input()
if n in existing:
print("YES")
else:
existing.add(n)
print("NO")
if __name__ == '__main__':
main() | 7 | PYTHON3 |
n = int(input())
data = []
for i in range(n):
s = input()
data.append(s)
data.sort(key = len)
flag = 1
for i in range(len(data) - 1):
if data[i] not in data[i+1]:
flag = 0
if flag == 1:
print("YES")
for i in data:
print(i)
else:
print("NO") | 8 | PYTHON3 |
#include <iostream>
using namespace std;
int main(){
int n,a;
while( cin >> n , n ){
a = 0;
while( n != 1 ){
(n%2)? n=n*3+1 : n/=2 ;
a++;
}
cout << a << endl;
}
} | 0 | CPP |
# ===============================================================================================
# importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
# If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
# If the element is already present in the list,
# the right most position where element has to be inserted is returned
# ==============================================================================================
# fast I/O region
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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
# ===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
# ===============================================================================================
# some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") # for fast input
def out(var): sys.stdout.write(str(var)) # for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def zerolist(n): return [0] * n
def nextline(): out("\n") # as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def printlist(a):
for p in range(0, len(a)):
out(str(a[p]) + ' ')
def solve():
n=int(inp())
t=n
c=0
while(t>1):
if t%2==0:
t=(t//2)
elif t%3==0:
t=(2*t)//3
elif t%5==0:
t=(4*t)//5
else:
c=-1
break
c+=1
print(c)
testcase(int(inp()))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
bool f = true;
for (int i = 0; i < 8; i++) {
cin >> str;
for (int j = 1; j < str.length(); j++) {
if (str[j] == str[j - 1]) {
f = false;
}
}
}
if (f)
cout << "YES";
else
cout << "NO";
return 0;
}
| 7 | CPP |
a = []
for i in range(2):
n, b = map(int, input().split())
a.append(0)
for x in map(int, input().split()):
a[-1] = a[-1] * b + x
print('<>='[(a[0] == a[1]) + (a[0] >= a[1])])
| 7 | PYTHON3 |
n=list(map(int,input().strip().split()))
for i in range(n[1]):
if n[0]>0:
if n[0]%10==0:
n[0]=n[0]/10
else:
n[0]=n[0]-1
print(int(n[0]))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
Point() {}
Point(int a, int b) { x = a, y = b; }
} usetree[4];
vector<int> op;
char trans[4] = {'R', 'U', 'D', 'L'};
int step[4][2] = {{1, 0}, {0, 1}, {0, -1}, {-1, 0}};
int pre[505][505];
int m, stx, sty, shax, shay;
bool vis[405][405], tree[405][405];
int ax[1005], ay[1005];
string ans;
queue<Point> q;
bool in(int x, int y) { return x >= 0 && x <= 300 && y >= 0 && y <= 300; }
void bfs() {
while (!q.empty()) {
Point x = q.front();
q.pop();
for (int d = 0; d < 4; ++d) {
int tx = x.x + step[d][0], ty = x.y + step[d][1];
if (in(tx, ty) && !tree[tx][ty] && !vis[tx][ty]) {
vis[tx][ty] = 1;
pre[tx][ty] = d;
if (tx == shax && ty == shay) return;
q.push(Point(tx, ty));
}
}
}
}
bool move(int dir) {
stx += step[dir][0], sty += step[dir][1], shax += step[dir][0],
shay += step[dir][1];
ans += trans[dir];
if (in(shax, shay) && tree[shax][shay]) {
shax -= step[dir][0], shay -= step[dir][1];
return 1;
}
return 0;
}
void back(int x, int y) {
if (x == stx && y == sty) return;
op.push_back(pre[x][y]);
back(x - step[pre[x][y]][0], y - step[pre[x][y]][1]);
}
void init() {
while (stx >= 0 && stx <= 300 || shax >= 0 && shax <= 300) move(0);
while (sty >= 0 && sty <= 300 || shay >= 0 && shay <= 300) move(1);
}
void up() {
init();
while (shay <= 300) move(1);
while (shax != usetree[1].x) move(shax < usetree[1].x ? 0 : 3);
while (sty != shay) move(2);
}
void down() {
init();
while (shay >= 0) move(2);
while (shax != usetree[2].x) move(shax < usetree[2].x ? 0 : 3);
while (sty != shay) move(1);
}
void left() {
init();
while (shax >= 0) move(3);
while (shay != usetree[3].y) move(shay < usetree[3].y ? 1 : 2);
while (stx != shax) move(0);
}
void right() {
init();
while (shax <= 300) move(0);
while (shay != usetree[0].y) move(shay < usetree[0].y ? 1 : 2);
while (stx != shax) move(3);
}
void improve() {
if (sty > shay) up();
if (sty < shay) down();
if (stx < shax) left();
if (stx > shax) right();
}
void work() {
back(shax, shay);
reverse(op.begin(), op.end());
for (int i = 0; i < op.size(); ++i) {
bool ok = move(op[i]);
if (!ok) op.push_back(op[i]);
if (stx == shax && sty == shay) return;
if (!in(stx, sty)) break;
}
improve();
}
int main() {
ios::sync_with_stdio(0);
cin >> stx >> sty >> shax >> shay >> m;
stx += 150, sty += 150, shax += 150, shay += 150;
usetree[3].x = usetree[2].y = 1e9;
usetree[0].x = usetree[1].y = -1e9;
for (int i = 1; i <= m; ++i) {
cin >> ax[i] >> ay[i];
ax[i] += 150, ay[i] += 150;
if (usetree[0].x < ax[i]) usetree[0] = Point(ax[i], ay[i]);
if (usetree[1].y < ay[i]) usetree[1] = Point(ax[i], ay[i]);
if (usetree[2].y > ay[i]) usetree[2] = Point(ax[i], ay[i]);
if (usetree[3].x > ax[i]) usetree[3] = Point(ax[i], ay[i]);
vis[ax[i]][ay[i]] = tree[ax[i]][ay[i]] = 1;
}
if (!m) {
cout << -1;
return 0;
}
q.push(Point(stx, sty));
bfs();
if (!vis[shax][shay]) {
cout << -1;
return 0;
}
ans = "";
work();
cout << ans;
return 0;
}
| 11 | CPP |
def ans(x):
sum=0
if n1*x-nb>0:
sum=sum+(n1*x-nb)*pb
if n2*x-ns>0:
sum=sum+(n2*x-ns)*ps
if n3*x-nc>0:
sum=sum+(n3*x-nc)*pc
if r>=sum:
return 1
else:
return 0
s=input()
a=list(input().split())
nb=int(a[0])
ns=int(a[1])
nc=int(a[2])
q=list(input().split())
pb=int(q[0])
ps=int(q[1])
pc=int(q[2])
r=int(input())
n1=s.count("B")
n2=s.count("S")
n3=s.count("C")
low=0
c=0
high=r+max(nb,ns,nc)
while high>low+1:
if ans(high):
print(high)
c=1
break
mid=(low+high)//2
if (ans(mid)):
if low==mid:
break
low=mid
if (1-ans(mid)):
high=mid
if c==0:
print(low) | 9 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string k;cin>>k;
cout<<k.substr(0,3)<<endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> x(n);
vector<int> y(n);
int mi, mx;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
if (i == 0) {
mi = x[i];
mx = y[i];
} else {
mi = min(x[i], mi);
mx = max(y[i], mx);
}
}
bool t = 0;
for (int i = 0; i < n; i++) {
if (x[i] == mi && y[i] == mx) {
cout << i + 1;
t = 1;
break;
}
}
if (!t) cout << -1;
return 0;
}
| 8 | CPP |
n = int(input())
s = list(input())
types = len(set(s))
def check(l) :
mp = dict()
for i in range(l):
if s[i] not in mp :
mp[s[i]]=1
else :
mp[s[i]]+=1
if len(mp) == types :
return True
for i in range(l,n) :
mp[s[i-l]]-=1
if mp[s[i-l]] is 0 :
mp.pop(s[i-l])
if s[i] not in mp :
mp[s[i]]=1
else :
mp[s[i]]+=1
if len(mp) == types :
return True
return False
l,r = 1 , n
while l < r :
mid = (l+r)//2
if check(mid) :
r = mid
else :
l = mid + 1
print(r) | 9 | PYTHON3 |
testcases = int(input())
while(testcases>0):
testcases = testcases - 1
a,b,n,S = map(int,input().split())
if(a*n + b < S):
print("NO")
else:
num = S//n
num = min(num , a)
if(num*n + b >=S):
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int t[n];
for (int i = 0; i < n; i++) {
cin >> t[i];
}
sort(t, t + n);
int x, ans = 0, p;
for (int i = 0; i < n; i++) {
x = 0;
for (int j = i; j < n; j++) {
if (t[j] - t[i] > d) break;
x++;
}
ans = max(ans, x);
}
cout << n - ans;
return 0;
}
| 7 | CPP |
#include<bits/stdc++.h>
using namespace std;
int n,a[20000010];
bool s(int i,int j,int k)
{
return a[i]<=k&&a[j]<=k;
}
bool b(int i,int j,int k)
{
return a[i]>k&&a[j]>k;
}
bool check(int k)
{
for(int i=0;i<n-1;i++)
{
if(b(n+i,n+i+1,k)||b(n-i,n-i-1,k))
return 0;
if(s(n+i,n+i+1,k)||s(n-i,n-i-1,k))
return 1;
}
return s(1,1,k);
}
int main()
{
scanf("%d",&n);
int nn=2*n-1,l=1,r=nn;
for(int i=1;i<=nn;i++)
scanf("%d",&a[i]);
while(l<r)
{
int mid=l+(r-l)/2;
if(check(mid))
r=mid;
else
l=mid+1;
}
printf("%d\n",r);
return 0;
} | 0 | CPP |
n = int(input())
if n % 10 < 5:
n = n // 10 * 10
else:
n = (n // 10 + 1) * 10
print(n)
| 7 | PYTHON3 |
from collections import defaultdict
import math
al={}
a=int(input())
al=defaultdict(lambda:math.inf,al)
for i in range(a):
x,y=input().split()
y=sorted(y)
if('A' in y):
al['A']=min(al['A'],int(x))
if('B' in y):
al['B']=min(al['B'],int(x))
if('C' in y):
al['C']=min(al['C'],int(x))
if(('A' in y) and ('B' in y)):
al['AB']=min(al['AB'],int(x))
if(('C' in y) and ('B' in y)):
al['BC']=min(al['BC'],int(x))
if(('A' in y) and ('B' in y) and ('C' in y)):
al['ABC']=min(al['ABC'],int(x))
if(('A' in y) and ('C' in y)):
al['AC']=min(al['AC'],int(x))
temp=min(al['A']+al['BC'],al['B']+al['AC'],al['C']+al['AB'],al['ABC'],al['A']+al['B']+al['C'])
if(temp==math.inf):
print(-1)
else:
print(temp)
| 8 | PYTHON3 |
input()
a=list(map(int,input().split()))
sum=0
flag=False
for i in range(len(a)):
if i==a[i]:
sum+=1
elif a[a[i]]==i and not flag:
sum+=2
flag=True
if not flag and sum!=len(a):
sum+=1
print(sum)
| 8 | PYTHON3 |
n=int(input())
m=list(input())
a=m.count("A")
d=m.count("D")
if a>d:
print("Anton")
elif d>a:
print("Danik")
else:
print("Friendship") | 7 | PYTHON3 |
n, L, v1, v2, k = map(int, input().split())
n = (n + k - 1) // k * 2
dif = v2 - v1
p1 = (n * v2 - dif) * L
p2 = (n * v1 + dif) * v2
ans = p1 / p2
print(ans)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
string a[100005];
int b[2][100005], n, m, ans, ok;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[0][i] = 0;
}
ok = 1;
ans = 0;
for (int j = 0; j < m; j++) {
ok = !ok;
for (int i = 2; i <= n; i++) {
if (b[ok][i])
b[!ok][i] = 1;
else {
if (a[i - 1][j] > a[i][j]) {
ok = !ok;
ans++;
break;
} else if (a[i - 1][j] == a[i][j])
b[!ok][i] = 0;
else
b[!ok][i] = 1;
}
}
}
cout << ans << endl;
return 0;
}
| 7 | CPP |
l = []
for i in range(4):
a = []
s = input()
for char in s:
if char == '#':
a.append(0)
else:
a.append(1)
l.append(a)
for i in range(3):
for j in range(3):
if (l[i][j]^l[i][j+1])^(l[i+1][j]^l[i+1][j+1]):
print("YES")
exit(0)
if (l[i][j]==l[i][j+1]) and (l[i+1][j]==l[i+1][j+1]) and (l[i][j]==l[i+1][j]):
print("YES")
exit(0)
print("NO") | 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N=2e3+7;
ll dp[N][N];
struct stu{
ll value,id;
bool friend operator<(const stu &x,const stu &y){
return x.value>y.value;
}
}arr[N];
int main(){
ll n;
cin>>n;
for(ll i=1;i<=n;i++) {
cin>>arr[i].value;
arr[i].id=i;
}
sort(arr+1,arr+1+n);
for(ll i=1;i<=n;i++){
for(ll l=0;l<i;l++){
ll r=i-1-l;
dp[l+1][r]=max(dp[l+1][r],dp[l][r]+arr[i].value*abs(arr[i].id-l-1));
dp[l][r+1]=max(dp[l][r+1],dp[l][r]+arr[i].value*abs(n-r-arr[i].id));
}
}
ll ans=0;
for(int i=0;i<=n;i++) ans=max(ans,dp[i][n-i]);
cout<<ans<<endl;
return 0;
} | 0 | CPP |
import sys
x=input()
hello='hello'
for i in hello:
if i in x:
x=x[x.index(i)+1:]
else:
print('NO')
sys.exit(0)
print('YES')
| 7 | PYTHON3 |
n=int(input())
arr=list(map(int,input().split(' ')))
mx=max(arr)
win=arr.index(mx)
print(win+1,end=' ')
arr[win]=0
print(max(arr)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (a == 0 && b == 0) {
cout << "NO";
return 0;
}
if (abs(a - b) > 1) {
cout << "NO";
} else
cout << "YES";
return 0;
}
| 7 | CPP |
for t in range(int(input())):
a, b, c, d=[int(i) for i in input().split()]
if b==c:
print(b,d)
else:
print(b,c) | 7 | PYTHON3 |
#include<iostream>
#include<assert.h>
template<typename T>
void swap(T &a,T &b){
T x=a;
a=b;
b=x;
}
int dif(int x,int y){return x-y>=0?x-y:y-x;}
const int N = 4;
int st[N*N];
int calc(int i,int j){
if(st[i*N+j]<0) return 0;
int res=0;
res+=dif(i,st[i*N+j]/N);
res+=dif(j,st[i*N+j]%N);
return res;
}
int dist=0,ans=45;
int check(int cur){
if(dist==0&&ans>cur) ans=cur;
int val=cur+dist;
return val<ans;
}
int dy[]={0,0,1,-1};
int dx[]={1,-1,0,0};
int in(int y,int x){return 0<=y&&y<N&&0<=x&&x<N;};
void dfs(int di,int y,int x,int p){
for(int k=0;k<4;k++){
if((p>=0)&&((p^1)==k)) continue;
int ny=y+dy[k],nx=x+dx[k];
if(!in(ny,nx)) continue;
dist-=calc(ny,nx);
swap(st[y*N+x],st[ny*N+nx]);
dist+=calc(y,x);
if(check(di+1)) dfs(di+1,ny,nx,k);
dist-=calc(y,x);
swap(st[y*N+x],st[ny*N+nx]);
dist+=calc(ny,nx);
}
}
int main(){
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
std::cin>>st[i*N+j],st[i*N+j]--;
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
dist+=calc(i,j);
int y=-1,x=-1;
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
if(st[i*N+j]<0) y=i,x=j;
check(0);
dfs(0,y,x,-1);
std::cout<<ans<<std::endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
string shag;
for (int i = 0; i < 5; i++) {
cin >> shag;
if ((s[0] == shag[0]) || (s[1] == shag[1])) {
cout << "YES";
break;
}
if (i == 4) cout << "NO";
}
}
| 7 | CPP |
A,B=map(int,input().split())
if max(A,B)>=9:
print(":(")
else:
print("Yay!") | 0 | PYTHON3 |
a=list(map(int,input().split()))
#print(max(a[0],a[1],a[2],a[3]))
a.sort()
print(a[3]-a[0],a[3]-a[1],a[3]-a[2])
| 7 | PYTHON3 |
n , m = input().split()
n = int(n)
m = int(m)
s = 0
words = input().split()
words = [int(word) for word in words]
for x in words :
print((x+s)//m)
s = (x+s) % m
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
map<long long int, vector<long long int>> f;
for (long long int i = 0; i < n; i++) {
long long int temp;
cin >> temp;
f[temp].push_back(i + 1);
}
if ((*(f.begin())).second.size() > 1) {
cout << "Still Rozdil";
} else {
cout << f.begin()->second[0];
}
return 0;
}
| 7 | CPP |
import math
def primeFactors(n):
while n % 2 == 0:
l.append(2)
n = n // 2
for i in range(3, int(math.sqrt(n))+1, 2):
while n % i == 0:
l.append(i)
n = n // i
if n > 2:
l.append(n)
x=int(input())
for i in range(x):
n=int(input())
if n%2==0:
print(n//2,end=" ")
print(n//2)
else:
l=[]
primeFactors(n)
if len(l)==1:
print(1,end=" ")
print(n-1)
else:
print(n//min(l),end=" ")
print(n-n//min(l)) | 8 | PYTHON3 |
#include <iostream>
#include <algorithm>
#include <map>
#include <math.h>
using namespace std;
pair<int, int> p[200005];
int a[200005];
int mx[200005 << 2], mi[200005 << 2];
int add[200005 << 2];
void pushUp(int l, int r, int rt) {
mx[rt] = max(mx[rt << 1], mx[rt << 1 | 1]);
mi[rt] = min(mi[rt << 1], mi[rt << 1 | 1]);
}
void build(int l, int r, int rt) {
mx[rt] = 0;
mi[rt] = 0;
add[rt] = 0;
if (l == r) {
} else {
int mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
}
}
void pushDown(int l, int r, int rt) {
if (add[rt]) {
add[rt << 1] += add[rt];
mx[rt << 1] += add[rt];
mi[rt << 1] += add[rt];
add[rt << 1 | 1] += add[rt];
mx[rt << 1 | 1] += add[rt];
mi[rt << 1 | 1] += add[rt];
add[rt] = 0;
}
}
void Add(int l, int r, int rt, int ql, int qr, int val) {
if (ql <= l && r <= qr) {
add[rt] += val;
mx[rt] += val;
mi[rt] += val;
} else {
int mid = (l + r) >> 1;
pushDown(l, r, rt);
if (ql <= mid) Add(l, mid, rt << 1, ql, qr, val);
if (mid < qr) Add(mid + 1, r, rt << 1 | 1, ql, qr, val);
pushUp(l, r, rt);
}
}
int queryMax(int l, int r, int rt, int ql, int qr) {
if (ql <= l && r <= qr) return mx[rt];
else {
pushDown(l, r, rt);
int mid = (l + r) >> 1;
int ret = -1e9;
if (ql <= mid) ret = max(ret, queryMax(l, mid, rt << 1, ql, qr));
if (mid < qr) ret = max(ret, queryMax(mid + 1, r, rt << 1 | 1, ql, qr));
return ret;
}
}
int queryMin(int l, int r, int rt, int ql, int qr) {
if (ql <= l && r <= qr) return mi[rt];
else {
pushDown(l, r, rt);
int mid = (l + r) >> 1;
int ret = 1e9;
if (ql <= mid) ret = min(ret, queryMin(l, mid, rt << 1, ql, qr));
if (mid < qr) ret = min(ret, queryMin(mid + 1, r, rt << 1 | 1, ql, qr));
return ret;
}
}
int ans[200005];
int cal(int x) {
if (x < 0) return -x - 1;
else return x;
}
int main(void) {
int n;
scanf("%d", &n);
for (int i = 1;i <= n;i++) {
p[i].second = i;
scanf("%d", &p[i].first);
a[i] = p[i].first;
}
sort(p + 1, p + 1 + n);
build(1, n, 1);
for (int i = 1;i <= n;i++) {
Add(1, n, 1, i, i, i);
}
for (int i = 1;i <= n;i++) {
int pos = p[i].second;
int mxL = 0;
int miL = 0;
if (pos > 1) {
mxL = max(mxL, queryMax(1, n, 1, 1, pos - 1));
miL = min(miL, queryMin(1, n, 1, 1, pos - 1));
}
int miR = queryMin(1, n, 1, pos, n);
int mxR = queryMax(1, n, 1, pos, n);
int ret = max(cal(miR - mxL), cal(mxR - miL));
ans[pos] = max(ans[pos], ret / 2);
if (i == n || p[i].first != p[i + 1].first) {
int j = i;
while (j >= 1 && p[j].first == p[i].first) j--;
for (int x = j + 1;x <= i;x++)
Add(1, n, 1, p[x].second, n, -2);
for (int x = j + 1;x <= i;x++) {
pos = p[x].second;
mxL = 0;
miL = 0;
if (pos > 1) {
mxL = max(mxL, queryMax(1, n, 1, 1, pos - 1));
miL = min(miL, queryMin(1, n, 1, 1, pos - 1));
}
miR = queryMin(1, n, 1, pos, n);
mxR = queryMax(1, n, 1, pos, n);
int ret1 = max(cal(miR - mxL), cal(mxR - miL));
ans[pos] = max(ans[pos], ret1 / 2);
}
}
}
for (int i = 1;i <= n;i++) printf("%d ", ans[i]);
puts("");
return 0;
} | 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long n, long long m) {
if (m == 0)
return n;
else
return gcd(m, n % m);
}
int longestsub(string x, string y, int n, int m) {
int lcs[n + 1][m + 1];
int result = 0;
for (int i = 0; i < n + 1; i++) {
for (int j = 0; j < m + 1; j++) {
if (i == 0 || j == 0) {
lcs[i][j] = 0;
} else if (x[i - 1] == y[j - 1]) {
lcs[i][j] = 1 + lcs[i - 1][j - 1];
result = max(result, lcs[i][j]);
} else
lcs[i][j] = 0;
}
}
return result;
}
long long fast_pow(long long a, long long p) {
long long res = 1;
while (p) {
if (p % 2 == 0) {
a = a * 1ll * a % 1000000007;
p /= 2;
} else {
res = res * 1ll * a % 1000000007;
p--;
}
}
return res;
}
long long fact(long long n) {
long long res = 1;
for (int i = 1; i <= n; i++) {
res = res * 1ll * i % 1000000007;
}
return res;
}
long long C(long long n, long long k) {
return fact(n) * 1ll * fast_pow(fact(k), 1000000007 - 2) % 1000000007 * 1ll *
fast_pow(fact(n - k), 1000000007 - 2) % 1000000007;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
int n;
cin >> n;
long long ans = 2 * 3;
for (int i = 3; i < n; i++) {
ans += i * (i + 1);
}
cout << ans << '\n';
}
}
| 10 | CPP |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <cmath>
#include <cstdlib>
#include <stack>
#include <queue>
#include <numeric>
#include <ctime>
using namespace std;
//global var
string card[4][13];
char trump, T;
string ans_team;
int ans_score;
map<char, int> h;
//function
struct State{
int n, id;
char m;
State(){};
State(int n_, int id_, char m_){
n = n_;
id = id_;
m = m_;
};
};
bool operator < (const State &a, const State &b){
if(a.m == trump){
if(b.m == trump){
return (a.n < b.n);
}else{
return false;
}
}else{
if(b.m == trump){
return true;
}else{
if(a.n == b.n){
return (a.id > b.id);
}
return a.n < b.n;
}
}
}
//card state
State get_state(string c, int p, int start){
int n = h[c[0]], id;
char m = c[1];
for(int i = 0, k = start; i < 4; i++, (k = (k + 1) % 4)){
if(k == p){
id = i;
break;
}
}
return State(n, id, m);
}
//solution func
void solve(){
int start = 0;
int NS = 0, EW = 0;
for(int j = 0; j < 13; j++){
int win;
State win_s;
bool flag = false;
for(int i = 0; i < 4; i++){
State s = get_state(card[i][j], i, start);
if(s.m == T){
flag = true;
break;
}
}
if(flag){
trump = T;
}else{
State s = get_state(card[start][j], start, start);
trump = s.m;
}
for(int i = 0; i < 4; i++){
State s = get_state(card[i][j], i, start);
if(i == 0){
win = 0;
win_s = s;
}else if(win_s < s){
win = i;
win_s = s;
}
}
/*
// debug
cout << j << " ";
if(win == 0){
cout << "N";
}
if(win == 1){
cout << "E";
}
if(win == 2){
cout << "S";
}
if(win == 3){
cout << "W";
}
cout << " " << trump << endl;
//
*/
if(win == 0 || win == 2){
NS++;
}
else{
EW++;
}
start = win;
}
if(EW < NS){
ans_team = "NS";
ans_score = NS - 6;
}else{
ans_team = "EW";
ans_score = EW - 6;
}
}
int main(){
h['T'] = 10;
h['J'] = 11;
h['Q'] = 12;
h['K'] = 13;
h['A'] = 14;
for(char c = '2'; c <= '9'; c++){
h[c] = c - '0';
}
while(cin >> T){
if(T == '#'){
break;
}
for(int i = 0; i < 4; i++){
for(int j = 0; j < 13; j++){
cin >> card[i][j];
}
}
solve();
cout << ans_team << " " << ans_score << endl;
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct point {
long long int a, b, c, ind;
};
bool compare1(point p1, point p2) {
if (p1.b < p2.b) return true;
if (p1.b > p2.b) return false;
if (p1.c <= p2.c) return true;
return false;
}
map<long long int, vector<point> > m;
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, i;
cin >> n;
point arr[n];
vector<long long int> final, temp;
for (i = 0; i < n; i++) {
cin >> arr[i].a >> arr[i].b >> arr[i].c;
arr[i].ind = i + 1;
m[arr[i].a].push_back(arr[i]);
}
for (auto u : m) {
sort(u.second.begin(), u.second.end(), compare1);
temp.clear();
for (i = 0; i < u.second.size() - 1;) {
if (u.second[i].b == u.second[i + 1].b) {
cout << u.second[i].ind << " " << u.second[i + 1].ind << "\n";
i += 2;
} else {
temp.push_back(u.second[i].ind);
i += 1;
}
}
if (i == u.second.size() - 1) temp.push_back(u.second[i].ind);
for (i = 1; i < temp.size(); i += 2)
cout << temp[i] << " " << temp[i - 1] << "\n";
if (temp.size() & 1) final.push_back(temp[temp.size() - 1]);
}
for (i = 0; i < final.size(); i += 2)
cout << final[i] << " " << final[i + 1] << "\n";
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> dolls[200005];
vector<pair<int, int> > in_ord, out_ord;
int cost[200005];
long long cnt[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> dolls[i].second >> dolls[i].first;
in_ord.push_back(make_pair(dolls[i].first, i));
out_ord.push_back(make_pair(dolls[i].second, i));
}
sort(in_ord.begin(), in_ord.end());
sort(out_ord.begin(), out_ord.end());
int ptr = 0;
int best_val = 0;
long long best_cnt = 1;
for (auto i : in_ord) {
while (ptr < n && out_ord[ptr].first <= i.first) {
int cur = cost[out_ord[ptr].second] - out_ord[ptr].first;
if (cur < best_val) {
best_val = cur;
best_cnt = cnt[out_ord[ptr].second];
} else if (cur == best_val) {
best_cnt = (best_cnt + cnt[out_ord[ptr].second]) % 1000000007;
}
ptr++;
}
cost[i.second] = best_val + i.first;
cnt[i.second] = best_cnt;
}
long long o = 0;
int min_cost = 1e9;
for (int i = ptr; i < n; i++) {
if (cost[out_ord[i].second] < min_cost) {
min_cost = cost[out_ord[i].second];
o = cnt[out_ord[i].second];
} else if (cost[out_ord[i].second] == min_cost) {
o = (o + cnt[out_ord[i].second]) % 1000000007;
}
}
cout << o << endl;
}
| 11 | CPP |
for _ in range(int(input())):
a,b,c = [int(x) for x in input().split()]
print(int((b**2+(a-c)**2)**0.5)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
const int INF = 2e9;
const long long LINF = 9e18;
const int MOD = 2e9 + 11;
const int p = 37;
const int MAXN = 2 * 1e3;
vector<vector<int>> a(MAXN, vector<int>(MAXN));
vector<vector<bool>> updated(MAXN, vector<bool>(MAXN, false));
int n, m;
const int DX1[] = {0, 1, 0, 1};
const int DY1[] = {0, 0, -1, -1};
const int DX2[] = {0, 0, 1, 1};
const int DY2[] = {0, 1, 0, 1};
const int DX3[] = {0, 0, -1, -1};
const int DY3[] = {0, 1, 0, 1};
const int DX4[] = {0, -1, 0, -1};
const int DY4[] = {0, 0, -1, -1};
void check2(int x1, int y1, pii& s1, int& cnt1) {
if (x1 >= 0 && x1 < m && y1 >= 0 && y1 < n) {
cnt1 += a[y1][x1];
if (a[y1][x1] == 1) s1 = {y1, x1};
} else
cnt1 = -10;
}
void check3(int cnt, pii s, queue<pii>& q) {
if (cnt == 1) {
q.push(s);
}
}
void check(pii cur, queue<pii>& q) {
int cnt1, cnt2, cnt3, cnt4;
cnt1 = cnt2 = cnt3 = cnt4 = 0;
int x = cur.second;
int y = cur.first;
if (updated[y][x]) return;
a[y][x] = 0;
updated[y][x] = true;
pii s1, s2, s3, s4;
for (int i = 0; i < 4; ++i) {
int x1 = x + DX1[i];
int y1 = y + DY1[i];
int x2 = x + DX2[i];
int y2 = y + DY2[i];
int x3 = x + DX3[i];
int y3 = y + DY3[i];
int x4 = x + DX4[i];
int y4 = y + DY4[i];
check2(x1, y1, s1, cnt1);
check2(x2, y2, s2, cnt2);
check2(x3, y3, s3, cnt3);
check2(x4, y4, s4, cnt4);
}
check3(cnt1, s1, q);
check3(cnt2, s2, q);
check3(cnt3, s3, q);
check3(cnt4, s4, q);
}
void check4(int x, int y, int& cnt) {
if (x >= 0 && x < m && y >= 0 && y < n) {
cnt += a[y][x];
} else
cnt = -10;
}
bool satisfies(int y, int x) {
int cnt1 = 0, cnt2 = 0, cnt3 = 0, cnt4 = 0;
for (int i = 0; i < 4; ++i) {
int x1 = x + DX1[i];
int y1 = y + DY1[i];
int x2 = x + DX2[i];
int y2 = y + DY2[i];
int x3 = x + DX3[i];
int y3 = y + DY3[i];
int x4 = x + DX4[i];
int y4 = y + DY4[i];
check4(x1, y1, cnt1);
check4(x2, y2, cnt2);
check4(x3, y3, cnt3);
check4(x4, y4, cnt4);
}
if (cnt1 == 1 || cnt2 == 1 || cnt3 == 1 || cnt4 == 1) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
char c;
cin >> c;
if (c == '.')
a[i][j] = 0;
else
a[i][j] = 1;
}
}
queue<pii> q;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == 1 && satisfies(i, j)) {
q.push({i, j});
}
}
}
while (!q.empty()) {
pii cur = q.front();
q.pop();
check(cur, q);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == 0)
cout << '.';
else
cout << '*';
}
cout << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int a, n, r, b, c, q = 9999999, t, d;
int main() {
cin >> a >> b >> c;
q = b - a;
if (a == b)
cout << "YES";
else if (c == 0)
cout << "NO";
else if (q % c == 0 && ((q >= 0 && c >= 0) || ((q) < 0 && c < 0)))
cout << "YES";
else
cout << "NO";
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100, M = 1010;
int n, m;
long long int c[N], g[N], a1[M], b1[M], a2[M], b2[M];
inline long long int read() {
long long int x = 0, t = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = -1, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * t;
}
inline void init() {
freopen("graph.in", "r", stdin);
freopen("graph.out", "w", stdout);
}
inline void work(long long int x, int n, long long int *d1, long long int *d2) {
if (n == 0) {
d1[n] = d2[n] = 0;
return;
}
if (n == 1) {
d1[n] = (x == 2);
d2[n] = (x == 1);
return;
}
if (x <= c[n - 1]) {
work(x, n - 1, d1, d2);
d1[n] = min(d1[n - 1], d2[n - 1] + 2);
d2[n] = min(d1[n - 1], d2[n - 1]) + 1 + g[n - 2];
} else {
work(x - c[n - 1], n - 2, d1, d2);
d1[n] = d1[n - 2] + 1;
d2[n] = d2[n - 2];
}
}
inline long long int dis(long long int u, long long int v, int n) {
if (n <= 1) return (u != v);
if (u <= c[n - 1]) {
if (v > c[n - 1]) return min(a1[n - 1], a2[n - 1]) + b1[n - 2] + 1;
return min(dis(u, v, n - 1),
min(a1[n - 1] + b2[n - 1], a2[n - 1] + b1[n - 1]) + 2);
} else
return dis(u - c[n - 1], v - c[n - 1], n - 2);
}
int main() {
m = read();
n = read();
n = min(n, 77);
c[0] = 1;
c[1] = 2;
for (register int i = 2; i <= n; i++) c[i] = c[i - 1] + c[i - 2];
g[0] = 0;
g[1] = g[2] = 1;
for (register int i = 3; i <= n; i++) g[i] = g[i - 2] + 1;
while (m--) {
long long int u = read(), v = read();
if (u > v) swap(u, v);
work(u, n, a1, a2);
work(v, n, b1, b2);
printf("%d\n", dis(u, v, n));
}
return 0;
}
| 9 | CPP |
n = int(input())
ctr = any([int(x) for x in input().split()])
print('HARD' if ctr else 'EASY') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long INF = 2e9;
const long long N = 3e5 + 35;
void kudne() {
long long n;
cin >> n;
vector<pair<long long, long long>> st(n);
vector<long long> ed(n);
for (long long i = 0; i < n; ++i) {
cin >> st[i].first >> ed[i];
st[i].second = i;
}
sort(st.begin(), st.end());
long long m;
cin >> m;
vector<pair<long long, long long>> a(m);
vector<long long> b(m), v(m);
for (long long i = 0; i < m; ++i) {
cin >> a[i].first >> b[i] >> v[i];
a[i].second = i;
}
sort(a.begin(), a.end());
vector<long long> ans(n);
set<pair<long long, long long>> s;
long long id = 0;
for (long long i = 0; i < n; ++i) {
while (id < m && a[id].first <= st[i].first) {
long long k = a[id].second;
s.insert({b[k], k});
id++;
}
long long j = st[i].second;
auto it = s.lower_bound({ed[j], -1});
if (it == s.end()) {
cout << "NO";
return;
}
auto p = *it;
ans[j] = p.second + 1;
v[p.second]--;
if (!v[p.second]) s.erase(it);
}
cout << "YES\n";
for (long long x : ans) cout << x << " ";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long tc = 1;
for (long long i = 1; i <= tc; ++i) {
kudne();
if (i < tc) cout << "\n";
}
return 0;
}
| 9 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
int k=n%10;
if(k==2 ||k==4 ||k==5||k==7||k==9)
cout<<"hon";
else if(k==3)
cout<<"bon";
else
cout<<"pon";
return 0;
} | 0 | CPP |
d = []
n = int(input())
for i in range(n):
a,b = map(int,input().split())
d.append([a,-1])
d.append([b,1])
d.sort()
t = 0
for i in d:
t -= i[1]
if t > 2:
print("NO")
exit(0)
print("YES")
# Made By Mostafa_Khaled | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
while (t--) {
long long n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
if (n == 1) {
cout << "1 1\n";
cout << 0 << "\n";
cout << "1 1\n";
cout << 0 << "\n";
cout << "1 1\n";
cout << (-v[0]) << "\n";
} else {
cout << 1 << " " << n << "\n";
for (int i = 0; i < n; i++) cout << (-v[i] * n) << " ";
cout << "\n";
cout << "1 " << n - 1 << "\n";
for (int i = 0; i + 1 < n; i++) cout << v[i] * (n - 1) << " ";
cout << "\n";
cout << 2 << " " << n << "\n";
for (int i = 1; i + 1 < n; i++) cout << "0 ";
cout << (v[n - 1] * (n - 1)) << " ";
cout << "\n";
}
}
}
| 9 | CPP |
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(false);
int n;
std::string s;
std::cin >> n;
std::cin.ignore();
std::getline(std::cin, s);
int r = 0, g = 0, b = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'R') r++;
if (s[i] == 'G') g++;
if (s[i] == 'B') b++;
}
if (r && g && b) {
std::cout << "BGR" << std::endl;
return 0;
}
if (r && g) {
if (r > 1 && g > 1) {
std::cout << "BGR" << std::endl;
} else if (r > 1) {
std::cout << "BG" << std::endl;
} else if (g > 1) {
std::cout << "BR" << std::endl;
} else {
std::cout << "B" << std::endl;
}
return 0;
}
if (r && b) {
if (r > 1 && b > 1) {
std::cout << "BGR" << std::endl;
} else if (r > 1) {
std::cout << "BG" << std::endl;
} else if (b > 1) {
std::cout << "GR" << std::endl;
} else {
std::cout << "G" << std::endl;
}
return 0;
}
if (b && g) {
if (b > 1 && g > 1) {
std::cout << "BGR" << std::endl;
} else if (b > 1) {
std::cout << "GR" << std::endl;
} else if (g > 1) {
std::cout << "BR" << std::endl;
} else {
std::cout << "R" << std::endl;
}
return 0;
}
if (r) {
std::cout << "R" << std::endl;
return 0;
}
if (b) {
std::cout << "B" << std::endl;
return 0;
}
if (g) {
std::cout << "G" << std::endl;
return 0;
}
return 0;
}
| 8 | CPP |
#hello
n=int(input())
A=[int(i) for i in input().split(" ")]
res=0
ans=[]
avg=sum(A)/n
for i in range(n):
if A[i]==avg:
res+=1
ans.append(i+1)
print(res)
print(*ans)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x;
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> x;
sum += abs(x);
}
cout << abs(sum) << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, i, ans;
string pm, pk;
int main() {
long long t;
cin >> t;
while (t--) {
ans = 0;
cin >> n >> pm >> pk;
pm = "0" + pm;
pk = "0" + pk;
for (i = 1; i <= n; i++) {
if (pm[i] == '0' && pk[i] == '1') {
pm[i] = '2';
ans++;
} else if (i > 1 && pk[i] == '1' && pm[i - 1] == '1') {
pm[i - 1] = '2';
ans++;
} else if (i < n && pk[i] == '1' && pm[i + 1] == '1') {
pm[i + 1] = '2';
ans++;
}
}
cout << ans << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, k, gyz;
long long mod_pow(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) ans = ans * a % 1000003;
a = a * a % 1000003;
b >>= 1;
}
return ans;
}
void get_gyz() {
gyz = 0;
long long a = 2;
long long temp = (k - 1) / a;
gyz += temp;
while (temp > 0) {
a *= 2;
temp = (k - 1) / a;
gyz += temp;
}
}
long long fermat(long long a) {
long long b = 1000003 - 2;
return mod_pow(a, b);
}
int main() {
long long fm, fz;
scanf("%I64d%I64d", &n, &k);
get_gyz();
long long x = mod_pow(2, gyz);
x = fermat(x);
x = (x + 1000003) % 1000003;
fm = mod_pow(mod_pow(2, n), k - 1) * x % 1000003;
if (k - 1 >= 1000003)
fz = 0;
else {
fz = 1;
long long temp = mod_pow(2, n);
long long t;
for (int i = 1; i < k; i++) {
t = temp - i < 0 ? temp - i + 1000003 : temp - i;
fz = fz * t % 1000003;
}
fz = fz * x % 1000003;
}
int flag = 0;
long long temp = 1;
for (int i = 1; i <= n && i <= 63; i++) {
temp *= 2;
if (k <= temp) {
flag = 1;
}
}
if (flag)
printf("%I64d %I64d\n", (fm - fz + 1000003) % 1000003, fm);
else
printf("1 1\n");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 151000;
const long long maxm = 105;
const long long mod = 1e9 + 7;
long long n, t, m;
signed main() {
cin >> n;
long long m = n;
long long sum = 1, s = 1;
while (m--) {
sum = (sum * 27) % mod;
}
while (n--) {
s = (s * 7) % mod;
}
if (sum < s)
printf("%lld\n", sum + mod - s);
else
printf("%lld\n", sum - s);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long v[55];
int main() {
long long a, b, k;
cin >> a >> b;
v[1] = 1;
for (int i = 2; i <= a; ++i) {
v[i] = 2 * v[i - 1] + 1;
}
k = a;
while (v[a]) {
v[a] = v[a] / 2 + 1;
if (v[a] < b)
b %= v[a];
else if (v[a] == b) {
cout << k << endl;
return 0;
}
v[a]--;
k--;
}
cout << k << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, ans = 1000;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (m % x == 0) ans = min(ans, m / x);
}
cout << ans;
}
| 7 | CPP |
# The real secret to success is enthusiasm. Walter Chrysler
# by : Blue Edge - Create some chaos
n,m=map(int,input().split())
if m%n:
exit(print(-1))
z=m//n
t=0
while z%2==0:
t+=1
z//=2
while z%3==0:
t+=1
z//=3
if z!=1:
print(-1)
else:
print(t)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const double PI = atan(1.0) * 4;
const int di[4] = {-1, 0, 1, 0};
const int dj[4] = {0, -1, 0, 1};
const long long INF = (long long)2e18 + 50;
const int maximum = numeric_limits<int>::max();
const int minimum = numeric_limits<int>::min();
const int N = 2e5 + 50;
const int P = 998244353;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
t = 1;
while (t--) {
int ans = 0;
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
vector<int> res(n);
int j = 0;
for (int i = 1; i < n; i += 2) {
res[i] = a[j++];
}
for (int i = 0; i < n; i += 2) {
res[i] = a[j++];
}
for (int i = 1; i < n - 1; i++) {
if (res[i] < res[i - 1] && res[i] < res[i + 1]) ans++;
}
cout << ans << "\n";
for (int i = 0; i < n; i++) {
cout << res[i] << " ";
}
cout << "\n";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MOD2 = MOD + 2;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
int modulo(int a, int b) { return (a % b + b) % b; }
vector<long long> BIT(220001, 0), a(220001);
int n;
void update(int idx, long long val) {
for (int i = idx; i <= n; i += i & -i) {
BIT[i] += val;
}
}
long long sum(int idx) {
long long sum = 0;
for (int i = idx; i > 0; i -= i & -i) {
sum += BIT[i];
}
return sum;
}
int find_first(long long s) {
int low = 0, high = n + 1;
while (low < high) {
int mid = (low + high) / 2;
if (sum(mid) >= s)
high = mid;
else
low = mid + 1;
}
return low;
}
int query() {
if (BIT[1] == 0) return 1;
long long s = BIT[1];
while (true) {
int index = find_first(2 * s);
if (index > n) return -1;
s = sum(index);
if (2 * a[index] == s) return index;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int q;
cin >> n >> q;
for (int i = (1); i <= (n); i++) {
cin >> a[i];
update(i, a[i]);
}
for (int i = (1); i <= (q); i++) {
int p;
long long x;
cin >> p >> x;
update(p, x - a[p]);
a[p] = x;
cout << query() << endl;
}
return 0;
}
| 11 | CPP |
x = int(input())
shapes = []
for prompt in range(x):
shape = input()
shapes.append(shape)
count = 0
for shape in shapes:
if shape == 'Tetrahedron':
count = count + 4
elif shape == 'Cube':
count = count + 6
elif shape == 'Octahedron':
count = count + 8
elif shape == 'Dodecahedron':
count = count + 12
elif shape == 'Icosahedron':
count = count + 20
print(count)
| 7 | PYTHON3 |
#include <cstdio>
#include <queue>
using namespace std;
int main()
{
int n;
scanf("%d", &n);
while (n-- > 0){
char str[2048] = {0};
scanf("%s", str);
deque<char> train;
train.push_back(*str);
bool v[26] = {false};
v[*str - 'a'] = true;
for (int i = 3; str[i] != 0; i += 3){
if (!v[str[i] - 'a']){
if (str[i - 1] == '>') train.push_back(str[i]);
else train.push_front(str[i]);
v[str[i] - 'a'] = true;
}
}
while (!train.empty()){
putchar(train.front());
train.pop_front();
}
puts("");
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200001];
int par[200001], parent[200001];
int find(int i) {
if (parent[i] == -1) return i;
return parent[i] = find(parent[i]);
}
void Union(int x, int y) {
int xset = find(x);
int yset = find(y);
parent[xset] = yset;
}
int main() {
int i, j, k, n, m;
cin >> n;
int flg[200001] = {0};
int cnt = 0;
for (i = 0; i <= n; i++) {
parent[i] = -1;
}
for (i = 1; i <= n; i++) {
int p;
cin >> p;
par[i] = p;
int x = find(p);
int y = find(i);
if (x == y) {
} else {
parent[y] = x;
}
}
int arr[1];
arr[0] = 0;
k = 0;
int fr = 0;
for (i = 1; i <= n; i++) {
if (i == par[i] && k == 0) {
arr[0] = i;
k++;
break;
}
}
for (i = 1; i <= n; i++) {
if (i == arr[0]) continue;
if (parent[i] == -1 && k == 0) {
arr[0] = i;
par[i] = arr[0];
parent[i] = arr[0];
cnt++;
k++;
} else if (parent[i] == -1) {
par[i] = arr[0];
cnt++;
parent[i] = arr[0];
}
}
cout << cnt << endl;
for (i = 1; i <= n; i++) cout << par[i] << " ";
cout << endl;
return 0;
}
| 10 | CPP |
# import sys
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
t = 1
t = int(input())
while t:
t -= 1
# n = int(input())
n, x = list(map(int, input().split()))
floor = 1
n -= 2
while n > 0:
floor += 1
n -= x
print(floor) | 7 | PYTHON3 |
# AC Library Python版
# Author Koki_tkg
'''
internal_type_traits以外は翻訳しました。
practiceは一応全部ACしていますが，
practiceで使っていない関数などの動作は未確認なので保証はしません。
また，C++版をほぼそのまま書き換えているので速度は出ません。 (2020/09/13 by Koki_tkg)
'''
# --------------------<< Library Start >>-------------------- #
# convolution.py
class convolution:
def __init__(self, a: list, b: list, mod: int):
self.a, self.b = a, b
self.n, self.m = len(a), len(b)
self.MOD = mod
self.g = primitive_root_constexpr(self.MOD)
def convolution(self) -> list:
n, m = self.n, self.m
a, b = self.a, self.b
if not n or not m: return []
if min(n, m) <= 60:
if n < m:
n, m = m, n
a, b = b, a
ans = [0] * (n + m - 1)
for i in range(n):
for j in range(m):
ans[i + j] += a[i] * b[j] % self.MOD
ans[i + j] %= self.MOD
return ans
z = 1 << ceil_pow2(n + m - 1)
a = self.resize(a, z)
a = self.butterfly(a)
b = self.resize(b, z)
b = self.butterfly(b)
for i in range(z): a[i] = a[i] * b[i] % self.MOD
a = self.butterfly_inv(a)
a = a[:n + m - 1]
iz = self.inv(z)
a = [x * iz % self.MOD for x in a]
return a
def butterfly(self, a: list) -> list:
n = len(a)
h = ceil_pow2(n)
first = True
sum_e = [0] * 30
m = self.MOD
if first:
first = False
es, ies = [0] * 30, [0] * 30
cnt2 = bsf(m - 1)
e = self.mypow(self.g, (m - 1) >> cnt2); ie = self.inv(e)
for i in range(cnt2, 1, -1):
es[i - 2] = e
ies[i - 2] = ie
e = e * e % m
ie = ie * ie % m
now = 1
for i in range(cnt2 - 2):
sum_e[i] = es[i] * now % m
now = now * ies[i] % m
for ph in range(1, h + 1):
w = 1 << (ph - 1); p = 1 << (h - ph)
now = 1
for s in range(w):
offset = s << (h - ph + 1)
for i in range(p):
l = a[i + offset] % m
r = a[i + offset + p] * now % m
a[i + offset] = (l + r) % m
a[i + offset + p] = (l - r) % m
now = now * sum_e[bsf(~s)] % m
return a
def butterfly_inv(self, a: list) -> list:
n = len(a)
h = ceil_pow2(n)
first = True
sum_ie = [0] * 30
m = self.MOD
if first:
first = False
es, ies = [0] * 30, [0] * 30
cnt2 = bsf(m - 1)
e = self.mypow(self.g, (m - 1) >> cnt2); ie = self.inv(e)
for i in range(cnt2, 1, -1):
es[i - 2] = e
ies[i - 2] = ie
e = e * e % m
ie = ie * ie % m
now = 1
for i in range(cnt2 - 2):
sum_ie[i] = ies[i] * now % m
now = es[i] * now % m
for ph in range(h, 0, -1):
w = 1 << (ph - 1); p = 1 << (h - ph)
inow = 1
for s in range(w):
offset = s << (h - ph + 1)
for i in range(p):
l = a[i + offset] % m
r = a[i + offset + p] % m
a[i + offset] = (l + r) % m
a[i + offset + p] = (m + l - r) * inow % m
inow = sum_ie[bsf(~s)] * inow % m
return a
@staticmethod
def resize(array: list, sz: int) -> list:
new_array = array + [0] * (sz - len(array))
return new_array
def inv(self, x: int):
if is_prime_constexpr(self.MOD):
assert x
return self.mypow(x, self.MOD - 2)
else:
eg = inv_gcd(x)
assert eg[0] == 1
return eg[1]
def mypow(self, x: int, n: int) -> int:
assert 0 <= n
r = 1; m = self.MOD
while n:
if n & 1: r = r * x % m
x = x * x % m
n >>= 1
return r
# dsu.py
class dsu:
def __init__(self, n: int):
self._n = n
self.parent_or_size = [-1] * self._n
def merge(self, a: int, b: int) -> int:
assert 0 <= a and a < self._n
assert 0 <= b and a < self._n
x = self.leader(a); y = self.leader(b)
if x == y: return x
if -self.parent_or_size[x] < -self.parent_or_size[y]: x, y = y, x
self.parent_or_size[x] += self.parent_or_size[y]
self.parent_or_size[y] = x
return x
def same(self, a: int, b: int) -> bool:
assert 0 <= a and a < self._n
assert 0 <= b and a < self._n
return self.leader(a) == self.leader(b)
def leader(self, a: int) -> int:
assert 0 <= a and a < self._n
if self.parent_or_size[a] < 0: return a
self.parent_or_size[a] = self.leader(self.parent_or_size[a])
return self.parent_or_size[a]
def size(self, a: int) -> int:
assert 0 <= a and a < self._n
return -self.parent_or_size[self.leader(a)]
def groups(self):
leader_buf = [0] * self._n; group_size = [0] * self._n
for i in range(self._n):
leader_buf[i] = self.leader(i)
group_size[leader_buf[i]] += 1
result = [[] for _ in range(self._n)]
for i in range(self._n):
result[leader_buf[i]].append(i)
result = [v for v in result if v]
return result
# fenwicktree.py
class fenwick_tree:
def __init__(self, n):
self._n = n
self.data = [0] * n
def add(self, p: int, x: int):
assert 0 <= p and p <= self._n
p += 1
while p <= self._n:
self.data[p - 1] += x
p += p & -p
def sum(self, l: int, r: int) -> int:
assert 0 <= l and l <= r and r <= self._n
return self.__sum(r) - self.__sum(l)
def __sum(self, r: int) -> int:
s = 0
while r > 0:
s += self.data[r - 1]
r -= r & -r
return s
# internal_bit.py
def ceil_pow2(n: int) -> int:
x = 0
while (1 << x) < n: x += 1
return x
def bsf(n: int) -> int:
return (n & -n).bit_length() - 1
# internal_math.py
def safe_mod(x: int, m: int) -> int:
x %= m
if x < 0: x += m
return x
class barrett:
def __init__(self, m: int):
self._m = m
self.im = -1 // (m + 1)
def umod(self): return self._m
def mul(self, a: int, b: int) -> int:
z = a
z *= b
x = (z * im) >> 64
v = z - x * self._m
if self._m <= v: v += self._m
return v
def pow_mod_constexpr(x: int, n: int, m: int) -> int:
if m == 1: return 0
_m = m; r = 1; y = safe_mod(x, m)
while n:
if n & 1: r = (r * y) % _m
y = (y * y) % _m
n >>= 1
return r
def is_prime_constexpr(n: int) -> bool:
if n <= 1: return False
if n == 2 or n == 7 or n == 61: return True
if n % 2 == 0: return False
d = n - 1
while d % 2 == 0: d //= 2
for a in [2, 7, 61]:
t = d
y = pow_mod_constexpr(a, t, n)
while t != n - 1 and y != 1 and y != n - 1:
y = y * y % n
t <<= 1
if y != n - 1 and t % 2 == 0: return False
return True
def inv_gcd(self, a: int, b: int) -> tuple:
a = safe_mod(a, b)
if a == 0: return (b, 0)
s = b; t = a; m0 = 0; m1 = 1
while t:
u = s // t
s -= t * u
m0 -= m1 * u
tmp = s; s = t; t = tmp; tmp = m0; m0 = m1; m1 = tmp
if m0 < 0: m0 += b // s
return (s, m0)
def primitive_root_constexpr(m: int) -> int:
if m == 2: return 1
if m == 167772161: return 3
if m == 469762049: return 3
if m == 754974721: return 11
if m == 998244353: return 3
divs = [0] * 20
divs[0] = 2
cnt = 1
x = (m - 1) // 2
while x % 2 == 0: x //= 2
i = 3
while i * i <= x:
if x % i == 0:
divs[cnt] = i; cnt += 1
while x % i == 0:
x //= i
i += 2
if x > 1: divs[cnt] = x; cnt += 1
g = 2
while True:
ok = True
for i in range(cnt):
if pow_mod_constexpr(g, (m - 1) // div[i], m) == 1:
ok = False
break
if ok: return g
g += 1
# internal_queue.py
class simple_queue:
def __init__(self):
self.payload = []
self.pos = 0
def size(self): return len(self.payload) - self.pos
def empty(self): return self.pos == len(self.payload)
def push(self, t: int): self.payload.append(t)
def front(self): return self.payload[self.pos]
def clear(self): self.payload.clear(); pos = 0
def pop(self): self.pos += 1
def pop_front(self): self.pos += 1; return self.payload[~-self.pos]
# internal_scc.py
class csr:
def __init__(self, n: int, edges: list):
from copy import deepcopy
self.start = [0] * (n + 1)
self.elist = [[] for _ in range(len(edges))]
for e in edges:
self.start[e[0] + 1] += 1
for i in range(1, n + 1):
self.start[i] += self.start[i - 1]
counter = deepcopy(self.start)
for e in edges:
self.elist[counter[e[0]]] = e[1]; counter[e[0]] += 1
class scc_graph:
# private
edges = []
# public
def __init__(self, n: int):
self._n = n
self.now_ord = 0; self.group_num = 0
def num_vertices(self): return self._n
def add_edge(self, _from: int, _to: int): self.edges.append((_from, [_to]))
def scc_ids(self):
g = csr(self._n, self.edges)
visited = []; low = [0] * self._n; ord = [-1] * self._n; ids = [0] * self._n
def dfs(s, v: int):
low[v] = ord[v] = self.now_ord; self.now_ord += 1
visited.append(v)
for i in range(g.start[v], g.start[v + 1]):
to = g.elist[i][0]
if ord[to] == -1:
s(s, to)
low[v] = min(low[v], low[to])
else:
low[v] = min(low[v], ord[to])
if low[v] == ord[v]:
while True:
u = visited.pop()
ord[u] = self._n
ids[u] = self.group_num
if u == v: break
self.group_num += 1
for i in range(self._n):
if ord[i] == -1: dfs(dfs, i)
for i in range(self._n):
ids[i] = self.group_num - 1 - ids[i]
return (self.group_num, ids)
def scc(self):
ids = self.scc_ids()
group_num = ids[0]
counts = [0] * group_num
for x in ids[1]: counts[x] += 1
groups = [[] for _ in range(group_num)]
for i in range(self._n):
groups[ids[1][i]].append(i)
return groups
# internal_type_traits.py
# lazysegtree.py
'''
def op(l, r): return
def e(): return
def mapping(l, r): return
def composition(l, r): return
def id(): return 0
'''
class lazy_segtree:
def __init__(self, op, e, mapping, composition, id, v: list):
self.op = op; self.e = e; self.mapping = mapping; self.composition = composition; self.id = id
self._n = len(v)
self.log = ceil_pow2(self._n)
self.size = 1 << self.log
self.lz = [self.id()] * self.size
self.d = [self.e()] * (2 * self.size)
for i in range(self._n): self.d[self.size + i] = v[i]
for i in range(self.size - 1, 0, -1): self.__update(i)
def set_(self, p: int, x: int):
assert 0 <= p and p < self._n
p += self.size
for i in range(self.log, 0, -1): self.__push(p >> i)
self.d[p] = x
for i in range(1, self.log + 1): self.__update(p >> 1)
def get(self, p: int):
assert 0 <= p and p < self._n
p += self.size
for i in range(self.log, 0, -1): self.__push(p >> i)
return self.d[p]
def prod(self, l: int, r: int):
assert 0 <= l and l <= r and r <= self._n
if l == r: return self.e()
l += self.size; r += self.size
for i in range(self.log, 0, -1):
if ((l >> i) << i) != l: self.__push(l >> i)
if ((r >> i) << i) != r: self.__push(r >> i)
sml, smr = self.e(), self.e()
while l < r:
if l & 1: sml = self.op(sml, self.d[l]); l += 1
if r & 1: r -= 1; smr = self.op(self.d[r], smr)
l >>= 1; r >>= 1
return self.op(sml, smr)
def all_prod(self): return self.d[1]
def apply(self, p: int, f):
assert 0 <= p and p < self._n
p += self.size
for i in range(self.log, 0, -1): self.__push(p >> i)
self.d[p] = self.mapping(f, self.d[p])
for i in range(1, self.log + 1): self.__update(p >> 1)
def apply(self, l: int, r: int, f):
assert 0 <= l and l <= r and r <= self._n
if l == r: return
l += self.size; r += self.size
for i in range(self.log, 0, -1):
if ((l >> i) << i) != l: self.__push(l >> i)
if ((r >> i) << i) != r: self.__push((r - 1) >> i)
l2, r2 = l, r
while l < r:
if l & 1: self.__all_apply(l, f); l += 1
if r & 1: r -= 1; self.__all_apply(r, f)
l >>= 1; r >>= 1
l, r = l2, r2
for i in range(1, self.log + 1):
if ((l >> i) << i) != l: self.__update(l >> i)
if ((r >> i) << i) != r: self.__update(r >> i)
def max_right(self, l: int, g):
assert 0 <= l and l <= self._n
if l == self._n: return self._n
l += self.size
for i in range(self.log, 0, -1): self.__push(l >> i)
sm = self.e()
while True:
while l % 2 == 0: l >>= 1
if not g(self.op(sm, self.d[l])):
while l < self.size:
self.__push(l)
l = 2 * l
if g(self.op(sm, self.d[l])):
sm = self.op(sm, self.d[l])
l += 1
return l - self.size
sm = self.op(sm, self.d[l])
l += 1
if (l & -l) == l: break
return self._n
def min_left(self, r: int, g):
assert 0 <= r and r <= self._n
if r == 0: return 0
r += self.size
for i in range(self.log, 0, -1): self.__push(r >> i)
sm = self.e()
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not g(self.op(self.d[r], sm)):
while r < self.size:
self.__push(r)
r = 2 * r + 1
if g(self.op(self.d[r], sm)):
sm = self.op(self.d[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.d[r], sm)
if (r & -r) == r: break
return 0
# private
def __update(self, k: int): self.d[k] = self.op(self.d[k * 2], self.d[k * 2 + 1])
def __all_apply(self, k: int, f):
self.d[k] = self.mapping(f, self.d[k])
if k < self.size: self.lz[k] = self.composition(f, self.lz[k])
def __push(self, k: int):
self.__all_apply(2 * k, self.lz[k])
self.__all_apply(2 * k + 1, self.lz[k])
self.lz[k] = self.id()
# math
def pow_mod(x: int, n: int, m: int) -> int:
assert 0 <= n and 1 <= m
if m == 1: return 0
bt = barrett(m)
r = 1; y = safe_mod(x, m)
while n:
if n & 1: r = bt.mul(r, y)
y = bt.mul(y, y)
n >>= 1
return n
def inv_mod(x: int, m: int) -> int:
assert 1 <= m
z = inv_gcd(x, m)
assert z[0] == 1
return z[1]
def crt(r: list, m: list) -> tuple:
assert len(r) == len(m)
n = len(r)
r0 = 0; m0 = 1
for i in range(n):
assert 1 <= m[i]
r1 = safe_mod(r[i], m[i]); m1 = m[i]
if m0 < m1:
r0, r1 = r1, r0
m0, m1 = m1, m0
if m0 % m1 == 0:
if r0 % m1 != r1: return (0, 0)
continue
g, im = inv_gcd(m0, m1)
u1 = m1 // g
if (r1 - r0) % g: return (0, 0)
x = (r1 - r0) // g % u1 * im % u1
r0 += x * m0
m0 *= u1
if r0 < 0: r0 += m0
return (r0, m0)
def floor_sum(n: int, m: int, a: int, b: int) -> int:
ans = 0
if a >= m:
ans += (n - 1) * n * (a // m) // 2
a %= m
if b >= m:
ans += n * (b // m)
bb %= m
y_max = (a * n + b) // m; x_max = (y_max * m - b)
if y_max == 0: return ans
ans += (n - (x_max + a - 1) // a) * y_max
ans += floor_sum(y_max, a, m, (a - x_max % a) % a)
return ans
# maxflow.py
# from collections import deque
class mf_graph:
numeric_limits_max = 10 ** 18
def __init__(self, n: int):
self._n = n
self.g = [[] for _ in range(self._n)]
self.pos = []
def add_edge(self, _from: int, _to: int, cap: int) -> int:
assert 0 <= _from and _from < self._n
assert 0 <= _to and _to < self._n
assert 0 <= cap
m = len(self.pos)
self.pos.append((_from, len(self.g[_from])))
self.g[_from].append(self._edge(_to, len(self.g[_to]), cap))
self.g[_to].append(self._edge(_from, len(self.g[_from]) - 1, 0))
return m
class edge:
def __init__(s, _from: int, _to: int, cap: int, flow: int):
s._from = _from; s._to = _to; s.cap = cap; s.flow = flow
def get_edge(self, i: int) -> edge:
m = len(self.pos)
assert 0 <= i and i < m
_e = self.g[self.pos[i][0]][self.pos[i][1]]
_re = self.g[_e.to][_e.rev]
return self.edge(self.pos[i][0], _e.to, _e.cap + _re.cap, _re.cap)
def edges(self) -> list:
m = len(self.pos)
result = [self.get_edge(i) for i in range(m)]
return result
def change_edge(self, i: int, new_cap: int, new_flow: int):
m = len(self.pos)
assert 0 <= i and i < m
assert 0 <= new_flow and new_flow <= new_cap
_e = self.g[self.pos[i][0]][self.pos[i][1]]
_re = self.g[_e.to][_e.rev]
_e.cap = new_cap - new_flow
_re.cap = new_flow
def flow(self, s: int, t: int):
return self.flow_(s, t, self.numeric_limits_max)
def flow_(self, s: int, t: int, flow_limit: int) -> int:
assert 0 <= s and s < self._n
assert 0 <= t and t < self._n
level = [0] * self._n; it = [0] * self._n
def bfs():
for i in range(self._n): level[i] = -1
level[s] = 0
que = deque([s])
while que:
v = que.popleft()
for e in self.g[v]:
if e.cap == 0 or level[e.to] >= 0: continue
level[e.to] = level[v] + 1
if e.to == t: return
que.append(e.to)
def dfs(self_, v: int, up: int) -> int:
if v == s: return up
res = 0
level_v = level[v]
for i in range(it[v], len(self.g[v])):
it[v] = i
e = self.g[v][i]
if level_v <= level[e.to] or self.g[e.to][e.rev].cap == 0: continue
d = self_(self_, e.to, min(up - res, self.g[e.to][e.rev].cap))
if d <= 0: continue
self.g[v][i].cap += d
self.g[e.to][e.rev].cap -= d
res += d
if res == up: break
return res
flow = 0
while flow < flow_limit:
bfs()
if level[t] == -1: break
for i in range(self._n): it[i] = 0
while flow < flow_limit:
f = dfs(dfs, t, flow_limit - flow)
if not f: break
flow += f
return flow
def min_cut(self, s: int) -> list:
visited = [False] * self._n
que = deque([s])
while que:
p = que.popleft()
visited[p] = True
for e in self.g[p]:
if e.cap and not visited[e.to]:
visited[e.to] = True
que.append(e.to)
return visited
class _edge:
def __init__(s, to: int, rev: int, cap: int):
s.to = to; s.rev = rev; s.cap = cap
# mincostflow.py
# from heapq import heappop, heappush
class mcf_graph:
numeric_limits_max = 10 ** 18
def __init__(self, n: int):
self._n = n
self.g = [[] for _ in range(n)]
self.pos = []
def add_edge(self, _from: int, _to: int, cap: int, cost: int) -> int:
assert 0 <= _from and _from < self._n
assert 0 <= _to and _to < self._n
m = len(self.pos)
self.pos.append((_from, len(self.g[_from])))
self.g[_from].append(self._edge(_to, len(self.g[_to]), cap, cost))
self.g[_to].append(self._edge(_from, len(self.g[_from]) - 1, 0, -cost))
return m
class edge:
def __init__(s, _from: int, _to: int, cap: int, flow: int, cost: int):
s._from = _from; s._to = _to; s.cap = cap; s.flow = flow; s.cost = cost
def get_edge(self, i: int) -> edge:
m = len(self.pos)
assert 0 <= i and i < m
_e = self.g[self.pos[i][0]][self.pos[i][1]]
_re = self.g[_e.to][_e.rev]
return self.edge(self.pos[i][0], _e.to, _e.cap + _re.cap, _re.cap, _e.cost)
def edges(self) -> list:
m = len(self.pos)
result = [self.get_edge(i) for i in range(m)]
return result
def flow(self, s: int, t: int) -> edge:
return self.flow_(s, t, self.numeric_limits_max)
def flow_(self, s: int, t: int, flow_limit: int) -> edge:
return self.__slope(s, t, flow_limit)[-1]
def slope(self, s: int, t: int) -> list:
return self.slope_(s, t, self.numeric_limits_max)
def slope_(self, s: int, t: int, flow_limit: int) -> list:
return self.__slope(s, t, flow_limit)
def __slope(self, s: int, t: int, flow_limit: int) -> list:
assert 0 <= s and s < self._n
assert 0 <= t and t < self._n
assert s != t
dual = [0] * self._n; dist = [0] * self._n
pv, pe = [-1] * self._n, [-1] * self._n
vis = [False] * self._n
def dual_ref():
for i in range(self._n):
dist[i] = self.numeric_limits_max
pv[i] = -1
pe[i] = -1
vis[i] = False
class Q:
def __init__(s, key: int, to: int):
s.key = key; s.to = to
def __lt__(s, r): return s.key < r.key
que = []
dist[s] = 0
heappush(que, Q(0, s))
while que:
v = heappop(que).to
if vis[v]: continue
vis[v] = True
if v == t: break
for i in range(len(self.g[v])):
e = self.g[v][i]
if vis[e.to] or not e.cap: continue
cost = e.cost - dual[e.to] + dual[v]
if dist[e.to] - dist[v] > cost:
dist[e.to] = dist[v] + cost
pv[e.to] = v
pe[e.to] = i
heappush(que, Q(dist[e.to], e.to))
if not vis[t]: return False
for v in range(self._n):
if not vis[v]: continue
dual[v] -= dist[t] - dist[v]
return True
flow = 0
cost = 0; prev_cost = -1
result = []
result.append((flow, cost))
while flow < flow_limit:
if not dual_ref(): break
c = flow_limit - flow
v = t
while v != s:
c = min(c, self.g[pv[v]][pe[v]].cap)
v = pv[v]
v = t
while v != s:
e = self.g[pv[v]][pe[v]]
e.cap -= c
self.g[v][e.rev].cap += c
v = pv[v]
d = -dual[s]
flow += c
cost += c * d
if prev_cost == d:
result.pop()
result.append((flow, cost))
prev_cost = cost
return result
class _edge:
def __init__(s, to: int, rev: int, cap: int, cost: int):
s.to = to; s.rev = rev; s.cap = cap; s.cost = cost
# modint.py
class Mint:
modint1000000007 = 1000000007
modint998244353 = 998244353
def __init__(self, v: int = 0):
self.m = self.modint1000000007
# self.m = self.modint998244353
self.x = v % self.__umod()
def inv(self):
if is_prime_constexpr(self.__umod()):
assert self.x
return self.pow_(self.__umod() - 2)
else:
eg = inv_gcd(self.x, self.m)
assert eg[0] == 1
return eg[2]
def __str__(self): return str(self.x)
def __le__(self, other): return self.x <= Mint.__get_val(other)
def __lt__(self, other): return self.x < Mint.__get_val(other)
def __ge__(self, other): return self.x >= Mint.__get_val(other)
def __gt(self, other): return self.x > Mint.__get_val(other)
def __eq__(self, other): return self.x == Mint.__get_val(other)
def __iadd__(self, other):
self.x += Mint.__get_val(other)
if self.x >= self.__umod(): self.x -= self.__umod()
return self
def __add__(self, other):
_v = Mint(self.x); _v += other
return _v
def __isub__(self, other):
self.x -= Mint.__get_val(other)
if self.x >= self.__umod(): self.x += self.__umod()
return self
def __sub__(self, other):
_v = Mint(self.x); _v -= other
return _v
def __rsub__(self, other):
_v = Mint(Mint.__get_val(other)); _v -= self
return _v
def __imul__(self, other):
self.x =self.x * Mint.__get_val(other) % self.__umod()
return self
def __mul__(self, other):
_v = Mint(self.x); _v *= other
return _v
def __itruediv__(self, other):
self.x = self.x / Mint.__get_val(other) % self.__umod()
return self
def __truediv__(self, other):
_v = Mint(self.x); _v /= other
return _v
def __rtruediv__(self, other):
_v = Mint(Mint.__get_val(other)); _v /= self
return _v
def __ifloordiv__(self, other):
other = other if isinstance(other, Mint) else Mint(other)
self *= other.inv()
return self
def __floordiv__(self, other):
_v = Mint(self.x); _v //= other
return _v
def __rfloordiv__(self, other):
_v = Mint(Mint.__get_val(other)); _v //= self
return _v
def __pow__(self, other):
_v = Mint(pow(self.x, Mint.__get_val(other), self.__umod()))
return _v
def __rpow__(self, other):
_v = Mint(pow(Mint.__get_val(other), self.x, self.__umod()))
return _v
def __imod__(self, other):
self.x %= Mint.__get_val(other)
return self
def __mod__(self, other):
_v = Mint(self.x); _v %= other
return _v
def __rmod__(self, other):
_v = Mint(Mint.__get_val(other)); _v %= self
return _v
def __ilshift__(self, other):
self.x <<= Mint.__get_val(other)
return self
def __irshift__(self, other):
self.x >>= Mint.__get_val(other)
return self
def __lshift__(self, other):
_v = Mint(self.x); _v <<= other
return _v
def __rshift__(self, other):
_v = Mint(self.x); _v >>= other
return _v
def __rlshift__(self, other):
_v = Mint(Mint.__get_val(other)); _v <<= self
return _v
def __rrshift__(self, other):
_v = Mint(Mint.__get_val(other)); _v >>= self
return _v
__repr__ = __str__
__radd__ = __add__
__rmul__ = __mul__
def __umod(self): return self.m
@staticmethod
def __get_val(val): return val.x if isinstance(val, Mint) else val
def pow_(self, n: int):
assert 0 <= n
x = Mint(self.x); r = 1
while n:
if n & 1: r *= x
x *= x
n >>= 1
return r
def val(self): return self.x
def mod(self): return self.m
def raw(self, v):
x = Mint()
x.x = v
return x
# scc.py
class scc_graph_sub:
# public
def __init__(self, n):
self.internal = scc_graph(n)
def add_edge(self, _from, _to):
n = self.internal.num_vertices()
assert 0 <= _from and _from < n
assert 0 <= _to and _to < n
self.internal.add_edge(_from, _to)
def scc(self): return self.internal.scc()
# segtree.py
'''
def e(): return
def op(l, r): return
def f(): return
'''
class segtree:
def __init__(self, op, e, v: list):
self._n = len(v)
self.log = ceil_pow2(self._n)
self.size = 1 << self.log
self.op = op; self.e = e
self.d = [self.e()] * (self.size * 2)
for i in range(self._n): self.d[self.size + i] = v[i]
for i in range(self.size - 1, 0, -1): self.__update(i)
def set_(self, p: int, x: int):
assert 0 <= p and p < self._n
p += self.size
self.d[p] = x
for i in range(1, self.log + 1): self.__update(p >> i)
def get(self, p: int):
assert 0 <= p and p < self._n
return self.d[p + self.size]
def prod(self, l: int, r: int):
assert 0 <= l and l <= r and r <= self._n
l += self.size; r += self.size
sml, smr = self.e(), self.e()
while l < r:
if l & 1: sml = self.op(sml, self.d[l]); l += 1
if r & 1: r -= 1; smr = self.op(self.d[r], smr)
l >>= 1; r >>= 1
return self.op(sml, smr)
def all_prod(self): return self.d[1]
def max_right(self, l: int, f):
assert 0 <= l and l <= self._n
assert f(self.e())
if l == self._n: return self._n
l += self.size
sm = self.e()
while True:
while l % 2 == 0: l >>= 1
if not f(self.op(sm, self.d[l])):
while l < self.size:
l = 2 * l
if f(self.op(sm, self.d[l])):
sm = self.op(sm, self.d[l])
l += 1
return l - self.size
sm = self.op(sm, self.d[l])
l += 1
if (l & -l) == l: break
return self._n
def min_left(self, r: int, f):
assert 0 <= r and r <= self._n
assert f(self.e())
if r == 0: return 0
r += self.size
sm = self.e()
while True:
r -= 1
while r > 1 and r % 2: r >>= 1
if not f(self.op(self.d[r], sm)):
while r < self.size:
r = 2 * r + 1
if f(self.op(self.d[r], sm)):
sm = self.op(self.d[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.d[r], sm)
if (r & -r) == r: break
return 0
def __update(self, k: int): self.d[k] = self.op(self.d[k * 2], self.d[k * 2 + 1])
# string.py
def sa_native(s: list):
from functools import cmp_to_key
def mycmp(r, l):
if l == r: return -1
while l < n and r < n:
if s[l] != s[r]: return 1 if s[l] < s[r] else -1
l += 1
r += 1
return 1 if l == n else -1
n = len(s)
sa = [i for i in range(n)]
sa.sort(key=cmp_to_key(mycmp))
return sa
def sa_doubling(s: list):
from functools import cmp_to_key
def mycmp(y, x):
if rnk[x] != rnk[y]: return 1 if rnk[x] < rnk[y] else -1
rx = rnk[x + k] if x + k < n else - 1
ry = rnk[y + k] if y + k < n else - 1
return 1 if rx < ry else -1
n = len(s)
sa = [i for i in range(n)]; rnk = s; tmp = [0] * n; k = 1
while k < n:
sa.sort(key=cmp_to_key(mycmp))
tmp[sa[0]] = 0
for i in range(1, n):
tmp[sa[i]] = tmp[sa[i - 1]]
if mycmp(sa[i], sa[i - 1]): tmp[sa[i]] += 1
tmp, rnk = rnk, tmp
k *= 2
return sa
def sa_is(s: list, upper: int):
THRESHOLD_NATIVE = 10
THRESHOLD_DOUBLING = 40
n = len(s)
if n == 0: return []
if n == 1: return [0]
if n == 2:
if s[0] < s[1]:
return [0, 1]
else:
return [1, 0]
if n < THRESHOLD_NATIVE:
return sa_native(s)
if n < THRESHOLD_DOUBLING:
return sa_doubling(s)
sa = [0] * n
ls = [False] * n
for i in range(n - 2, -1, -1):
ls[i] = ls[i + 1] if s[i] == s[i + 1] else s[i] < s[i + 1]
sum_l = [0] * (upper + 1); sum_s = [0] * (upper + 1)
for i in range(n):
if not ls[i]:
sum_s[s[i]] += 1
else:
sum_l[s[i] + 1] += 1
for i in range(upper + 1):
sum_s[i] += sum_l[i]
if i < upper: sum_l[i + 1] += sum_s[i]
def induce(lms: list):
from copy import copy
for i in range(n): sa[i] = -1
buf = copy(sum_s)
for d in lms:
if d == n: continue
sa[buf[s[d]]] = d; buf[s[d]] += 1
buf = copy(sum_l)
sa[buf[s[n - 1]]] = n - 1; buf[s[n - 1]] += 1
for i in range(n):
v = sa[i]
if v >= 1 and not ls[v - 1]:
sa[buf[s[v - 1]]] = v - 1; buf[s[v - 1]] += 1
buf = copy(sum_l)
for i in range(n - 1, -1, -1):
v = sa[i]
if v >= 1 and ls[v - 1]:
buf[s[v - 1] + 1] -= 1; sa[buf[s[v - 1] + 1]] = v - 1
lms_map = [-1] * (n + 1)
m = 0
for i in range(1, n):
if not ls[i - 1] and ls[i]:
lms_map[i] = m; m += 1
lms = [i for i in range(1, n) if not ls[i - 1] and ls[i]]
induce(lms)
if m:
sorted_lms = [v for v in sa if lms_map[v] != -1]
rec_s = [0] * m
rec_upper = 0
rec_s[lms_map[sorted_lms[0]]] = 0
for i in range(1, m):
l = sorted_lms[i - 1]; r = sorted_lms[i]
end_l = lms[lms_map[l] + 1] if lms_map[l] + 1 < m else n
end_r = lms[lms_map[r] + 1] if lms_map[r] + 1 < m else n
same = True
if end_l - l != end_r - r:
same = False
else:
while l < end_l:
if s[l] != s[r]: break
l += 1
r += 1
if l == n or s[l] != s[r]: same = False
if not same: rec_upper += 1
rec_s[lms_map[sorted_lms[i]]] = rec_upper
rec_sa = sa_is(rec_s, rec_upper)
for i in range(m):
sorted_lms[i] = lms[rec_sa[i]]
induce(sorted_lms)
return sa
def suffix_array(s: list, upper: int):
assert 0 <= upper
for d in s:
assert 0 <= d and d <= upper
sa = sa_is(s, upper)
return sa
def suffix_array2(s: list):
from functools import cmp_to_key
n = len(s)
idx = [i for i in range(n)]
idx.sort(key=cmp_to_key(lambda l, r: s[l] < s[r]))
s2 = [0] * n
now = 0
for i in range(n):
if i and s[idx[i - 1]] != s[idx[i]]: now += 1
s2[idx[i]] = now
return sa_is(s2, now)
def suffix_array3(s: str):
n = len(s)
s2 = list(map(ord, s))
return sa_is(s2, 255)
def lcp_array(s: list, sa: list):
n = len(s)
assert n >= 1
rnk = [0] * n
for i in range(n):
rnk[sa[i]] = i
lcp = [0] * (n - 1)
h = 0
for i in range(n):
if h > 0: h -= 1
if rnk[i] == 0: continue
j = sa[rnk[i] - 1]
while j + h < n and i + h < n:
if s[j + h] != s[i + h]: break
h += 1
lcp[rnk[i] - 1] = h
return lcp
def lcp_array2(s: str, sa: list):
n = len(s)
s2 = list(map(ord, s))
return lcp_array(s2, sa)
def z_algorithm(s: list):
n = len(s)
if n == 0: return []
z = [-1] * n
z[0] = 0; j = 0
for i in range(1, n):
k = z[i] = 0 if j + z[j] <= i else min(j + z[j] - i, z[i - j])
while i + k < n and s[k] == s[i + k]: k += 1
z[i] = k
if j + z[j] < i + z[i]: j = i
z[0] = n
return z
def z_algorithm2(s: str):
n = len(s)
s2 = list(map(ord, s))
return z_algorithm(s2)
# twosat.py
class two_sat:
def __init__(self, n: int):
self._n = n
self.scc = scc_graph(2 * n)
self._answer = [False] * n
def add_clause(self, i: int, f: bool, j: int, g: bool):
assert 0 <= i and i < self._n
assert 0 <= j and j < self._n
self.scc.add_edge(2 * i + (not f), 2 * j + g)
self.scc.add_edge(2 * j + (not g), 2 * i + f)
def satisfiable(self) -> bool:
_id = self.scc.scc_ids()[1]
for i in range(self._n):
if _id[2 * i] == _id[2 * i + 1]: return False
self._answer[i] = _id[2 * i] < _id[2 * i + 1]
return True
def answer(self): return self._answer
# --------------------<< Library End >>-------------------- #
import sys
sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return map(int, sys.stdin.readline().strip().split())
def read_ints2(x): return map(lambda num: int(num) - x, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def GCD(a: int, b: int) -> int: return b if a%b==0 else GCD(b, a%b)
def LCM(a: int, b: int) -> int: return (a * b) // GCD(a, b)
def Main_A():
n, q = read_ints()
d = dsu(n)
for _ in range(q):
t, u, v = read_ints()
if t == 0:
d.merge(u, v)
else:
print(int(d.same(u, v)))
def Main_B():
n, q = read_ints()
a = read_int_list()
fw = fenwick_tree(n)
for i, x in enumerate(a):
fw.add(i, x)
for _ in range(q):
query = read_int_list()
if query[0] == 0:
fw.add(query[1], query[2])
else:
print(fw.sum(query[1], query[2]))
def Main_C():
for _ in range(read_int()):
n, m, a, b = read_ints()
print(floor_sum(n, m, a, b))
#from collections import deque
def Main_D():
n, m = read_ints()
grid = [list(read_str()) for _ in range(n)]
mf = mf_graph(n * m + 2)
start = n * m
end = start + 1
dir = [(1, 0), (0, 1)]
for y in range(n):
for x in range(m):
if (y + x) % 2 == 0:
mf.add_edge(start, m*y + x, 1)
else:
mf.add_edge(m*y + x, end, 1)
if grid[y][x] == '.':
for dy, dx in dir:
ny = y + dy; nx = x + dx
if ny < n and nx < m and grid[ny][nx] == '.':
f, t = y*m + x, ny*m + nx
if (y + x) % 2: f, t = t, f
mf.add_edge(f, t, 1)
ans = mf.flow(start, end)
for y in range(n):
for x in range(m):
for e in mf.g[y * m + x]:
to, rev, cap = e.to, e.rev, e.cap
ny, nx = divmod(to, m)
if (y + x) % 2 == 0 and cap == 0 and to != start and to != end and (y*m+x) != start and (y*m+x) != end:
if y + 1 == ny: grid[y][x] = 'v'; grid[ny][nx] = '^'
elif y == ny + 1: grid[y][x] = '^'; grid[ny][nx] = 'v'
elif x + 1 == nx: grid[y][x] = '>'; grid[ny][nx] = '<'
elif x == nx + 1: grid[y][x] = '<'; grid[ny][nx] = '>'
print(ans)
print(*[''.join(ret) for ret in grid], sep='\n')
#from heapq import heappop, heappush
def Main_E():
n, k = read_ints()
a = [read_int_list() for _ in range(n)]
mcf = mcf_graph(n * 2 + 2)
s = n * 2
t = n * 2 + 1
for i in range(n):
mcf.add_edge(s, i, k, 0)
mcf.add_edge(i + n, t, k, 0)
mcf.add_edge(s, t, n * k, INF)
for i in range(n):
for j in range(n):
mcf.add_edge(i, n + j, 1, INF - a[i][j])
result = mcf.flow_(s, t, n * k)
print(n * k * INF - result[1])
grid = [['.'] * n for _ in range(n)]
edges = mcf.edges()
for e in edges:
if e._from == s or e._to == t or e.flow == 0: continue
grid[e._from][e._to - n] = 'X'
print(*[''.join(g) for g in grid], sep='\n')
def Main_F():
MOD = 998244353
n, m = read_ints()
a = read_int_list()
b = read_int_list()
a = [x % MOD for x in a]
b = [x % MOD for x in b]
cnv = convolution(a,b,MOD)
ans = cnv.convolution()
print(*ans)
def Main_G():
sys.setrecursionlimit(10 ** 6)
n, m = read_ints()
scc = scc_graph(n)
for _ in range(m):
a, b = read_ints()
scc.add_edge(a, b)
ans = scc.scc()
print(len(ans))
for v in ans:
print(len(v), ' '.join(map(str, v[::-1])))
def Main_H():
n, d = read_ints()
xy = [read_int_list() for _ in range(n)]
tw = two_sat(n)
for i in range(n):
for j in range(i + 1, n):
for x in range(2):
if abs(xy[i][0] - xy[j][0]) < d: tw.add_clause(i, False, j, False)
if abs(xy[i][0] - xy[j][1]) < d: tw.add_clause(i, False, j, True)
if abs(xy[i][1] - xy[j][0]) < d: tw.add_clause(i, True, j, False)
if abs(xy[i][1] - xy[j][1]) < d: tw.add_clause(i, True, j, True)
if not tw.satisfiable():
print('No')
exit()
print('Yes')
ans = tw.answer()
for i, flag in enumerate(ans):
print(xy[i][0] if flag else xy[i][1])
def Main_I():
s = read_str()
sa = suffix_array3(s)
ans = len(s) * (len(s) + 1) // 2
for x in lcp_array2(s, sa):
ans -= x
print(ans)
def Main_J():
def op(l, r): return max(l, r)
def e(): return -1
def f(n): return n < r
n, q = read_ints()
a = read_int_list()
seg = segtree(op, e, a)
query = [(read_ints()) for _ in range(q)]
for i in range(q):
t, l, r = query[i]
if t == 1:
seg.set_(~-l, r)
elif t == 2:
print(seg.prod(~-l, r))
else:
print(seg.max_right(~-l, f) + 1)
def Main_K():
p = 998244353
def op(l, r):
l1, l2 = l >> 32, l % (1 << 32)
r1, r2 = r >> 32, r % (1 << 32)
return (((l1 + r1) % p) << 32) + l2 + r2
def e(): return 0
def mapping(l, r):
l1, l2 = l >> 32, l % (1 << 32)
r1, r2 = r >> 32, r % (1 << 32)
return (((l1 * r1 + l2 * r2) % p) << 32) + r2
def composition(l, r):
l1, l2 = l >> 32, l % (1 << 32)
r1, r2 = r >> 32, r % (1 << 32)
return ((l1 * r1 % p) << 32) + (l1 * r2 + l2) % p
def id(): return 1 << 32
n, q = read_ints()
A = read_int_list()
A = [(x << 32) + 1 for x in A]
seg = lazy_segtree(op, e, mapping, composition, id, A)
ans = []
for _ in range(q):
query = read_int_list()
if query[0] == 0:
l, r, b, c = query[1:]
seg.apply(l, r, (b << 32) + c)
else:
l, r = query[1:]
print(seg.prod(l, r) >> 32)
def Main_L():
def op(l: tuple, r: tuple): return (l[0] + r[0], l[1] + r[1], l[2] + r[2] + l[1] * r[0])
def e(): return (0, 0, 0)
def mapping(l:bool, r: tuple):
if not l: return r
return (r[1], r[0], r[1] * r[0] - r[2])
def composition(l: bool, r: bool): return l ^ r
def id(): return False
n, q = read_ints()
A = read_int_list()
query = [(read_ints()) for _ in range(q)]
a = [(1, 0, 0) if i == 0 else (0, 1, 0) for i in A]
seg = lazy_segtree(op, e, mapping, composition, id, a)
for t, l, r in query:
if t == 1:
seg.apply(~-l, r, True)
else:
print(seg.prod(~-l, r)[2])
if __name__ == '__main__':
Main_H() | 0 | PYTHON3 |
n=int(input())
l=input().split()
li=[int(i) for i in l]
maxa=0
hashi=dict()
for i in li:
if i in hashi:
hashi[i]+=1
else:
hashi[i]=1
for i in hashi:
maxa=max(maxa,hashi[i])
print(maxa)
| 7 | PYTHON3 |
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
x={}
f=0
for i in l:
if i not in x:
x[i]=1
else:
x[i]+=1
if x[i]>=3:
f=1
print("YES")
break
if f==0:
p=l[0]
x[l[0]]-=1
for i in range(1,n):
if l[i]==p:
x[l[i]]-=1
else:
if x[p]>=1:
f=1
break
else:
p=l[i]
x[p]-=1
if f:
print("YES")
else:
print("NO")
| 8 | PYTHON3 |
n = int(input())
m, digit = n, 0
while(m != 0):
m //= 10
digit += 1
sum_of_digits = 0
for i in range(digit-1):
sum_of_digits += ((i+1) * (9 * (10**i)))
sum_of_digits += ((n - (10**(digit-1)) + 1) * digit)
print(sum_of_digits) | 8 | PYTHON3 |
import sys
import math
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
t=inp()
for i in range(t):
l = inp()
q =inlt()
cteo = 0
ctoe = 0
for j in range(l):
if(j%2 == 0):
if(q[j]%2 == 1):
ctoe = ctoe + 1
else:
if(q[j]%2 == 0):
cteo = cteo + 1
if(cteo == ctoe):
print(ctoe)
else:
print(-1) | 8 | PYTHON3 |
#include <iostream>
#include <stack>
#include <set>
#include <string>
#include <algorithm>
#include <vector>
#include <math.h>
#include <map>
#include <bits/stdc++.h>
using namespace std;
#define mk(x,y) make_pair(x,y)
#define ls rt<<1
#define rs rt<<1|1
#define lowbit(x) ((x)& - (x))
#define sp <<" "
#define el <<"\n"
#define R(a,b) a+rand()%((b)-(a)+1)
#define ll long long
#define pb push_back
#define all(v) v.begin(),v.end()
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,a,b) for( int i=a; i <= b; i++)
#define yes cout<<"YES" el
#define no cout<<"NO" el
#define use_fast ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define maxn 200010
#define mod 1000000007
#define db double
#define F first
#define S second
#define INF 0x3f3f3f3f3f3f3f3f
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<ll,int> pli;
typedef struct{int x,y;} node;
struct edge{
int from,to,w;
edge(int a,int b,int c){from=a;to=b;w=c;}
};
struct s_node{
int id,dis;
s_node(int a,int b){id=a;dis=b;}
bool operator <(const s_node&a)const{
return dis>a.dis;
}
};
inline ll read(){
ll s=0,w=1;
char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
while(ch>='0'&&ch<='9') s=s*10+ch-'0',ch=getchar();
return s*w;
}
inline void write(int X)
{
if(X<0) {X=~(X-1); putchar('-');}
if(X>9) write(X/10);
putchar(X%10+'0');
}
ll gcd(ll a,ll b){return b==0?a:gcd(b,a%b);}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
ll arr[maxn];
void solve(){
ll n,a,b;
cin>>n>>a>>b;
string str;
cin>>str;
ll sum=n*a;
if(b==0){cout<<sum<<endl;return;}
else if(b>0){cout<<sum+b*n<<endl;return;}
else{
vector<int>v;
v.clear();
str+='a';
int cnt=1;
for(int i=1;i<str.size();i++){
if(str[i]!=str[i-1]){v.push_back(cnt);cnt=1;}
else cnt++;
}
int len=v.size();
if(len%2==0){cout<<(len/2+1)*b+sum<<endl;}
else {cout<<((len/2)+1)*b+sum<<endl;}
}
}
int main(int argc, const char * argv[]){
use_fast;
int tt;
cin>>tt;
while(tt--){
solve();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i;
scanf("%d", &(n));
scanf("%d", &(k));
double A[n];
for (i = 0; i < n; i++) scanf("%lf", &A[i]);
double low = 0.0, high = 1000.0;
double ans = 0.0;
while (high - low > 1e-8) {
double mid = (low + high) / 2;
double excess = 0, less = 0;
for (i = 0; i < n; i++) {
if (A[i] > mid)
excess += A[i] - mid;
else
less += mid - A[i];
}
excess -= excess * k / 100.0;
if (excess >= less) {
low = mid + 1e-8;
ans = mid;
} else
high = mid - 1e-8;
}
printf("%.8f\n", ans);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int xorsum(long long int x) {
if (x % 4 == 0) return x;
if (x % 4 == 1) return 1;
if (x % 4 == 2) return x + 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
long long int ans = 0, x, m, y;
for (int i = 0; i < n; i++) {
cin >> x >> m;
y = x + m - 1;
ans ^= xorsum(y) ^ xorsum(x - 1);
}
if (ans)
cout << "tolik";
else
cout << "bolik";
}
| 9 | CPP |
a, b=map(int,input().split())
n=0
while a>0.1:
n+=a
a=a/b
print(int(n))
| 7 | PYTHON3 |
n,h=map(int,input().split())
l=list(map(int,input().split()))
c=0
for i in range(n):
if h<l[i]:
c+=2
else:
c+=1
print(c)
| 7 | PYTHON3 |
from functools import *
from fractions import *
print(int(input()) * reduce(gcd,map(int,input().split()))) | 7 | PYTHON3 |
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
int N, M, ans = 0;
cin >> N >> M;
vector<string> A(N), B(N);
for (string& i : A) cin >> i;
for (string& i : B) cin >> i;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
if (A[i][j] != B[i][j]) ++ans;
}
}
cout << ans << endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long int m;
cin >> m;
long long int q[m];
for (auto i = 0; i != m; i++) cin >> q[i];
long long int n;
cin >> n;
long long int a[n];
for (auto i = 0; i != n; i++) cin >> a[i];
sort(q, q + m);
sort(a, a + n);
long long int j, sum = 0;
for (auto k = 0; k != n / (q[0] + 2); k++) {
j = n - 1 - k * (q[0] + 2);
for (auto i = 0; i != q[0]; i++) sum += a[j - i];
}
j = n - 1 - (q[0] + 2) * (n / (q[0] + 2));
for (long long int i = 0; i < q[0]; i++) {
if (j < i) break;
sum += a[j - i];
}
cout << sum << "\n";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
int main() {
int j, k;
char a[100];
scanf("%s", a);
for (int i = 2; i < strlen(a); i += 2) {
k = a[i];
j = i - 2;
while (j >= 0 && a[j] > k) {
a[j + 2] = a[j];
j = j - 2;
}
a[j + 2] = k;
}
printf("%s", a);
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long int n;
cin >> n;
map<long long int, long long int> ma;
for (long long int i = 1; i <= n; i++) {
long long int tmp;
cin >> tmp;
ma[tmp] = 1;
}
vector<long long int> v;
for (auto i : ma) {
v.push_back(i.first);
}
n = v.size();
long long int maxi = 0;
for (auto i : v) {
for (long long int j = 1; (j - 1) * i <= v.back(); j++) {
long long int idx =
lower_bound((v).begin(), (v).end(), j * i) - v.begin();
idx--;
idx = max(idx, 0ll);
if (v[idx] >= i) maxi = max(maxi, v[idx] % i);
}
}
cout << maxi;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 14;
const int maxmat = 3, mod = 1e9 + 7;
int n;
long long m;
struct mat {
int a[maxmat][maxmat];
mat(bool v = 0) {
memset(a, 0, sizeof a);
for (int i = 0; i < maxmat; i++) a[i][i] = v;
}
int *operator[](int idx) { return a[idx]; }
};
mat operator*(mat &a, mat &b) {
mat ans;
for (int i = 0; i < maxmat; i++)
for (int k = 0; k < maxmat; k++)
for (int j = 0; j < maxmat; j++)
ans[i][j] = (ans[i][j] + (long long)a[i][k] * b[k][j]) % mod;
return ans;
}
mat operator^(mat a, long long b) {
mat ans(1);
for (; b; b >>= 1, a = a * a)
if (b & 1) ans = ans * a;
return ans;
}
int block[maxmat];
int dp[maxmat];
map<long long, vector<pair<int, int> > > events;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
while (n--) {
long long row, l, r;
cin >> row >> l >> r;
row--, l--;
events[l].push_back({row, +1});
events[r].push_back({row, -1});
}
events.insert({1, {}});
events.insert({m, {}});
dp[1] = 1;
for (auto it = events.begin(); it != events.end(); it++) {
if (it != events.begin()) {
mat step;
for (int i = 0; i < maxmat; i++)
for (int j = max(0, i - 1); j < min(i + 2, maxmat); j++)
if (!block[j]) step[i][j] = 1;
step = step ^ (it->first - prev(it)->first);
int old[maxmat];
memcpy(old, dp, sizeof dp);
memset(dp, 0, sizeof dp);
for (int i = 0; i < maxmat; i++)
for (int j = 0; j < maxmat; j++)
dp[i] = (dp[i] + (long long)old[j] * step[j][i]) % mod;
}
for (auto [row, v] : it->second) block[row] += v;
}
cout << dp[1] << '\n';
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int v, minn = 1000000000ll;
int a[10];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> v;
for (int i = 1; i <= 9; i++) cin >> a[i], minn = min(minn, a[i]);
if (v < minn) {
cout << -1;
return 0;
}
int x = v / minn;
while (x--)
for (int i = 9; i >= 1; i--)
if ((v - a[i]) / minn == x && v >= a[i]) {
cout << i;
v -= a[i];
break;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int getint() {
int sym = 1;
int res = 0;
char ch;
while (!isdigit(ch = getchar()))
if (ch == '-') sym = -1;
res = ch - '0';
while (isdigit(ch = getchar())) res = res * 10 + ch - '0';
return sym * res;
}
const int maxn = 200010;
pair<int, int> a[maxn];
int n, k;
void init() {
n = getint(), k = getint();
k = n - k + 1;
for (int i = 1; i <= n; ++i) a[i].first = getint(), a[i].second = getint();
sort(a + 1, a + n + 1);
}
vector<int> w;
long long calc(int sce) {
int l = lower_bound(a + 1, a + n + 1, make_pair(sce - 1, 0)) - a;
int r = lower_bound(a + 1, a + n + 1, make_pair(sce + 1, 0)) - a - 1;
int must = k - l + 1;
if (must > r - l + 1 || sce > n || sce < must) return ~0uLL >> 1;
long long ans = 0;
w.clear();
for (int i = l; i <= r; ++i) w.push_back(a[i].second);
sort(w.begin(), w.end(), greater<int>());
for (int i = 1; i <= must; ++i, w.pop_back()) ans += w.back(), --sce;
for (int i = 1; i <= l - 1; ++i) w.push_back(a[i].second);
for (int i = r + 1; i <= n; ++i) w.push_back(a[i].second);
sort(w.begin(), w.end(), greater<int>());
for (int i = 1; i <= sce; ++i, w.pop_back()) ans += w.back();
return ans;
}
void solve() {
if (!k) {
puts("0");
return;
}
int s = a[k].first;
long long ans = min(min(calc(s), calc(s + 1)), calc(s + 2));
if (ans == (~0uLL >> 1))
puts("-1");
else
printf("%I64d\n", ans);
}
int main() {
init();
solve();
return 0;
}
| 9 | CPP |
n, d = map(int,(input().split()))
for i in range (int(input())):
x,y = map(int,input().split())
if d<=x+y<=2*n-d and -d<=x-y<=d:
print('YES')
else:
print('NO') | 8 | PYTHON3 |
t = int(input())
while t:
t-=1
n =int(input())
a = list(map(int, input().split()))
s = set(a)
if len(s) > 1:
print(1)
else:
print(n) | 7 | PYTHON3 |
S = input()
odd = S[::2]
even = S[1::2]
if 'L' in odd or 'R' in even:
print('No')
else:
print('Yes') | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define LL long long
const int maxN = 5e5 + 10;
int n, m, g, lim, I, T;
int p[maxN * 2 + 1], q[maxN * 2 + 1];
LL K;
inline LL read()
{
LL num = 0, f = 1;
char ch = getchar();
while( !isdigit( ch ) ) { if(ch == '-') f = -1; ch = getchar(); }
while( isdigit( ch ) ) num = (num << 3) + (num << 1) + (ch ^ 48), ch = getchar();
return num * f;
}
inline void exgcd(int a, int b, int &d, LL &x, LL &y)
{
if(!b) { d = a; x = 1; y = 0; return; }
exgcd(b, a % b, d, x, y);
LL tmp = x;
x = y;
y = tmp - y * (a / b);
}
inline bool check(LL d)
{
LL res = d;
for(int i = 1; i <= lim; i++)
{
if(!p[i] || !q[i]) continue;
LL t = p[i] - q[i];
if(t % g != 0) continue;
t = (t / g) * I % n;
if(t < 0) t += n;
LL tp = d - q[i];
if(tp < 0) continue;
tp = tp / T - t;
if(tp < 0) continue;
res -= tp / n + 1;
}
return res >= K;
}
int main()
{
n = read(), T = m = read(), K = read();
for(int i = 1; i <= n; i++) p[ read() ] = i;
for(int i = 1; i <= m; i++) q[ read() ] = i;
lim = 2 * max(n, m);
LL x, y;
exgcd(n, m, g, x, y);
n /= g, m /= g;
I = (y % n + n) % n;
LL l = 1, r = 1e18, ans = 0;
while(l <= r)
{
LL mid = (l + r) >> 1;
if(check(mid)) ans = mid, r = mid - 1;
else l = mid + 1;
}
printf("%lld\n", ans);
return 0;
}
| 8 | CPP |
t = int(input())
for z in range(t):
n = int(input())
print(0) if n<=2 else print((n-1)//2) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
long long fastpower(long long x, long long n, long long M) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return fastpower((x * x) % M, n / 2, M);
else
return (x * fastpower((x * x) % M, (n - 1) / 2, M)) % M;
}
long long GCD(long long A, long long B) {
if (B == 0)
return A;
else
return GCD(B, A % B);
}
bool vowl(char c) {
return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}
long long modInverse(long long A, long long M) {
return fastpower(A, M - 2, M);
}
void sieve(long long N) {
bool isPrime[N + 1];
for (long long i = 0; i <= N; ++i) {
isPrime[i] = true;
}
isPrime[0] = false;
isPrime[1] = false;
for (long long i = 2; i * i <= N; ++i) {
if (isPrime[i] == true) {
for (long long j = i * i; j <= N; j += i) isPrime[j] = false;
}
}
}
vector<long long> factorize(long long n) {
vector<long long> res;
for (long long i = 2; i * i <= n; ++i) {
while (n % i == 0) {
res.push_back(i);
n /= i;
}
}
if (n != 1) {
res.push_back(n);
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long a, b, c;
cin >> a >> b >> c;
long long cont = (a + b + c) / 2;
cout << cont << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e14;
const long long maxn = 1e4 + 11;
const long long maxm = 1e2 + 11;
string s;
long long p, m;
long long dp[2][maxn][maxm];
long long nxt[maxn];
stack<long long> st;
long long node = 0;
void amax(long long &x, long long y) { x = max(x, y); }
void amin(long long &x, long long y) { x = min(x, y); }
void dfs(long long l, long long r) {
if (r <= l) return;
if (s[l] == '(' && nxt[l] == r) return dfs(l + 1, r - 1);
long long me = node++, lc, rc;
if (r == l + 1) {
dp[0][me][0] = dp[1][me][0] = s[l] - '0';
return;
}
lc = node;
dfs(l, nxt[l]);
rc = node;
dfs(nxt[l] + 1, r);
for (long long i = 0; i <= min(m, p); i++)
for (long long j = 0; j <= i; j++) {
if (p <= m) {
if (i - j >= 1) {
amax(dp[0][me][i], dp[0][lc][j] + dp[0][rc][i - j - 1]);
amin(dp[1][me][i], dp[1][lc][j] + dp[1][rc][i - j - 1]);
}
amin(dp[1][me][i], dp[1][lc][j] - dp[0][rc][i - j]);
amax(dp[0][me][i], dp[0][lc][j] - dp[1][rc][i - j]);
} else {
if (i - j >= 1) {
amax(dp[0][me][i], dp[0][lc][j] - dp[1][rc][i - j - 1]);
amin(dp[1][me][i], dp[1][lc][j] - dp[0][rc][i - j - 1]);
}
amax(dp[0][me][i], dp[0][lc][j] + dp[0][rc][i - j]);
amin(dp[1][me][i], dp[1][lc][j] + dp[1][rc][i - j]);
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s >> p >> m;
iota(nxt, nxt + maxn, 1);
for (long long i = 0; i < 2; i++)
for (long long j = 0; j < maxn; j++)
fill(dp[i][j], dp[i][j] + maxm, (2 * i - 1) * inf);
for (long long i = 0; i < (long long)(s).size(); i++) {
if (s[i] == '(')
st.push(i);
else if (s[i] == ')') {
nxt[st.top()] = i + 1;
st.pop();
}
}
dfs(0, (long long)(s).size());
cout << dp[0][0][min(m, p)] << endl;
return 0;
}
| 11 | CPP |
def solve(s):
for i0 in range(27):
for i1 in range(i0 + 1, 27):
if s[i0] == s[i1]:
break
if s[i0] == s[i1]:
break
assert s[i0] == s[i1]
d = i1 - i0
if d == 1:
return 'Impossible'
res = [None] * 26
def set(idx, ch):
nonlocal res
# 0 12
# 25 13
res[(idx + 26) % 26] = ch
def copy(start_idx):
for idx, ch in enumerate(s[:i1] + s[i1 + 1:]):
set(start_idx + idx, ch)
off = (d // 2 - 1 + d % 2)
copy(12 - off - i0)
assert None not in res
return ''.join(res[:13]) + '\n' + ''.join(reversed(res[13:]))
s = input()
#s = 'ABCGDEFHIJKGLMNOPQRSTUVWXYZ'
#s = 'BCDEFHIJKGLMNOPQRSTUVWXYZAA'
print(solve(s))
| 9 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.