solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > arr;
int sum[100005];
int bs(int low, int high, int req, int x) {
if (!arr.size()) return req;
if (low > high) return req;
int mid = (low + high) / 2;
if (arr[mid].first <= x) return bs(mid + 1, high, req, x);
return bs(low, mid - 1, mid, x);
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
int ind50 = bs(0, arr.size(), i, t - 90);
int val50 = 0;
if (i) val50 = sum[i - 1] - sum[ind50 - 1];
val50 = 50 - val50;
int ind120 = bs(0, arr.size(), i, t - 1440);
int val120 = 0;
if (i) val120 = sum[i - 1] - sum[ind120 - 1];
val120 = 120 - val120;
int ans = 0;
ans = min(20, min(val120, val50));
cout << ans << endl;
arr.push_back({t, ans});
if (!i)
sum[i] = ans;
else
sum[i] = sum[i - 1] + ans;
}
return 0;
}
| 1,600 | CPP |
n,q=map(int,input().split())
a=list(map(int,input().split()))
swaps=[0]*q
for i in range(q):
b=input().split()
b[1]=int(b[1])
out=1 if (b[0]=="<" and b[1]<=0) or (b[0]==">" and b[1]>=0) else 0
split=b[1]+0.5 if b[0]==">" else b[1]-0.5
sign=1 if split>0 else -1
split=abs(split)
swaps[i]=(split,sign,out)
sml=10**5+0.5
zeros=0
for i in range(q):
sml=min(swaps[i][0],sml)
zeros+=1-swaps[i][2]
zeros%=2
arr=[0]*100001
big=100000.5
flips=1
for i in range(q):
if swaps[-1-i][0]<big:
if swaps[-1-i][2]==1:
for j in range(int(swaps[-1-i][0]+0.5),int(big+0.5)):
arr[j]=-swaps[-i-1][1]*flips
else:
for j in range(int(swaps[-1-i][0]+0.5),int(big+0.5)):
arr[j]=swaps[-i-1][1]*flips
big=swaps[-1-i][0]
if swaps[-1-i][2]==0:
flips=-flips
def func(k):
if abs(k)<sml:
return k if zeros==0 else -k
else:
return arr[abs(k)]*abs(k)
print(" ".join([str(func(guy)) for guy in a])) | 2,400 | PYTHON3 |
n=int(input())
a=[int(i) for i in input().split()]
res=1
max1=1
try:
for i in range(n):
if a[i+1]>=a[i]:
res+=1
else:
if res>max1:
max1=res
res=1
except:
if res>max1:
max1=res
print(max1) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 2e5 + 10;
int counts[sz];
int imps[sz];
int main() {
int n;
list<pair<int, int> > rank;
int root;
bool first = true;
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int l;
scanf("%d", &l);
rank.push_front(make_pair(l, counts[l]));
++counts[l];
imps[l] = l;
if (first) {
root = l;
first = false;
}
}
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
lamps;
for (int i = 1; i <= n; ++i) {
if (counts[i] == 0) {
lamps.push(make_pair(i, i));
imps[i] = i;
}
}
bool possible = true;
list<pair<int, int> > wires;
for (auto itr = rank.begin(); itr != rank.end(); ++itr) {
if (lamps.empty()) {
possible = false;
break;
}
pair<int, int> l = lamps.top();
lamps.pop();
wires.emplace_back(itr->first, l.second);
if (itr->second == 0) {
pair<int, int> p = make_pair(max(imps[itr->first], l.first), itr->first);
lamps.push(p);
} else {
imps[itr->first] = max(imps[itr->first], l.first);
}
}
if (possible) {
printf("%d\n", root);
for (auto itw = wires.begin(); itw != wires.end(); ++itw) {
printf("%d %d\n", itw->first, itw->second);
}
} else {
printf("-1\n");
}
return 0;
}
| 2,200 | CPP |
n, s = map(int, input().split())
a = [n - i for i in range(n)]
j = 0
k = 0
while s > 0:
x = s // a[j]
s -= x * a[j]
j += 1
k += x
print(k) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = numeric_limits<int>::max();
inline int pow2(int k) { return 1 << k; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q;
scanf("%d %d", &n, &q);
int s1 = 0;
int s2 = 1;
for (int i = 0; i < q; i++) {
int t, x;
scanf("%d", &t);
if (t == 2) {
if (s1 % 2 == 0) {
s1 += 1;
} else {
s1 -= 1;
}
if (s2 % 2 == 0) {
s2 += 1;
} else {
s2 -= 1;
}
} else {
scanf("%d", &x);
s1 += x;
s2 += x;
}
s1 = s1 % n;
s2 = s2 % n;
}
for (int i = 0; i < n; ++i) {
int k;
if ((i - s1) % 2 == 0) {
k = (i - s1) % n;
k += 1;
} else {
k = (i - s2) % n;
k += 2;
}
if (k <= 0) k += n;
printf("%d ", k);
}
return 0;
}
| 1,800 | CPP |
from collections import Counter
c = Counter()
for _ in range(int(input())):
c.update(input().split())
print('FAIL' if all(c[x]==2 for x in '12345') else 'WIN') | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& vec) {
out << "[";
for (int x : vec) out << x << ", ";
out << "]";
return out;
}
unsigned long long int k, d, t;
unsigned long long int n;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> k >> d >> t;
n = (k + d - 1) / d;
unsigned long long int m = (2ULL * t) / (k + n * d);
double t1 = (double)t - ((double)m * ((double)n * d + (double)k) / 2.0);
double ans = 0;
if (t1 <= k)
ans = t1;
else
ans = 2 * t1 - k;
ans = ans + m * (n * d);
cout.precision(20);
cout << fixed << ans << endl;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int nums[n];
for (int i = 0; i < n; i++) {
int b;
cin >> b;
nums[i] = b;
}
for (int i = 0; i < n - 1; i++) {
cout << nums[i] + nums[i + 1] << " ";
}
cout << nums[n - 1];
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[410], b[410];
int h0, t0, r, n, m, vis[410][410];
int dfs(int first, int second) {
if (vis[first][second]) return vis[first][second];
vis[first][second] = -1;
int _max = 0;
for (int i = 1; i <= min(first, n); i++) {
pair<int, int> p = make_pair(first - i + a[i].first, second + a[i].second);
if (vis[p.first][p.second] == -1) {
cout << "Draw\n";
exit(0);
} else if (p.first + p.second <= r) {
_max = max(_max, dfs(p.first, p.second));
}
}
for (int i = 1; i <= min(second, m); i++) {
pair<int, int> p = make_pair(first + b[i].first, second - i + b[i].second);
if (vis[p.first][p.second] == -1) {
cout << "Draw\n";
exit(0);
} else if (p.first + p.second <= r) {
_max = max(_max, dfs(p.first, p.second));
}
}
return vis[first][second] = _max + 1;
}
void solve() {
memset(vis, 0, sizeof(vis));
dfs(h0, t0);
cout << "Zmey\n" << vis[h0][t0] << endl;
}
int main() {
int first, second;
cin >> first >> second >> r >> n;
h0 = first;
t0 = second;
for (int i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
}
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> b[i].first >> b[i].second;
}
queue<pair<int, int> > q;
q.push(make_pair(first, second));
vis[first][second] = 1;
bool l = 0;
while (!q.empty()) {
tie(first, second) = q.front();
q.pop();
if (second == 0 && 0 == first) {
printf("Ivan\n%d\n", vis[first][second] - 1);
return 0;
}
for (int i = 1; i <= min(first, n); i++) {
pair<int, int> p =
make_pair(first - i + a[i].first, second + a[i].second);
if (vis[p.first][p.second])
l = 1;
else if (p.first + p.second <= r) {
vis[p.first][p.second] = vis[first][second] + 1;
q.push(p);
}
}
for (int i = 1; i <= min(second, m); i++) {
pair<int, int> p =
make_pair(first + b[i].first, second - i + b[i].second);
if (vis[p.first][p.second])
l = 1;
else if (p.first + p.second <= r) {
vis[p.first][p.second] = vis[first][second] + 1;
q.push(p);
}
}
}
if (l)
solve();
else
cout << "Zmey\n" << vis[first][second] << endl;
return 0;
}
| 2,100 | CPP |
'''
# SHREYANS BHAVSAR #
# DDIT #
# @shreyans_9950 #
# CF,CC,HE,HR,GFG #
'''
# import math
# def shrey():
# /*!@#$%^&*()-+=*/
# s=list(input())
# l=len(s)
# ans=""
# for i in range(l):
# if(i==0 or i==l-1 or i%2!=0):
# ans+=s[i]
# print(ans)
# n=int(input())
# a=list(map(int,input().split()))
# c=0
# c1=0
# for i in range(len(a)):
# if(i%2==0 and a[i]%2!=0):
# c+=1
# if(i%2!=0 and a[i]%2==0):
# c1+=1
# if(c!=c1):
# print(-1)
# else:
# print(c)
# a,b=input().split()
# a=int(a)
# b=int(b)
# ans=(60-b)+((23-a)*60)
# print(ans)
# n,k=input().split()
# n=int(n)
# k=int(k)
# print(n-max(0,n%k-k//2))
# n,k=input().split()
# n=int(n)
# k=int(k)
# for i in range(k):
# if(n%10!=0):
# n-=1
# else:
# n=n//10
# print(n)
# T = input()
# T = int(T)
# for q in range(1,T+1):
# /*shreyans bhavsar(DDIT)*/
# shrey()
# n = int(input())
# str1 = input()
# lst1 = []
# for i in range(n-1):
# lst1.append(str1[i:i+2])
# print (max(lst1,key=lst1.count))
# n,k=input().split()
# n=int(n)
# k=int(k)
# a=list(map(int,input().split()))
# a.sort()
# # print(*a)
# if(k==0):
# if(a[0]>1):
# print(1)
# else:
# print(-1)
# else:
# if(k==n or a[k]!=a[k-1]):
# print(a[k-1])
# else:
# print(-1)
# for i in range(int(input())):
# l,v,u,r=map(int,input().split())
# print(l//v-((r//v)-((u-1)//v)))
# for i in range(int(input())):
# a,b,c=map(int,input().split())
# ans=max(0,abs(a-b)+abs(a-c)+abs(b-c)-4)
# print(ans)
# for i in range(int(input())):
# n=int(input())
# b=3
# j=3
# while n%b!=0:
# b=2**j-1
# j+=1
# print(n//b)
# for i in range(int(input())):
# n=int(input())
# if(n%3==0):
# print(n//3)
# else:
# b=3
# c=3
# while(n%b!=0):
# b=2**c-1
# c+=1
# print(n//b)
# for q in range(int(input())):
# n=int(input())
# if((n//2)%2!=0):
# print("NO")
# else:
# s=0
# s1=0
# print("YES")
# ans=[]
# # ans.append(2)
# for i in range(0,n//2):
# c=2*(i+1)
# s+=c
# ans.append(c)
# for i in range(n//2,n-1):
# c=2*(i-n//2+1)-1
# s1+=c
# ans.append(c)
# d=s-s1
# ans.append(d)
# print(*ans)
# for q in range(int(input())):
# n=int(input())
# a=list(map(int,input().split()))
# c=0
# for i in a:
# if i%2!=0:
# c+=1
# if n==c:
# if c%2!=0:
# print("YES")
# else:
# print("NO")
# elif c>0 and n!=c:
# print("YES")
# else:
# print("NO")
# import math
# for q in range(int(input())):
# n=int(input())
# x=(n-1)//9
# print(n+x)
# for q in range(int(input())):
# n=int(input())
# print(1,n-1)
# for q in range(int(input())):
# s=int(input())
# a=list(map(int,input().split()))
# a=set(list(a))
# print(len(a))
# t=int(input())
# for p in range (t):
# n,x=map(int,input().split())
# i=1
# ans=['a']*n
# while i*(i+1)/2<x:
# i+=1
# ans[n-i-1]='b'
# x=x-i*(i-1)//2
# ans[n-x]='b'
# print("".join(ans))
# for q in range(int(input())):
# n=int(input())
# s=list(input())
# ans=[]
# ans1=[]
# f=1
# for i in s:
# if(f):
# if(i=='2'):
# ans.append('1')
# ans1.append('1')
# elif(i=='1'):
# # if(f==0):
# ans.append('1')
# ans1.append('0')
# f=0
# else:
# ans.append('0')
# ans1.append('0')
# else:
# ans.append('0')
# ans1.append(i)
# ans="".join(ans)
# ans1="".join(ans1)
# print(ans)
# print(ans1)
# for q in range(int(input())):
# a,b,n=map(int,input().split())
# i=0
# while(a<=n and b<=n):
# if(a<b):
# i+=1
# a+=b
# else:
# i+=1
# b+=a
# print(i)
# for q in range(int(input())):
import math
# s="codeforces"
# n=int(input())
# if(n==1):
# print(s)
# elif(n==2):
# s+="s"
# print(s)
# elif(n==3):
# s+="ss"
# print(s)
# else:
# t=1
# for i in range(2,51):
# t2=math.pow(i,10)
# t1=t
# if n>=t1 and n<=t2:
# b=i
# break
# else:
# t=t2
# ans=math.pow(b-1,10)
# c=0
# for i in range(1,11):
# c+=1
# ans*=b
# ans//=(b-1)
# if(n<=ans):
# break
# for i in range(10):
# if(i+1<=c):
# for j in range(1,b+1):
# print(s[i],end="")
# else:
# for j in range(1,b+1):
# print(s[i],end="")
# print()
# n = int(input())
# for q in range(n):
# s=input()
# ans=""
# for i in range(len(s)):
# if i
# ==0 or i==len(s)-1 or i%2!=0:
# ans+=s[i]
# ams="".join(ans)
# print(ans)
# for i in range(int(input())):
# a,b,c,d=map(int,input().split())
# if(a*c+b>=d and d%c<=b):
# print("YES")
# else:
# print("NO")
# for q in range(int(input())):
# n=int(input())
# a=list(map(int,input().split()))
# a.sort()
# c=1
# for i in range(n-1):
# if a[i+1]-a[i]==1:
# c=2
# print(c)
# for q in range(int(input())):
# n=int(input())
# a=list(map(int,input().split()))
# b=sum(a)
# a.sort()
# if b%n==0:
# print(b//n)
# else:
# print(b//n+1)
# n,k=map(int,input().split())
# a=list(map(int,input().split()))
# aa=[]
# for i in a:
# if(i in aa):
# continue
# if(len(aa)>=k):
# aa.pop()
# aa.insert(0,i)
# print(len(aa))
# print(*aa)
# n=int(input())
# if(n%2==0 and n>2):
# print("YES")
# else:
# print("NO")
# import math
# n,m,a=map(int,input().split())
# print(math.ceil(n/a)*math.ceil(m/a))
# for i in range(int(input())):
# s=input()
# if(len(s)<=10):
# print(s)
# else:
# s=list(s)
# n=len(s)
# print(s[0],end="")
# print(len(s)-2,end="")
# print(s[n-1])
# n,k=map(int,input().split())
# a=list(map(int,input().split()))
# c=0
# for i in a:
# if(i>=a[k-1] and i>0):
# c+=1
# print(c)
# d=0
# for i in range(int(input())):
# a,b,c=map(int,input().split())
# if(a+b+c>=2):
# d+=1
# print(d)
# n,m=map(int,input().split())
# c=n*m
# print(c//2)
# a=int(input())
# x=0
# p=int(a**0.5)
# k=(p*p==a)
# for i in range(1,p+1-k):
# if(a%i==0):
# x+=2
# x+=k
# print(x)
# n,m,k,l=map(int,input().split())
# d=0
# if((k+l)%m==0):
# d=(k+l)//m
# # print(d)
# else:
# d=(k+l)//m+1
# # print(d)
# if(m*d>n):
# print(-1)
# else:
# print(d)
# c=0
# for i in range(int(input())):
# s=input()
# if(s=="++X" or s=="X++"):
# c+=1
# elif(s=="--X" or s=="X--"):
# c-=1
# print(c)
# s=input()
# s1=input()
# s=s.lower()
# s1=s1.lower()
# if s<s1:
# print(-1)
# elif s>s1:
# print(1)
# else:
# print(0)
# for i in range(5):
# s=input()
# if '1' in s:
# print(abs(i-2)+abs(s.index('1')//2-2))
# for i in (5):
# for j in range(5):
# if(a[i][j]==1):
# w=i+1
# q=j+1
# break
# print(abs(w-2)+abs(q-2))
# s=list(input())
# s=list(s)
# ans=[]
# for i in range(len(s)):
# if(i%2==0):
# ans.append(s[i])
# ans=ans.sort()
# for i in range(len(ans)):
# print(ans[i],end="+")
# print()
# print('+'.join(sorted(input().split('+'))))
# s=input()
# s=list(s)
# s[0]=s[0].upper()
# s="".join(s)
# print(s)
s=input()
if(7*"0" in s or 7*"1" in s):
print("YES")
else:
print("NO") | 900 | PYTHON3 |
import sys
import os.path
if(os.path.exists('input.txt')) :
sys.stdin = open("input.txt", "r")
sys.stdout = open("output.txt", "w")
sys.stderr = open("error.txt", "w")
depth = 1000000
mod = 1000000007
lim = mod * mod
sys.setrecursionlimit(depth)
linp = lambda: list(minp())
minp = lambda: map(int, input().split())
from math import inf, ceil, sqrt, log2, gcd
from collections import defaultdict, deque
dxy = [(1, 0),(-1, 0),(0, 1),(0, -1)]
for _ in range(int(input())) :
n = int(input())
a, s = linp(), input()
blue, red = [], []
for i in range(n) :
if s[i] == 'B' : blue.append(a[i])
else : red.append(a[i])
red.sort(reverse=True)
v = [False for _ in range(n+1)]
j = n
for e in red :
while v[j] != False and j >= e :
j -= 1
if j >= e :
v[j] = True
j -= 1
i = 1
blue.sort()
for e in blue :
while v[i] != False and i <= e :
i += 1
if i <= e :
v[i] = True
i += 1
v = v[1:]
if all(v) : print("YES")
else : print("NO")
| 1,300 | PYTHON3 |
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
avl=AvlTree()
#-----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default='z', func=lambda a, b: min(a ,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left)/ 2)
# Check if middle element is
# less than or equal to key
if (arr[mid]<=key):
count = mid+1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def countGreater( arr,n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
for i in range(int(input())):
x=list(map(int,input().split()))
x.sort(reverse=True)
if x[0]!=x[1]:
print("NO")
continue
print("YES")
print(x[0],x[2],x[2]) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[10000], d[10000];
int main() {
int n, ans = 0;
cin >> n;
for (register int i = 1; i <= n; i++) cin >> a[i] >> d[i];
for (register int i = 1; i <= n; i++) {
if (ans <= a[i])
ans += a[i] - ans + 1;
else if ((ans - a[i]) % d[i] == 0)
ans++;
else
ans += a[i] + ((ans - a[i]) / d[i] + 1) * d[i] - ans + 1;
}
cout << ans - 1 << endl;
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
int A[200005], B[200005], C[200005];
int L[200005];
int N;
int memo[200005][5], vis[200005][5];
int dp(int n, int cur) {
if (n > N) return 0;
if (cur > 3) return 1e8;
if (vis[n][cur]) return memo[n][cur];
vis[n][cur] = 1;
int &res = memo[n][cur] = 1e8;
if (cur < 3) res = min(res, (L[n] != cur + 1) + dp(n + 1, cur + 1));
if (cur < 2) res = min(res, (L[n] != cur + 2) + dp(n + 1, cur + 2));
res = min(res, (L[n] != cur) + dp(n + 1, cur));
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int a, b, c;
cin >> a >> b >> c;
N = a + b + c;
vector<int> aaa(N);
iota(aaa.begin(), aaa.end(), 1);
srand(time(NULL));
random_shuffle(aaa.begin(), aaa.end());
for (int i = 1; i <= a; i++) {
cin >> A[i];
L[A[i]] = 1;
}
for (int i = 1; i <= b; i++) {
cin >> B[i];
L[B[i]] = 2;
}
for (int i = 1; i <= c; i++) {
cin >> C[i];
L[C[i]] = 3;
}
sort(A + 1, A + a + 1);
sort(B + 1, B + b + 1);
sort(C + 1, C + c + 1);
cout << dp(1, 1) << "\n";
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n, a, b;
cin >> n >> a >> b;
vector<int> dancers(n);
for (int i = 0; i < n; ++i) {
cin >> dancers[i];
}
int min_color = min(a, b);
int cost = 0;
for (int i = 0; i < (n + 1) / 2; ++i) {
if (dancers[i] + dancers[n - 1 - i] == 1) {
printf("-1\n");
return 0;
}
if (dancers[i] == dancers[n - i - 1] && dancers[i] <= 1) {
continue;
}
if (dancers[i] == 2 && dancers[n - 1 - i] == 2) {
cost += min_color;
if (i != n - i - 1) cost += min_color;
} else if (dancers[i] == 0 || dancers[n - 1 - i] == 0) {
cost += a;
} else if (dancers[i] == 1 || dancers[n - i - 1] == 1) {
cost += b;
}
}
cout << cost << endl;
return 0;
}
| 1,000 | CPP |
import math
for _ in range(int(input())):
n=int(input());A=list(map(int,input().split()));d={};color=1;B=sorted(list(set(A)));mai=0
for i in A:d[i]=0
for i in range(2,1001):
t=0
for j in B:
if d.get(j,-1) == 0:
if j%i == 0:
t=1
mai = color
d[j] = color
if t==1:
color+=1
print(mai)
for i in A:
print(d[i],end = " ")
print() | 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[1000010];
int num[1010];
int main() {
int n, num1 = 0, maxn = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> num[i];
a[num[i]]++;
}
for (int i = 1; i <= 1000000; i++) {
if (a[i] > maxn) {
maxn = a[i];
num1 = i;
}
if (a[i] == maxn)
for (int j = n; j >= 1; j--) {
if (num[j] == num1) {
maxn = a[i];
num1 = i;
} else if (num[j] == i)
break;
}
}
cout << num1 << endl;
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
inline void writeln(long long a) {
write(a);
puts("");
}
const int N = 250005;
int leaf[N], vis[N], dep[N], fa[N];
vector<int> v[N];
void dfs(int p) {
vis[p] = 1;
dep[p] = dep[fa[p]] + 1;
for (auto i : v[p])
if (!vis[i]) {
leaf[p] = 1;
fa[i] = p;
dfs(i);
}
}
void print(int x, int y) {
writeln(dep[x] - dep[y] + 1);
for (;; x = fa[x]) {
wri(x);
if (x == y) break;
}
puts("");
}
signed main() {
int n = read(), m = read(), k = read();
while (m--) {
int s = read(), t = read();
v[s].push_back(t);
v[t].push_back(s);
}
dfs(1);
for (int i = 1; i <= n; i++)
if ((long long)dep[i] * k >= n) {
puts("PATH");
print(i, 1);
return 0;
}
puts("CYCLES");
int tot = 0;
for (int i = 1; i <= n; i++)
if (leaf[i] == 0) {
int q[4];
q[0] = 0;
for (auto j : v[i])
if (j != fa[i]) q[++*q] = j;
if ((dep[i] - dep[q[1]] + 1) % 3)
print(i, q[1]);
else if ((dep[i] - dep[q[2]] + 1) % 3)
print(i, q[2]);
else {
if (dep[q[1]] < dep[q[2]]) swap(q[1], q[2]);
writeln(dep[q[1]] - dep[q[2]] + 2);
wri(i);
for (int i = q[1];; i = fa[i]) {
wri(i);
if (i == q[2]) break;
}
}
tot++;
if (tot == k) return 0;
}
}
| 2,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100003];
int main() {
ios::sync_with_stdio(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int ok = 0;
for (int i = 30; i >= 0; i--) {
int cnt = 0;
for (int j = 1; j <= n; j++) {
if (a[j] & (1 << i)) cnt++;
}
if (cnt & 1) {
if (n & 1) {
if ((cnt / 2 + 1) & 1) {
ok = 1;
break;
} else {
ok = 2;
break;
}
} else {
ok = 1;
break;
}
}
}
if (ok == 1)
cout << "WIN" << endl;
else if (ok == 2)
cout << "LOSE" << endl;
else
cout << "DRAW" << endl;
}
return 0;
}
| 1,900 | CPP |
s = input()
print(s) if s[0].isupper() else print(s[0].capitalize() + s[1:]) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, j, k, i, an, m, ans[20];
string s;
cin >> n;
for (i = 0; i < n; i++) {
an = 0;
cin >> s;
for (j = 12; j >= 1; j--) {
if (12 % j) {
continue;
}
bool ccan = true, can = false;
can = false;
for (m = 0; m < j; m++) {
ccan = true;
for (k = 0; j * k < 12; k++) {
if (s[j * k + m] == 'O') {
ccan = false;
break;
}
}
can = (can || ccan);
}
if (can) {
ans[an] = j;
an++;
}
}
cout << an << ' ';
for (j = 0; j < an; j++) {
cout << 12 / ans[j] << 'x' << ans[j] << ' ';
}
cout << endl;
}
}
| 1,000 | CPP |
linha = input().split(" ")
alunos = int(linha[0])
ratio = int(linha[1])
losers = alunos
if ratio > alunos/2:
print(0,0,alunos)
else:
a = int((alunos/2) / (ratio + 1))
b = a * ratio
c = ((alunos/2)%(ratio + 1))
losers = (alunos) - (a + b)
print("%i %i %i"%(a,b,losers))
# 1507387086275
| 800 | PYTHON3 |
a = int(input())
b = int(input())
c = int(input())
print(max(a*b*c, a*b+c, a+b*c, a+b+c, a*(b+c), (a+b)*c)) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int ans = 0;
for (; n > 0; n /= 8) ans += n % 8 == 1;
printf("%d\n", ans);
return 0;
}
| 2,100 | CPP |
# cook your dish here
t=int(input())
for _ in range(t):
n=int(input())
print(n)
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const long long infinity = (1000000000 + 11);
void solve() {}
void Task() {
int test;
cin >> test;
for (int i = 1; i <= test; i++) {
solve();
}
}
bool isnum(string str) {
if ((str[0] == '0' && str.size() != 1) || str.size() == 0) {
return false;
}
for (int i = 0; i < str.size(); i++) {
if (!(str[i] >= '0' && str[i] <= '9')) {
return false;
}
}
return true;
}
int main() {
string s;
cin >> s;
vector<string> str;
int x = 0;
str.emplace_back();
for (int i = 0; i < s.size(); i++) {
if (s[i] == ',' || s[i] == ';') {
x++;
str.emplace_back();
continue;
}
str[x].push_back(s[i]);
}
vector<string> a, b;
for (int i = 0; i < str.size(); i++) {
if (isnum(str[i])) {
a.push_back(str[i]);
} else {
b.push_back(str[i]);
}
}
if (a.size() == 0) {
cout << "-\n";
} else {
cout << "\"";
for (int i = 0; i < a.size(); i++) {
if (i != 0) {
cout << ",";
}
cout << a[i];
}
cout << "\""
<< "\n";
}
if (b.size() == 0) {
cout << "-\n";
} else {
cout << "\"";
for (int i = 0; i < b.size(); i++) {
if (i != 0) {
cout << ",";
}
cout << b[i];
}
cout << "\""
<< "\n";
}
return 0;
}
| 1,600 | CPP |
import collections
t = int(input())
def solve(arr, k):
peaks = []
for i in range(1, len(arr)-1):
if arr[i-1] < arr[i] > arr[i+1]:
peaks.append(1)
else:
peaks.append(0)
#print(peaks)
best = (0, 1) # total p, earliest
window = collections.deque()
ones = collections.deque()
bound = [1, 1]
for i in range(0, len(peaks)):
#print(bound[0], window, ones)
if len(window) < k-2:
window.append(peaks[i])
bound[1] += 1
else:
# pop the earliest one
v = window.popleft()
if v == 1:
ones.popleft()
window.append(peaks[i])
bound[0] += 1
bound[1] += 1
if peaks[i] == 1:
ones.append(peaks[i])
# check segment
if len(ones) > best[0] and len(window) == k-2:
best = (len(ones), bound[0]) # totalp, earliest
print(best[0]+1, best[1]) # p+1, earliest peak
for _ in range(t):
n, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
solve(arr, k) | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m[200010];
set<int> s;
struct P {
int i, x;
bool operator<(const P& p) const { return x < p.x; }
} p[200010];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
p[i].i = i;
p[i].x = x;
}
sort(&p[1], &p[n + 1]);
s.insert(0);
s.insert(n + 1);
for (int i = 1; i <= n; i++) {
set<int>::iterator L = s.upper_bound(p[i].i), R = L;
L--;
m[i] = *R - *L - 1;
s.insert(p[i].i);
}
int cnt = 0;
for (int i = n; i > 0 && cnt < n; i--) {
int P = 0;
for (int j = cnt; j < m[i]; j++) printf("%d ", p[i].x), P++;
cnt += P;
}
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int in() {
int n;
scanf("%d", &n);
return n;
}
long long Lin() {
long long n;
scanf("%lld", &n);
return n;
}
double Din() {
double n;
scanf("%lf", &n);
return n;
}
const long long inf = 1e17;
const long long mod = (long long)1e9 + 7;
const int N = 2e5 + 5;
int a[N], b[N], c[N], ans[N];
int solve() {
int n = in(), m = in();
for (int i = 1; i <= n + m; i++) {
a[i] = in();
}
int j = 0, k = 0;
for (int i = 1; i <= n + m; i++) {
int x = in();
if (x == 0)
b[++j] = a[i];
else
c[++k] = a[i];
}
j = 1;
for (int i = 1; i <= n;) {
if (j == m) {
ans[j]++;
i++;
continue;
}
if (abs(b[i] - c[j]) <= abs(b[i] - c[j + 1]))
ans[j]++, i++;
else
j++;
}
for (int i = 1; i <= m; i++) {
if (i > 1) printf(" ");
printf("%d", ans[i]);
}
printf("\n");
return 0;
}
int main() {
int test = 1, tc = 0;
while (test--) {
solve();
}
return 0;
}
| 1,200 | CPP |
n = int(input())
for i in range(1, (n*n)//2+1):
print(i, (n*n-i+1)) | 1,000 | PYTHON3 |
from math import *
a, b = list(map(int, input().split()))
count = 0
if a == b:
print(a, 0)
elif a > b:
count = b
a = a - b
a = floor(a / 2)
print(count, a)
else:
count = a
b = b - a
b = floor(b / 2)
print(count, b)
| 800 | PYTHON3 |
x = int(input())
k = 0
for i in range(5):
k += x//(5-i)
x = x % (5-i)
if x == 0:
break
print(k)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int fun(int x) { return (x * x + x) / 2; }
int32_t main() {
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
list<int> v{3, 1, 4, 2};
long long kh = fun(100);
if (n < 4) {
cout << "-1" << endl;
continue;
}
for (int i = 5; i <= n; i++) {
if (i % 2 != 1)
v.push_front(i);
else
v.push_back(i);
}
for (auto x : v) {
cout << x << " ";
}
cout << endl;
}
return 0;
}
| 1,600 | CPP |
import sys,os,io
from sys import stdin,stdout
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from bisect import bisect_left , bisect_right
import math
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
# else:
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def beautifulpath(n,adj,s):
queue = deque()
indeg = [0]*(n)
for i in range(n):
for j in adj[i]:
indeg[j]+=1
# print(indeg)
for i in range(n):
if(indeg[i]==0):
queue.append(i)
# print(queue)
topo = []
count = 0
dp = [[0 for i in range(26)] for i in range(n)]
while queue:
start = queue.popleft()
topo.append(start)
count+=1
dp[start][ord(s[start])-97] +=1
# print(queue,topo,dp)
for i in adj[start]:
for j in range(26):
dp[i][j] = max(dp[i][j],dp[start][j])
indeg[i]-=1
if(indeg[i]==0):
queue.append(i)
if(count==n):
ans = 0
for i in range(n):
ans = max(ans,max(dp[i]))
return ans
return -1
input = lambda: sys.stdin.readline().strip()
n,m = map(int,input().split())
s = input()
adj = []
for i in range(n+1):
adj.append([])
for i in range(m):
x,y = map(int,input().split())
x-=1
y-=1
adj[x].append(y)
# print(adj)
ans = beautifulpath(n,adj,s)
print(ans)
| 1,700 | PYTHON3 |
n = int(input())
coins = [int(i) for i in input().split(" ")]
half = sum(coins) / 2
coins.sort(reverse=True)
num = 0
total = 0
for c in coins:
if total <= half:
num += 1
total += c
print(num) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 3;
vector<int> adj[N], v[N];
int col[N], ans;
bool vis[N];
void dfs(int x, int p) {
ans = max(ans, (int)v[x].size());
for (int it : v[x]) {
if (col[it]) vis[col[it]] = 1;
}
int c = 1;
for (int it : v[x]) {
if (!col[it]) {
while (vis[c]) c++;
col[it] = c;
vis[c] = 1;
}
}
for (int it : v[x]) vis[col[it]] = 0;
for (int to : adj[x])
if (to != p) dfs(to, x);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int s;
cin >> s;
v[i].resize(s);
int b;
for (int j = 0; j < s; j++) cin >> v[i][j];
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b), adj[b].push_back(a);
}
dfs(1, 0);
ans = max(1, ans);
cout << ans << '\n';
for (int i = 1; i <= m; i++) cout << max(1, col[i]) << ' ';
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct ds {
int cnt;
vector<int> min_data, max_data;
ds() {}
ds(int cnt_ = 1, int data_size = 0)
: cnt(cnt_), min_data(data_size), max_data(data_size) {}
ds(const vector<int>& data) : cnt(1), min_data(data), max_data(data) {}
};
ds join(ds a, const ds& b) {
a.cnt += b.cnt;
for (int i = -1; ++i < ((int)a.min_data.size());) {
a.min_data[i] = min(a.min_data[i], b.min_data[i]);
a.max_data[i] = max(a.max_data[i], b.max_data[i]);
}
return a;
}
int comparing_id;
bool by_min;
bool operator<(const ds& a, const ds& b) {
if (by_min) return a.min_data[comparing_id] < b.min_data[comparing_id];
return a.max_data[comparing_id] < b.max_data[comparing_id];
}
using namespace std::rel_ops;
multiset<ds> se;
bool cmp_itor(const multiset<ds>::iterator& u,
const multiset<ds>::iterator& v) {
return u == se.end() ? false : v == se.end() ? true : *u < *v;
}
bool updatable(const ds& a, const ds& b) {
bool has_lower = false, has_upper = false;
for (int i = -1; ++i < ((int)a.min_data.size());) {
if (a.min_data[i] < b.max_data[i]) has_lower = true;
if (b.min_data[i] < a.max_data[i]) has_upper = true;
}
return has_lower and has_upper;
}
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i++ < n;) {
vector<int> data(k);
for (int f = -1; ++f < k;) cin >> data[f];
ds cur(data);
for (comparing_id = 0; comparing_id < k; ++comparing_id) {
by_min = false;
for (auto it = se.upper_bound(ds(cur.min_data));
it != se.end() and updatable(*it, cur); it = se.erase(it)) {
cur = join(cur, *it);
}
}
comparing_id = 0;
se.insert(cur);
cout << (--se.end())->cnt << '\n';
}
return 0;
}
| 2,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
string toString(char c, int count) {
string ret;
for (int i = 0; i < count; i++) {
ret += c;
}
return ret;
}
int main() {
string s;
cin >> s;
int k;
cin >> k;
int n = (int)s.length();
if (k >= n) {
cout << "0" << endl;
string t;
cout << endl;
return 0;
}
vector<int> a(26);
for (int i = 0; i < (int)s.length(); i++) {
a[s[i] - 'a']++;
}
bool found = false;
while (!found && k > 0) {
int minm = INT_MAX;
int index = 0;
for (int i = 0; i < 26; i++) {
if (a[i] > 0 && k >= a[i]) {
if (a[i] < minm) {
minm = a[i];
index = i;
}
}
}
if (minm == INT_MAX) {
found = true;
continue;
}
int t = a[index];
a[index] = 0;
k -= t;
string m;
for (int i = 0; i < (int)s.length(); i++) {
if (s[i] == (char)(index + 'a')) continue;
m += s[i];
}
s = m;
}
int count = 0;
for (int i = 0; i < (int)s.length(); i++) {
if (a[s[i] - 'a'] > 0) {
count++;
a[s[i] - 'a'] = 0;
}
}
cout << count << endl;
cout << s << endl;
return 0;
}
| 1,200 | CPP |
n=int(input())
a=[]
b=[]
for i in range(2*n):
s=input()
if i<n:
a.append(s)
else:
b.append(s)
c=0
i=0
while(i<len(a)):
if a[i] in b:
ind=b.index(a[i])
del a[i]
del b[ind]
else:
i+=1
c+=1
print(c)
| 1,200 | PYTHON3 |
n, x = list(map(int, input().split()))
n_bosy = 0
for i in range(n):
s,d = input().split()
if(s == "+"):
x += int(d)
else:
if(abs(int(d)) > x):
n_bosy = n_bosy + 1
else:
x -= abs(int(d))
print(f'{x} {n_bosy}') | 800 | PYTHON3 |
s = str(input())
m = n = str()
k = i = 0
for i in range(len(s)):
if s[i] != " ":
m += s[i]
else:
k = i + 1
break;
while k != len(s):
n += s[k]
k+=1
m = int(m)
n = int(n)
a = int(m * n * 0.5)
print(a) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int arr[200010];
int pat[200010];
int def[200010];
int patdef[200010];
int lps[200010];
int nlps[200010];
int n, m;
void kmp() {
lps[0] = 0;
for (int i = 1; i <= m - 1; ++i) {
int j = lps[i - 1];
while (j > 0 && patdef[i] != patdef[j]) {
j = lps[j - 1];
}
if (patdef[i] == patdef[j] || j == 0) j++;
lps[i] = j;
}
}
int main() {
cin >> n >> m;
for (int i = 0; i <= n - 1; ++i) {
cin >> arr[i];
}
def[0] = 0;
for (int i = 1; i <= n - 1; ++i) {
def[i] = arr[i] - arr[i - 1];
}
patdef[0] = 0;
for (int i = 0; i <= m - 1; ++i) {
cin >> pat[i];
}
for (int i = 1; i <= m - 1; ++i) {
patdef[i] = pat[i] - pat[i - 1];
}
kmp();
int j = 0, c = 0;
for (int i = 0; i <= n - 1; ++i) {
while (j > 0 && def[i] != patdef[j]) j = lps[j - 1];
if (def[i] == patdef[j] || i == 0 || j == 0) j++;
if (j >= m) {
c++;
j = lps[j - 1];
}
}
cout << c << "\n";
;
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int maxm = 1e3 + 5;
const int mod = 1e9 + 7;
char ch[maxn], s[maxn];
int main() {
scanf("%s", ch);
int len = strlen(ch);
int top = 0;
s[top++] = ch[0], s[top++] = ch[1];
for (int i = 2; i < len; i++) {
char c = ch[i];
if ((c == s[top - 1] && s[top - 1] == s[top - 2]) ||
(c == s[top - 1] && s[top - 2] == s[top - 3]))
continue;
else
s[top++] = c;
}
s[top] = '\0';
puts(s);
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.find('0') != -1) {
cout << "YES" << endl;
cout << 0 << endl;
return 0;
} else if (s.find('8') != -1) {
cout << "YES" << endl;
cout << 8 << endl;
return 0;
} else {
vector<char> v;
{
if (s.find('2') != -1) v.push_back('2');
if (s.find('4') != -1) v.push_back('4');
if (s.find('6') != -1) v.push_back('6');
}
while (v.size() != 0) {
string a = "00";
a[1] = v.back();
for (long long i = 0; i < s.find_last_of(v.back()); i++) {
a[0] = s[i];
if (stoi(a) % 8 == 0) {
cout << "YES" << endl;
cout << a << endl;
return 0;
}
}
string b = "000";
b[2] = v.back();
for (long long i = 0; i < s.find_last_of(v.back()); i++)
for (long long j = i + 1; j < s.find_last_of(v.back()); j++) {
b[0] = s[i];
b[1] = s[j];
if (stoi(b) % 8 == 0) {
cout << "YES" << endl;
cout << b << endl;
return 0;
}
}
v.pop_back();
}
}
cout << "NO" << endl;
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod(1000000007);
const int inf(INT_MAX);
const int MAXN();
struct record {
int point, score, miss;
};
map<string, record> d;
map<string, record>::iterator it;
struct result {
int p, s, m;
string name;
};
bool compare(result i, result j) {
if (i.p != j.p) return i.p > j.p;
if (i.s - i.m != j.s - j.m) return (i.s - i.m) > (j.s - j.m);
return i.s > j.s;
}
vector<result> a;
vector<string> b;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string t;
cin >> t;
d[t].point = d[t].score = d[t].miss = 0;
}
for (int i = 0; i < n * (n - 1) / 2; i++) {
string t, team1, team2;
cin >> t;
int j = 0;
while (t[j] != '-') j++;
team1 = t.substr(0, j);
team2 = t.substr(j + 1, t.size() - j - 1);
cin >> t;
int num1 = 0, num2 = 0;
j = 0;
while (t[j] != ':') num1 = num1 * 10 + (t[j] - '0'), j++;
j++;
while (j < t.size()) num2 = num2 * 10 + (t[j] - '0'), j++;
if (num1 > num2)
d[team1].point += 3;
else if (num2 > num1)
d[team2].point += 3;
else
d[team1].point++, d[team2].point++;
d[team1].score += num1, d[team1].miss += num2;
d[team2].score += num2, d[team2].miss += num1;
}
for (it = d.begin(); it != d.end(); it++) {
result t;
t.p = it->second.point;
t.s = it->second.score;
t.m = it->second.miss;
t.name = it->first;
a.push_back(t);
}
sort(a.begin(), a.end(), compare);
for (int i = 0; i < a.size() / 2; i++) b.push_back(a[i].name);
sort(b.begin(), b.end());
for (int i = 0; i < b.size(); i++) cout << b[i] << endl;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int N = 1e9 + 7;
long long int r, g, b;
vector<long long int> cr, cg, cb;
long long int dp[204][204][204];
long long int f(long long int x, long long int y, long long int z) {
if (dp[x][y][z] != -1) {
return dp[x][y][z];
}
if ((x == r + 1 && y == g + 1) || (y == g + 1 && z == b + 1) ||
(x == r + 1 && z == b + 1)) {
return 0;
}
long long int res = 0;
if (x == r + 1) {
res = cg[y - 1] * cb[z - 1] + f(x, y + 1, z + 1);
}
if (y == g + 1) {
res = cr[x - 1] * cb[z - 1] + f(x + 1, y, z + 1);
}
if (z == b + 1) {
res = cr[x - 1] * cg[y - 1] + f(x + 1, y + 1, z);
}
if (res) {
dp[x][y][z] = res;
return res;
}
res = max(cr[x - 1] * cg[y - 1] + f(x + 1, y + 1, z),
max(cr[x - 1] * cb[z - 1] + f(x + 1, y, z + 1),
cg[y - 1] * cb[z - 1] + f(x, y + 1, z + 1)));
dp[x][y][z] = res;
return res;
}
void solve() {
for (long long int i = 0; i < 204; i++) {
for (long long int j = 0; j < 204; j++) {
for (long long int k = 0; k < 204; k++) {
dp[i][j][k] = -1;
}
}
}
cin >> r >> g >> b;
cr.resize(r);
cg.resize(g);
cb.resize(b);
for (long long int i = 0; i < r; i++) {
cin >> cr[i];
}
for (long long int i = 0; i < g; i++) {
cin >> cg[i];
}
for (long long int i = 0; i < b; i++) {
cin >> cb[i];
}
sort(cr.begin(), cr.end());
sort(cb.begin(), cb.end());
sort(cg.begin(), cg.end());
reverse(cr.begin(), cr.end());
reverse(cb.begin(), cb.end());
reverse(cg.begin(), cg.end());
cout << f(1, 1, 1) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1e5 + 10;
const int mod = 1e9 + 7;
inline int mul(int a, int b) { return 1ll * a * b % mod; }
inline int qm(int a, int b) {
int s = 1;
while (b) {
if (b & 1) s = mul(s, a);
a = mul(a, a);
b >>= 1;
}
return s;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
if (i) printf(" ");
printf("%d", (2 * n - i) * 2);
}
printf("\n");
}
return 0;
}
| 800 | CPP |
n = int(input())
num = [0, 0, 0, 0]
def calc(x):
num[0] = x // 1000
x %= 1000
num[1] = x // 100
x %= 100
num[2] = x // 10
x %= 10
num[3] = x
calc(n)
ans = 0
for i in range(n+1, 10000):
calc(i)
if (num[0] != num[1] and num[0] != num[2] and num[0] != num[3] and num[1] != num[2] and num[1] != num[3] and num[2] != num[3]):
ans = i
break;
print(ans) | 800 | PYTHON3 |
#!/usr/bin/python3
# @Author : indiewar
n = int(input())
s = input()
dp = [0 for i in range(30)]
ans = [1 for i in range(n)]
for i in range(n):
tmp = ord(s[i]) - ord('a')
for j in range(tmp+1,26):
ans[i] = max(ans[i],dp[j]+1)
dp[tmp] = ans[i]
print(max(ans))
for i in ans:
print(i,end=" ") | 2,000 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
a = list(input())
ans = n
for i in range(n):
if(a[i] == '1'):
ans = max(ans, 2*(n - i), 2*(i+1))
print(ans) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int la, ra, lb, rb, x, y, wx, wy, lla, rra, llb, rrb, best, i, p;
void solve(int l, int r, int &x, int &w) {
int p = 0, z = 0, i;
for (i = 1;; i = 2 * i + 1, z++)
if (r - (r & i) < l)
break;
else
p = i;
x = r - (r & p);
w = z;
}
int ints(int la, int ra, int lb, int rb) {
int x = max(la, lb), y = min(ra, rb);
return max(0, y - x + 1);
}
int main() {
scanf("%d%d%d%d", &la, &ra, &lb, &rb);
solve(la, ra, x, wx);
solve(lb, rb, y, wy);
if (wx == wy)
best = ints(la, ra, x - y + lb, x - y + rb);
else if (wx < wy)
best = max(ints(y - (1 << wx) - x + la, y - (1 << wx) - x + ra, lb, rb),
ints(y + (1 << wx) - x + la, y + (1 << wx) - x + ra, lb, rb));
else
best = max(ints(la, ra, x - (1 << wy) - y + lb, x - (1 << wy) - y + rb),
ints(la, ra, x + (1 << wy) - y + lb, x + (1 << wy) - y + rb));
for (i = min(wx, wy); i > 0; i--) {
p = 1 << i;
lla = max(1, p - x + la);
rra = min(p - 1, ra - x);
llb = max(1, p - y + lb);
rrb = min(p - 1, rb - y);
best = max(best, ints(lla, p - 1, llb, p - 1));
best = max(best, ints(lla, p - 1, 1, rrb));
best = max(best, ints(1, rra, llb, p - 1));
best = max(best, ints(1, rra, 1, rrb));
}
printf("%d\n", best);
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
long long n;
string s;
int cnt;
long long a[500000];
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> s;
for (int i = 0; i < n; i++) {
a[cnt] = 1;
while (i != n && s[i] == s[i + 1]) {
a[cnt]++;
i++;
}
cnt++;
}
cout << (n * (n - 1)) / 2 - 2 * n + a[0] + a[cnt - 1] + cnt - 1;
return 0;
}
| 1,900 | CPP |
m = 0
p = 0
for i in range(int(input())):
a, b = map(int, input().split())
p = p - a + b
m = max(m, p)
print(m) | 800 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("", on)
using namespace std;
const long long maxn = 5e5 + 13;
const long long INF = 2e9 + 13;
const long long MOD = 1e9 + 7;
double a[maxn];
double f(double x, long long n) {
vector<double> pref(n), b(n);
double minS = INF, maxS = -INF;
pref[0] = a[1] - x;
for (long long i = 1; i <= n; ++i)
b[i - 1] = a[i] - x, minS = min(a[i] - x, minS), maxS = max(maxS, a[i] - x);
for (long long i = 1; i < n; ++i) pref[i] = pref[i - 1] + b[i];
double minl = 0;
for (long long i = 0; i < n; ++i) {
maxS = max(maxS, pref[i] - minl);
minl = min(pref[i], minl);
}
minl = 0;
for (long long i = 0; i < n; ++i) {
minS = min(minS, pref[i] - minl);
minl = max(minl, pref[i]);
}
return max(abs(minS), abs(maxS));
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
double maxe = 0;
for (long long i = 1; i <= n; ++i) cin >> a[i], maxe = max(maxe, abs(a[i]));
double l = -maxe - 1, r = maxe + 1;
for (long long i = 1; i <= 100; ++i) {
double x1 = l + (r - l) / 3;
double x2 = l + (2 * (r - l)) / 3;
double f1 = f(x1, n);
double f2 = f(x2, n);
if (f1 > f2)
l = x1;
else
r = x2;
}
cout << fixed << setprecision(10) << f(l, n) << "\n";
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct q_ {
int t;
int a;
int b;
};
struct node_ {
int x;
node_ *l, *r;
int ex;
int min, max;
int n;
long long s, v;
};
void parse(node_ *t, int onlyex = 0) {
if (t == NULL) return;
parse(t->l, onlyex);
if (!onlyex || t->ex) {
cout << "x " << t->x << endl;
cout << "ex " << t->ex << endl;
cout << "min " << t->min << endl;
cout << "max " << t->max << endl;
cout << "n " << t->n << endl;
cout << "s " << t->s << endl;
cout << "v " << t->v << endl;
cout << endl;
}
parse(t->r, onlyex);
}
void parse2(node_ *t, int level = 1) {
if (t == NULL) return;
parse2(t->l, level + 1);
cout << "x " << t->x << endl;
cout << "ex " << t->ex << endl;
cout << "level " << level << endl;
cout << endl;
parse2(t->r, level + 1);
}
vector<int> v;
int x[100000];
int x_[100000];
int n, m, vs;
q_ q[100000];
node_ *t;
node_ pool[200004];
int poolsz;
void mix(int n1, long long s1, long long v1, int n2, long long s2, long long v2,
int &n, long long &s, long long &v) {
v = v1 + v2 + n1 * s2 - n2 * s1;
n = n1 + n2;
s = s1 + s2;
}
node_ *maketree(int i, int j) {
if (i > j) return NULL;
int m = (i + j) / 2;
node_ *n = &pool[poolsz++];
n->x = v[m];
n->ex = 0;
n->l = maketree(i, m - 1);
n->r = maketree(m + 1, j);
return n;
}
void mark(int x, node_ *t) {
if (t->x == x)
t->ex = 1;
else if (x < t->x)
mark(x, t->l);
else
mark(x, t->r);
}
void setup(node_ *t, int &n, long long &s, long long &v, int &min, int &max) {
if (t == NULL) {
min = 2000000000;
max = -2000000000;
n = 0;
s = 0;
v = 0;
} else {
int n1, mn1, mx1, n2, mn2, mx2;
long long s1, v1, s2, v2;
setup(t->l, n1, s1, v1, mn1, mx1);
setup(t->r, n2, s2, v2, mn2, mx2);
min = 2000000000;
max = -2000000000;
if (t->ex) {
mix(n1, s1, v1, 1, t->x, 0, n1, s1, v1);
min = t->x;
max = t->x;
}
mix(n1, s1, v1, n2, s2, v2, n, s, v);
min = (min < mn1 ? min : mn1);
min = (min < mn2 ? min : mn2);
max = (max > mx1 ? max : mx1);
max = (max > mx2 ? max : mx2);
t->n = n;
t->s = s;
t->v = v;
t->min = min;
t->max = max;
}
}
void q2(node_ *t, int l, int r, int &n, long long &s, long long &v) {
if (t == NULL || t->max < l || t->min > r) {
n = 0;
s = 0;
v = 0;
} else if (t->x < l) {
q2(t->r, l, r, n, s, v);
} else if (t->x > r) {
q2(t->l, l, r, n, s, v);
} else {
if (l <= t->min && r >= t->max) {
n = t->n;
s = t->s;
v = t->v;
return;
}
int n1, n2;
long long s1, v1, s2, v2;
q2(t->l, l, r, n1, s1, v1);
q2(t->r, l, r, n2, s2, v2);
if (t->ex) {
mix(n1, s1, v1, 1, t->x, 0, n1, s1, v1);
}
mix(n1, s1, v1, n2, s2, v2, n, s, v);
}
}
void q1(node_ *t, int x, int add, int &n, long long &s, long long &v, int &min,
int &max) {
if (t == NULL) {
n = 0;
s = 0;
v = 0;
return;
}
int n1, mn1, mx1;
int nm, mnm, mxm;
int n2, mn2, mx2;
long long s1, v1, sm, vm, s2, v2;
if (x == t->x) {
t->ex = add;
n1 = (t->l == NULL ? 0 : t->l->n);
s1 = (t->l == NULL ? 0 : t->l->s);
v1 = (t->l == NULL ? 0 : t->l->v);
mn1 = (t->l == NULL ? 2000000000 : t->l->min);
mx1 = (t->l == NULL ? -2000000000 : t->l->max);
nm = add;
sm = (add ? t->x : 0);
vm = 0;
mnm = (add ? t->x : 2000000000);
mxm = (add ? t->x : -2000000000);
n2 = (t->r == NULL ? 0 : t->r->n);
s2 = (t->r == NULL ? 0 : t->r->s);
v2 = (t->r == NULL ? 0 : t->r->v);
mn2 = (t->r == NULL ? 2000000000 : t->r->min);
mx2 = (t->r == NULL ? -2000000000 : t->r->max);
} else if (x < t->x) {
q1(t->l, x, add, n1, s1, v1, mn1, mx1);
nm = t->ex;
sm = (t->ex ? t->x : 0);
vm = 0;
mnm = (t->ex ? t->x : 2000000000);
mxm = (t->ex ? t->x : -2000000000);
n2 = (t->r == NULL ? 0 : t->r->n);
s2 = (t->r == NULL ? 0 : t->r->s);
v2 = (t->r == NULL ? 0 : t->r->v);
mn2 = (t->r == NULL ? 2000000000 : t->r->min);
mx2 = (t->r == NULL ? -2000000000 : t->r->max);
} else {
n1 = (t->l == NULL ? 0 : t->l->n);
s1 = (t->l == NULL ? 0 : t->l->s);
v1 = (t->l == NULL ? 0 : t->l->v);
mn1 = (t->l == NULL ? 2000000000 : t->l->min);
mx1 = (t->l == NULL ? -2000000000 : t->l->max);
nm = t->ex;
sm = (t->ex ? t->x : 0);
vm = 0;
mnm = (t->ex ? t->x : 2000000000);
mxm = (t->ex ? t->x : -2000000000);
q1(t->r, x, add, n2, s2, v2, mn2, mx2);
}
min = (mn1 < mnm ? mn1 : mnm);
min = (min < mn2 ? min : mn2);
max = (mx1 > mxm ? mx1 : mxm);
max = (max > mx2 ? max : mx2);
mix(n1, s1, v1, nm, sm, vm, n1, s1, v1);
mix(n1, s1, v1, n2, s2, v2, n, s, v);
t->n = n;
t->s = s;
t->v = v;
t->min = min;
t->max = max;
}
int main() {
ios_base::sync_with_stdio(false);
poolsz = 0;
cin >> n;
v.reserve(n);
for (int i = 0; i < n; i++) {
cin >> x[i];
v.push_back(x[i]);
}
memcpy(x_, x, sizeof(int) * n);
cin >> m;
v.reserve(n + m);
for (int i = 0; i < m; i++) {
cin >> q[i].t >> q[i].a >> q[i].b;
if (q[i].t == 1) {
q[i].a--;
x_[q[i].a] += q[i].b;
v.push_back(x_[q[i].a]);
}
}
sort(v.begin(), v.end());
vs = 1;
for (int i = 1; i < v.size(); i++) {
if (v[i] != v[vs - 1]) v[vs++] = v[i];
}
t = maketree(0, vs - 1);
for (int i = 0; i < n; i++) mark(x[i], t);
int i1, i4, i5;
long long l2, l3;
setup(t, i1, l2, l3, i4, i5);
for (int i = 0; i < m; i++) {
if (q[i].t == 1) {
q1(t, x[q[i].a], 0, i1, l2, l3, i4, i5);
x[q[i].a] += q[i].b;
q1(t, x[q[i].a], 1, i1, l2, l3, i4, i5);
} else {
q2(t, q[i].a, q[i].b, i1, l2, l3);
cout << l3 << endl;
}
}
return 0;
}
| 2,500 | CPP |
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <cstring>
#include <list>
#include <cassert>
#include <climits>
#include <bitset>
#include <chrono>
#include <random>
using namespace std;
#define PB push_back
#define MP make_pair
#define SZ(v) ((int)(v).size())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) FORE(i,0,n)
#define FORSZ(i,a,v) FOR(i,a,SZ(v))
#define REPSZ(i,v) REP(i,SZ(v))
std::mt19937 rnd((int)std::chrono::steady_clock::now().time_since_epoch().count());
typedef long long ll;
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
template<typename Item, typename Sum, typename Lazy> struct SplayTree {
struct Node { int par, ch[2]; Item item; Sum sum; Lazy lazy; Node(Item item, Sum sum, Lazy lazy) :par(-1), item(item), sum(sum), lazy(lazy) { ch[0] = ch[1] = -1; } };
vector<Node> nodes;
void reset() { nodes.clear(); }
void apply(int x, Lazy lazy) { nodes[x].item += lazy; nodes[x].sum += lazy; nodes[x].lazy += lazy; }
void push(int x) { REP(z, 2) if (nodes[x].ch[z] != -1) apply(nodes[x].ch[z], nodes[x].lazy); nodes[x].lazy = Lazy(); }
void update(int x) { nodes[x].sum = Sum(); if (nodes[x].ch[0] != -1) nodes[x].sum += nodes[nodes[x].ch[0]].sum; nodes[x].sum += Sum(nodes[x].item); if (nodes[x].ch[1] != -1) nodes[x].sum += nodes[nodes[x].ch[1]].sum; }
void connect(int x, int p, int z) { if (x != -1) nodes[x].par = p; if (p != -1) nodes[p].ch[z] = x; }
int disconnect(int p, int z) { int x = nodes[p].ch[z]; nodes[p].ch[z] = -1; if (x != -1) nodes[x].par = -1; return x; }
void rotate(int x) {
int p = nodes[x].par, g = nodes[p].par, z = nodes[p].ch[0] == x ? 0 : 1, y = nodes[x].ch[1 - z]; push(p), push(x);
connect(y, p, z), connect(p, x, 1 - z), connect(x, g, g == -1 ? -1 : nodes[g].ch[0] == p ? 0 : 1); update(p);
}
void splay(int x, int y = -1) { if (nodes[x].par == y) return; while (nodes[x].par != y) { int p = nodes[x].par, g = nodes[p].par; if (g != y) rotate((nodes[p].ch[0] == x) == (nodes[g].ch[0] == p) ? p : x); rotate(x); } update(x); }
int first(int x) { if (x == -1) return x; splay(x); while (nodes[x].ch[0] != -1) x = nodes[x].ch[0]; splay(x); return x; }
int last(int x) { if (x == -1) return x; splay(x); while (nodes[x].ch[1] != -1) x = nodes[x].ch[1]; splay(x); return x; }
int add(Item item) { nodes.PB(Node(item, Sum(item), Lazy())); return SZ(nodes) - 1; };
int join(int l, int r) { if (l == -1) return r; l = last(l); push(l); connect(r, l, 1); update(l); return l; }
void split(int x, int v, int& l, int& r) {
if (x == -1) { l = r = -1; return; } else splay(x);
l = r = -1;
while (x != -1) { push(x); if (nodes[x].item.l() < v) l = x, x = nodes[x].ch[1]; else r = x, x = nodes[x].ch[0]; }
if (l != -1) splay(l); if (r != -1) splay(r, l);
if (l == -1) return;
assert(nodes[l].par == -1 && nodes[l].ch[1] == r && (r == -1 || nodes[r].ch[0] == -1));
push(l); disconnect(l, 1); update(l);
if (nodes[l].item.r() < v) return;
Item splitted = nodes[l].item.split(v);
if (nodes[l].ch[0] != -1 && nodes[nodes[l].ch[0]].item.r() == nodes[l].item.r()) l = disconnect(l, 0);
if (r == -1 || splitted.l() != nodes[r].item.l()) r = join(add(splitted), r);
update(l);
}
void gather(int x, vector<Item>& ret) { push(x); if (nodes[x].ch[0] != -1) gather(nodes[x].ch[0], ret); ret.PB(nodes[x].item); if (nodes[x].ch[1] != -1) gather(nodes[x].ch[1], ret); }
vector<Item> all(int x) { vector<Item> ret; if (x != -1) splay(x), gather(x, ret); return ret; }
};
const int MAXRECT = 200000;
const int INF = 1000000000;
struct Rect { int lt, rt, lx, rx; };
int nrect, sx;
Rect rect[MAXRECT];
struct Line {
int ly, ry, lcost, slope;
Line() {}
Line(int ly, int ry, int lcost, int slope) :ly(ly), ry(ry), lcost(lcost), slope(ly == ry ? 0 : slope) {}
int rcost() { return lcost + slope * (ry - ly); }
int len() { return ry - ly; }
void setly(int nly) { lcost += (nly - ly) * slope; ly = nly; if (ly == ry) slope = 0; }
void setry(int nry) { ry = nry; if (ly == ry) slope = 0; }
int l() { return ly; }
int r() { return ry; }
Line split(int y) {
assert(ly < y && y <= ry);
auto ret = Line(y, ry, lcost + (y - ly) * slope, slope);
setry(y - 1);
return ret;
}
};
struct SumLine { SumLine() {} SumLine(Line line) {} };
SumLine& operator+=(SumLine& a, const SumLine& b) { return a; }
struct LazyLine {};
Line& operator+=(Line& a, const LazyLine& b) { return a; }
SumLine& operator+=(SumLine& a, const LazyLine& b) { return a; }
LazyLine& operator+=(LazyLine& a, const LazyLine& b) { return a; }
SplayTree<Line, SumLine, LazyLine> linetree;
void printfunc(int lineroot,int tline) {
if (lineroot == -1) {
printf(" BLOCKED");
} else {
auto alllines = linetree.all(lineroot);
for (auto line : alllines) printf(" (%d,%d)..(%d,%d)", line.ly == -INF ? -INF : line.ly + tline, line.ly == -INF ? INF : line.lcost, line.ry == +INF ? +INF : line.ry + tline, line.ry == +INF ? INF : line.rcost());
}
puts("");
}
int t;
int rtrimfunc(int node, int nry) {
while(true) {
node = linetree.last(node);
if (linetree.nodes[node].item.ry <= nry) break;
if (linetree.nodes[node].item.ly < nry || linetree.nodes[node].item.ly == nry && linetree.nodes[node].ch[0] == -1) {
linetree.nodes[node].item.setry(nry);
break;
}
node = linetree.disconnect(node, 0);
assert(node != -1);
}
return node;
}
int lgrowfunc(int node, int nly) {
node = linetree.first(node);
assert(nly <= linetree.nodes[node].item.ly);
if (nly == linetree.nodes[node].item.ly) return node;
if (linetree.nodes[node].item.slope == -1 || linetree.nodes[node].item.ly == linetree.nodes[node].item.ry) {
linetree.nodes[node].item.slope = -1;
linetree.nodes[node].item.setly(nly);
linetree.update(node);
} else {
Line line(nly, linetree.nodes[node].item.ly, linetree.nodes[node].item.lcost + linetree.nodes[node].item.ly - nly, -1);
node = linetree.join(linetree.add(line), node);
}
return node;
}
int rgrowfunc(int node, int nry) {
node = linetree.last(node);
assert(nry >= linetree.nodes[node].item.ry);
if (nry == linetree.nodes[node].item.ry) return node;
if (linetree.nodes[node].item.slope == +1 || linetree.nodes[node].item.ly == linetree.nodes[node].item.ry) {
linetree.nodes[node].item.slope = +1;
linetree.nodes[node].item.setry(nry);
linetree.update(node);
} else {
Line line(linetree.nodes[node].item.ry, nry, linetree.nodes[node].item.rcost(), +1);
node = linetree.join(node, linetree.add(line));
}
return node;
}
int shiftfunc(int node, int dt) {
if (dt == 0) return node;
node = linetree.first(node);
int ply = linetree.nodes[node].item.ly;
if (ply != -INF) node = lgrowfunc(node, ply - dt);
node = linetree.last(node);
int pry = linetree.nodes[node].item.ry;
if (pry != +INF) node = rtrimfunc(node, pry - dt);
return node;
}
int mergefunc(int l, int r) {
//printf("merging\n");
//printfunc(l, t);
//printfunc(r, t);
l = linetree.last(l);
r = linetree.first(r);
while (l != -1 && r != -1 && linetree.nodes[l].item.rcost() > linetree.nodes[r].item.lcost) {
assert(linetree.nodes[l].item.ry == linetree.nodes[r].item.ly);
if (linetree.nodes[l].item.slope == -1 || linetree.nodes[l].item.ly == linetree.nodes[l].item.ry) {
r = lgrowfunc(r, linetree.nodes[l].item.ly);
l = linetree.disconnect(l, 0);
} else {
assert(linetree.nodes[l].item.slope == 1);
if (linetree.nodes[r].item.lcost + linetree.nodes[l].item.len() <= linetree.nodes[l].item.lcost) {
r = lgrowfunc(r, linetree.nodes[l].item.ly);
l = linetree.disconnect(l, 0);
} else {
int y = linetree.nodes[r].item.lcost - linetree.nodes[l].item.lcost + linetree.nodes[l].item.ly + linetree.nodes[l].item.ry; assert(y % 2 == 0); y /= 2;
assert(y > linetree.nodes[l].item.ly && y < linetree.nodes[l].item.ry);
r = lgrowfunc(r, y);
linetree.nodes[l].item.setry(y);
}
}
l = linetree.last(l);
r = linetree.first(r);
}
while (l != -1 && r != -1 && linetree.nodes[l].item.rcost() < linetree.nodes[r].item.lcost) {
assert(linetree.nodes[l].item.ry == linetree.nodes[r].item.ly);
if (linetree.nodes[r].item.slope == +1 || linetree.nodes[r].item.ly == linetree.nodes[r].item.ry) {
l = rgrowfunc(l, linetree.nodes[r].item.ry);
r = linetree.disconnect(r, 1);
} else {
assert(linetree.nodes[r].item.slope == -1);
if (linetree.nodes[l].item.rcost() + linetree.nodes[r].item.len() <= linetree.nodes[r].item.rcost()) {
l = rgrowfunc(l, linetree.nodes[r].item.ry);
r = linetree.disconnect(r, 1);
} else {
int y = linetree.nodes[r].item.rcost() - linetree.nodes[l].item.rcost() + linetree.nodes[r].item.ly + linetree.nodes[r].item.ry; assert(y % 2 == 0); y /= 2;
assert(y > linetree.nodes[r].item.ly && y < linetree.nodes[r].item.ry);
l = rgrowfunc(l, y);
linetree.nodes[r].item.setly(y);
}
}
l = linetree.last(l);
r = linetree.first(r);
}
int ret = linetree.join(l, r);
//printf("-> "); printfunc(ret, t);
return ret;
}
struct Region {
int lx, rx, blockcnt, lineroot, tline;
Region(int lx, int rx, int blockcnt, int lineroot, int tline) :lx(lx), rx(rx), blockcnt(blockcnt), lineroot(lineroot), tline(tline) {};
int l() { return lx; }
int r() { return rx; }
void norm() { if (lineroot != -1) { lineroot = shiftfunc(lineroot, t - tline); tline = t; } }
Region split(int x) {
assert(lx < x && x <= rx);
norm();
auto ret = Region(x, rx, blockcnt, -1, tline);
rx = x - 1;
if (lineroot != -1) linetree.split(lineroot, x - t, lineroot, ret.lineroot);
return ret;
};
};
struct SumRegion {
int mnblockcnt;
SumRegion() { mnblockcnt = INT_MAX; }
SumRegion(Region region) { mnblockcnt = region.lineroot == -1 ? INT_MAX : region.blockcnt; }
};
SumRegion& operator+=(SumRegion& a, const SumRegion& b) { a.mnblockcnt = min(a.mnblockcnt, b.mnblockcnt); return a; }
struct LazyRegion {
int lazyblockcnt;
LazyRegion() { lazyblockcnt = 0; }
LazyRegion(int lazyblockcnt) :lazyblockcnt(lazyblockcnt) {}
};
Region& operator+=(Region& a, const LazyRegion& b) { a.blockcnt += b.lazyblockcnt; return a; }
SumRegion& operator+=(SumRegion& a, const LazyRegion& b) { if (a.mnblockcnt != INT_MAX) a.mnblockcnt += b.lazyblockcnt; return a; }
LazyRegion& operator+=(LazyRegion& a, const LazyRegion& b) { a.lazyblockcnt += b.lazyblockcnt; return a; }
SplayTree<Region, SumRegion, LazyRegion> regiontree;
void print(int regionroot) {
auto allregions = regiontree.all(regionroot);
for (auto region : allregions) {
//region.norm();
printf("[%d..%d] = %d:", region.lx, region.rx, region.blockcnt); if (region.lineroot!=-1 && region.tline != t) printf(" (delay %d)", t - region.tline);
printfunc(region.lineroot, region.tline);
}
}
int killzeroes(int node) {
regiontree.splay(node);
while (regiontree.nodes[node].sum.mnblockcnt == 0) {
//printf("killing\n"); print(node);
while (regiontree.nodes[node].item.blockcnt != 0 || regiontree.nodes[node].item.lineroot == -1) {
//printf("node=%d\n", node);
if (regiontree.nodes[node].ch[0] != -1 && regiontree.nodes[regiontree.nodes[node].ch[0]].sum.mnblockcnt == 0) {
node = regiontree.nodes[node].ch[0];
} else {
node = regiontree.nodes[node].ch[1];
}
assert(node != -1 && regiontree.nodes[node].sum.mnblockcnt == 0);
}
//printf("found node=%d\n", node);
assert(regiontree.nodes[node].item.lineroot != -1);
regiontree.splay(node);
regiontree.nodes[node].item.lineroot = -1;
regiontree.update(node);
}
return node;
}
int rgrow(int node, int x) {
int l, r; regiontree.split(node, x + 1, l, r);
l = regiontree.last(l);
r = regiontree.first(r);
//printf("growing\n");
//printf("l\n"); print(l);
//printf("r\n"); print(r);
if (l == -1 || regiontree.nodes[l].item.lineroot == -1) return regiontree.join(l, r);
while (r != -1 && regiontree.nodes[r].item.lineroot == -1 && regiontree.nodes[r].item.blockcnt == 0) {
//printf("step\n");
assert(regiontree.nodes[l].item.rx + 1 == regiontree.nodes[r].item.lx);
regiontree.nodes[l].item.rx = regiontree.nodes[r].item.rx;
r = regiontree.disconnect(r, 1);
r = regiontree.first(r);
}
if (r != -1 && regiontree.nodes[r].item.lineroot != -1) {
assert(regiontree.nodes[l].item.rx + 1 == regiontree.nodes[r].item.lx);
regiontree.nodes[l].item.rx = regiontree.nodes[r].item.lx;
regiontree.nodes[l].item.norm();
regiontree.nodes[l].item.lineroot = rgrowfunc(regiontree.nodes[l].item.lineroot, regiontree.nodes[l].item.rx - t);
regiontree.nodes[r].item.norm();
regiontree.nodes[l].item.lineroot = mergefunc(regiontree.nodes[l].item.lineroot, regiontree.nodes[r].item.lineroot);
regiontree.nodes[l].item.rx = regiontree.nodes[r].item.rx;
r = regiontree.disconnect(r, 1);
} else {
regiontree.nodes[l].item.norm();
regiontree.nodes[l].item.lineroot = rgrowfunc(regiontree.nodes[l].item.lineroot, regiontree.nodes[l].item.rx - t);
}
int ret = regiontree.join(l, r);
//printf("after rgrow\n"); print(ret);
return ret;
}
int lgrow(int node, int x) {
//printf("lgrow %d\n", x);
int l, r; regiontree.split(node, x, l, r);
l = regiontree.last(l);
r = regiontree.first(r);
if (r == -1 || regiontree.nodes[r].item.lineroot == -1) return regiontree.join(l, r);
while (l != -1 && regiontree.nodes[l].item.lineroot == -1 && regiontree.nodes[l].item.blockcnt == 0) {
assert(regiontree.nodes[l].item.rx + 1 == regiontree.nodes[r].item.lx);
regiontree.nodes[r].item.lx = regiontree.nodes[l].item.lx;
l = regiontree.disconnect(l, 0);
l = regiontree.last(l);
}
if (l != -1 && regiontree.nodes[l].item.lineroot != -1) {
assert(regiontree.nodes[l].item.rx + 1 == regiontree.nodes[r].item.lx);
regiontree.nodes[l].item.rx = regiontree.nodes[r].item.lx;
regiontree.nodes[l].item.norm();
regiontree.nodes[l].item.lineroot = rgrowfunc(regiontree.nodes[l].item.lineroot, regiontree.nodes[l].item.rx - t);
regiontree.nodes[r].item.norm();
regiontree.nodes[l].item.lineroot = mergefunc(regiontree.nodes[l].item.lineroot, regiontree.nodes[r].item.lineroot);
regiontree.nodes[l].item.rx = regiontree.nodes[r].item.rx;
r = regiontree.disconnect(r, 1);
} else {
regiontree.nodes[r].item.norm();
regiontree.nodes[r].item.lineroot = lgrowfunc(regiontree.nodes[r].item.lineroot, regiontree.nodes[r].item.lx - t);
}
return regiontree.join(l, r);
}
int solve() {
//REP(i, nrect) printf("t=%d..%d y=%d..%d to %d..%d\n", rect[i].lt, rect[i].rt, rect[i].lx - rect[i].lt, rect[i].rx - rect[i].lt, rect[i].lx - rect[i].rt, rect[i].rx - rect[i].rt);
linetree.reset();
regiontree.reset();
int linedn = linetree.add(Line(-INF, sx, abs(-INF - sx), -1));
int lineup = linetree.add(Line(sx, +INF, 0, +1));
int lineroot = linetree.join(linedn, lineup);
int regionroot = regiontree.add(Region(-INF, +INF, 0, lineroot, 0));
vector<pair<int, int>> e;
REP(i, nrect) e.PB(MP(2 * rect[i].lt + 1, i)), e.PB(MP(2 * rect[i].rt + 0, i));
sort(e.begin(), e.end());
//printf("INITIAL\n"); print(regionroot);
REPSZ(i, e) {
t = e[i].first >> 1; int kind = e[i].first & 1, idx = e[i].second;
if (kind == 0) { // release rect
int l, m, r;
regiontree.split(regionroot, rect[idx].lx + 1, l, m);
regiontree.split(m, rect[idx].rx, m, r);
regiontree.apply(m, LazyRegion(-1));
regionroot = regiontree.join(regiontree.join(l, m), r);
regionroot = rgrow(regionroot, rect[idx].lx);
regionroot = lgrow(regionroot, rect[idx].rx);
}
if (kind == 1) { // block rect
int l, m, r;
regiontree.split(regionroot, rect[idx].lx + 1, l, m);
//printf("L\n"); print(l);
//printf("M\n"); print(m);
regiontree.split(m, rect[idx].rx, m, r);
//printf("M\n"); print(m);
//printf("R\n"); print(r);
m = killzeroes(m);
//printf("M\n"); print(m);
regiontree.apply(m, LazyRegion(1));
regionroot = regiontree.join(regiontree.join(l, m), r);
}
//printf("after %s rect %d (t=%d)\n", kind == 0 ? "releasing" : "blocking", idx + 1, t); print(regionroot);
//if (i == 0) exit(0);
}
//printf("FINAL (t=%d)\n",t); print(regionroot);
auto finalregions = regiontree.all(regionroot);
assert(SZ(finalregions) == 1);
auto finalregion = finalregions[0];
finalregion.norm();
assert(finalregion.lineroot != -1);
auto finalfunc = linetree.all(finalregion.lineroot);
int ret = INT_MAX;
for (auto func : finalfunc) ret = min(ret, min(func.lcost, func.rcost()));
return ret;
}
void run() {
scanf("%d", &nrect);
scanf("%d", &sx);
REP(i, nrect) scanf("%d%d%d%d", &rect[i].lt, &rect[i].rt, &rect[i].lx, &rect[i].rx), --rect[i].lt, ++rect[i].rt, --rect[i].lx, ++rect[i].rx;
printf("%d\n", solve());
}
void stress() {
int mxrect = 100, mxdim = 100;
REP(rep, 10000) {
nrect = rnd() % mxrect + 1;
int tdim = rnd() % mxdim + 1;
int xdim = rnd() % mxdim + 1;
sx = rnd() % (xdim + 1);
REP(i, nrect) {
rect[i].lt = rnd() % tdim; rect[i].rt = rnd() % tdim; if (rect[i].lt > rect[i].rt) swap(rect[i].lt, rect[i].rt); rect[i].rt += 2;
rect[i].lx = rnd() % xdim; rect[i].rx = rnd() % xdim; if (rect[i].lx > rect[i].rx) swap(rect[i].lx, rect[i].rx); rect[i].rx += 2;
}
//printf("%d\n%d\n", nrect, sx); REP(i, nrect) printf("%d %d %d %d\n", rect[i].lt + 1, rect[i].rt - 1, rect[i].lx + 1, rect[i].rx - 1);
solve();
printf(".");
}
}
int main() {
run();
//stress();
return 0;
}
| 3,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 10;
int n, m, tot;
int tree[22 * maxn][2];
long long val[22 * maxn];
bool vis[maxn];
void insert(long long x) {
int root = 0;
for (int i = 32; i >= 0; i--) {
int c = (x >> i) & 1;
if (!tree[root][c]) tree[root][c] = tot++;
root = tree[root][c];
}
val[root] = x;
}
long long solve(long long x) {
int root = 0;
for (int i = 32; i >= 0; i--) {
int c = (x >> i) & 1;
if (tree[root][c])
root = tree[root][c];
else
root = tree[root][c ^ 1];
}
return val[root] ^ x;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
tot = 1;
memset(tree, 0, sizeof(tree));
memset(vis, 0, sizeof(vis));
long long tmp;
for (int i = 1; i <= n; i++) scanf("%I64d", &tmp), vis[tmp] = 1;
for (int i = 0; i <= 6e5; i++)
if (!vis[i]) insert((long long)i);
tmp = 0;
long long q = 0;
while (m--) {
scanf("%I64d", &q);
tmp ^= q;
printf("%I64d\n", solve(tmp));
}
}
return 0;
}
| 2,000 | CPP |
if __name__ == "__main__":
user_input = input()
numberOfQ = int(user_input)
values = user_input.split(" ")
res = []
for i in range(0, numberOfQ):
team_input = input()
line = team_input.split(" ")
values = [int(x) for x in line]
res.append(values)
for item in res:
print(2 * item[1]) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
void solve() {
long long n, m, a, b;
cin >> n >> m >> a >> b;
char ar[n][m];
long long countk = 0, countf = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> ar[i][j];
if (ar[i][j] == '.')
countk++;
else
countf++;
}
}
if (m == 1) {
cout << countk * a << '\n';
return;
}
if (2 * a < b) {
cout << countk * a << '\n';
return;
} else {
long long ans = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (ar[i][j] == '.') {
long long count = 0;
while (j < m && ar[i][j] == '.') {
count++;
j++;
}
long long tn = count / 2;
long long rem = count % 2;
ans += tn * b;
ans += rem * a;
}
}
}
cout << ans << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long tests = 1;
cin >> tests;
while (tests--) {
solve();
}
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x1, y1, x2, y2, n, a, b, c, temp1, temp2;
cin >> x1 >> y1;
cin >> x2 >> y2;
cin >> n;
int ans = 0;
for (int i = 0; i < n; ++i) {
cin >> a >> b >> c;
temp1 = a * x1 + b * y1 + c;
temp1 /= abs(temp1);
temp2 = a * x2 + b * y2 + c;
temp2 /= abs(temp2);
if (temp1 * temp2 < 0) ans++;
}
cout << ans << endl;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;
bitset<200000> bs[9][9];
int allowed[9][9][9];
ll n, m, k;
ll solve(int pos, int val, array<int, 9> still) {
ll sum = 0;
for (int i = (pos + 1); i < (k); ++i) {
still[i] &= allowed[pos][val][i];
if (still[i] == 0) return 0;
}
if (pos == k - 2) {
return __builtin_popcount(still[k - 1]);
}
int del = 0;
for (int mask = still[pos + 1]; mask; mask &= ~del) {
del = mask & (-mask);
sum += solve(pos + 1, __builtin_ctz(del), still);
}
return sum;
}
int main(int argc, char* argv[]) {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cin >> n >> m >> k;
array<int, 9> still = {};
for (int i = (0); i < (k); ++i) still[i] = (1u << (i + 1)) - 1;
vector<vector<pii>> g(n);
for (int i = (0); i < (m); ++i) {
int u, v, w;
cin >> u >> v >> w;
u--, v--;
g[u].push_back({w, v});
}
for (auto& a : g) sort((a).begin(), (a).end());
for (int u = (0); u < (n); ++u) {
for (int i = (0); i < (g[u].size()); ++i) {
if (bs[g[u].size() - 1][i][g[u][i].second]) {
still[g[u].size() - 1] &= ~(1u << i);
}
bs[g[u].size() - 1][i][g[u][i].second] = true;
}
}
for (int d1 = (0); d1 < (k); ++d1)
for (int v1 = (0); v1 < (d1 + 1); ++v1)
for (int d2 = (d1 + 1); d2 < (k); ++d2) {
allowed[d1][v1][d2] = (1u << (d2 + 1)) - 1;
for (int v2 = (0); v2 < (d2 + 1); ++v2) {
if ((bs[d1][v1] & bs[d2][v2]).any()) {
allowed[d1][v1][d2] &= ~(1u << v2);
}
}
}
if (k == 1)
cout << still[0] << '\n';
else
cout << (still[0] ? solve(0, 0, still) : 0ll) << '\n';
cout.flush();
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n, a[N], f[N][N], ans, w[N][N];
int main() {
scanf("%d", &n);
memset(f, 0x3f, sizeof(f));
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
f[i][i] = 1;
w[i][i] = a[i];
}
for (int i = 2; i <= n; i++) {
for (int l = 1; l + i - 1 <= n; l++) {
int r = l + i - 1;
for (int mid = l; mid <= r; mid++) {
f[l][r] = min(f[l][r], f[l][mid] + f[mid + 1][r]);
if (f[l][mid] == f[mid + 1][r] && f[l][mid] == 1 &&
w[l][mid] == w[mid + 1][r]) {
f[l][r] = 1;
w[l][r] = w[l][mid] + 1;
}
}
}
}
printf("%d", f[1][n]);
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int pot(int n) {
if (n == (n & -n)) return n;
return (n - (n & -n));
}
int main() {
int n, b, p;
cin >> n >> b >> p;
int ans1 = 0, ans2 = p * n;
while (n != 1) {
int d = pot(n);
int e = n - d;
n -= (d / 2);
ans1 += (d * b + (d / 2));
}
cout << ans1 << " " << ans2;
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool sieve[1000001];
void init() {
long long i, j;
sieve[0] = true;
sieve[1] = true;
for (i = 2; i < 1000001; i++) {
if (!sieve[i]) {
for (j = 2 * i; j < 1000001; j += i) sieve[j] = true;
}
}
}
long long power(long x, long n) {
if (n == 0) return 1;
if (n == 1) return x;
long n2 = n / 2;
long long po = power(x, n2);
if (n % 2) return po * po * x;
return po * po;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
a %= b;
return gcd(b, a);
}
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
int n, m;
vector<string> v;
int G[1005][1005];
bool vis[1005][1005];
int dfs(int x, int y, int c) {
if (vis[x][y] || v[x][y] == '*') return 0;
int ret = 1;
vis[x][y] = true;
G[x][y] = c;
if (x + 1 < n) {
ret += dfs(x + 1, y, c);
}
if (y + 1 < m) {
ret += dfs(x, y + 1, c);
}
if (y - 1 >= 0) {
ret += dfs(x, y - 1, c);
}
if (x - 1 >= 0) {
ret += dfs(x - 1, y, c);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
int i, j, c = 1;
cin >> n >> m;
v.resize(n);
for (i = 0; i < n; i++) cin >> v[i];
map<int, int> M;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (v[i][j] == '.' && !vis[i][j]) {
M[c] = dfs(i, j, c);
c++;
}
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (v[i][j] == '.')
cout << '.';
else {
set<int> s;
if (i + 1 < n) s.insert(G[i + 1][j]);
if (i - 1 >= 0) s.insert(G[i - 1][j]);
if (j + 1 < m) s.insert(G[i][j + 1]);
if (j - 1 >= 0) s.insert(G[i][j - 1]);
int ans = 1;
for (auto it : s) {
ans += M[it];
}
cout << ans % 10;
}
}
cout << "\n";
}
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAXN = 1000005;
int dp[MAXN][4][4];
int has[300];
char s[MAXN];
int ans;
int add(int x, int y) {
x += y;
if (x >= MOD) x -= MOD;
return x;
}
int main() {
scanf("%s", s);
int L = strlen(s);
has['0'] = 0;
has['1'] = 1;
has['2'] = 2;
has['*'] = 3;
if (L < 2) {
if (s[0] == '1' || s[0] == '2')
printf("0\n");
else if (s[0] == '?')
printf("2\n");
else
printf("1\n");
return 0;
}
if (s[0] != '?' && s[1] != '?') {
if (s[0] == '0' && s[1] == '0' || s[0] == '0' && s[1] == '1' ||
s[0] == '1' && s[1] == '*' || s[0] == '*' && s[1] == '*' ||
s[0] == '*' && s[1] == '1' || s[0] == '*' && s[1] == '2')
dp[2][has[s[0]]][has[s[1]]] = 1;
} else {
if (s[0] == '?' && s[1] == '?') {
dp[2][has['0']][has['0']] = 1;
dp[2][has['0']][has['1']] = 1;
dp[2][has['1']][has['*']] = 1;
dp[2][has['*']][has['*']] = 1;
dp[2][has['*']][has['1']] = 1;
dp[2][has['*']][has['2']] = 1;
} else if (s[0] == '?') {
if (s[1] == '0')
dp[2][has['0']][has['0']] = 1;
else if (s[1] == '1')
dp[2][has['0']][has['1']] = dp[2][has['*']][has['1']] = 1;
else if (s[1] == '2')
dp[2][has['*']][has['2']] = 1;
else
dp[2][has['1']][has['*']] = dp[2][has['*']][has['*']] = 1;
} else {
if (s[0] == '0')
dp[2][has['0']][has['0']] = dp[2][has['0']][has['1']] = 1;
else if (s[0] == '1')
dp[2][has['1']][has['*']] = 1;
else if (s[0] == '*')
dp[2][has['*']][has['2']] = dp[2][has['*']][has['*']] =
dp[2][has['*']][has['1']] = 1;
}
}
for (int i = 3; i <= L; i++) {
if (s[i - 1] == '?' || s[i - 1] == '*') {
dp[i][1][3] = add(dp[i][1][3], dp[i - 1][0][1]);
dp[i][1][3] = add(dp[i][1][3], dp[i - 1][1][1]);
dp[i][2][3] = add(dp[i][2][3], dp[i - 1][3][2]);
dp[i][3][3] = add(dp[i][3][3], dp[i - 1][3][3]);
dp[i][3][3] = add(dp[i][3][3], dp[i - 1][2][3]);
dp[i][3][3] = add(dp[i][3][3], dp[i - 1][1][3]);
}
if (s[i - 1] == '?' || s[i - 1] == '1') {
dp[i][3][1] = add(dp[i][3][1], dp[i - 1][3][3]);
dp[i][3][1] = add(dp[i][3][1], dp[i - 1][2][3]);
dp[i][3][1] = add(dp[i][3][1], dp[i - 1][1][3]);
dp[i][1][1] = add(dp[i][1][1], dp[i - 1][3][1]);
dp[i][0][1] = add(dp[i][0][1], dp[i - 1][0][0]);
dp[i][0][1] = add(dp[i][0][1], dp[i - 1][1][0]);
}
if (s[i - 1] == '?' || s[i - 1] == '0') {
dp[i][0][0] = add(dp[i][0][0], dp[i - 1][0][0]);
dp[i][0][0] = add(dp[i][0][0], dp[i - 1][1][0]);
dp[i][1][0] = add(dp[i][1][0], dp[i - 1][3][1]);
}
if (s[i - 1] == '?' || s[i - 1] == '2') {
dp[i][3][2] = add(dp[i][3][2], dp[i - 1][1][3]);
dp[i][3][2] = add(dp[i][3][2], dp[i - 1][2][3]);
dp[i][3][2] = add(dp[i][3][2], dp[i - 1][3][3]);
}
}
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
if (j != 2 && (j != 1 || j == 1 && i == 3)) ans = add(ans, dp[L][i][j]);
printf("%d\n", ans);
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
const int INF = 2000000005;
const long long BIG_INF = 2000000000000000005;
const int mod = 1000000007;
const int P = 31;
const long double PI = 3.141592653589793238462643;
const double eps = 1e-9;
using namespace std;
vector<pair<int, int> > dir = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
bool valid(int x, int y, int n, int m) {
return x >= 0 && y >= 0 && x < n && y < m;
}
mt19937 rng(1999999973);
const int N = 2050;
string s[N];
int column[N][N], row[N][N], n, m;
vector<int> tc[N][2], tr[N][2];
void init() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < 2; j++) {
tc[i][j].resize(N, 0);
tr[i][j].resize(N, 0);
}
}
}
inline void inc(int index, int delta, vector<int> &t) {
for (; index < N; index |= (index + 1)) {
t[index] += delta;
if (t[index] >= mod) t[index] -= mod;
if (t[index] < 0) t[index] += mod;
}
}
inline int sum(int r, vector<int> &t) {
int res = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) {
res += t[r];
if (res >= mod) res -= mod;
if (res < 0) res += mod;
}
return res;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
init();
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
if (s[n - 1][m - 1] == 'R') {
cout << 0;
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = m - 1; j >= 0; j--) {
row[i][j] = row[i][j + 1];
if (s[i][j] == 'R') row[i][j]++;
}
}
for (int j = 0; j < m; j++) {
for (int i = n - 1; i >= 0; i--) {
column[j][i] = column[j][i + 1];
if (s[i][j] == 'R') column[j][i]++;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int dir = 0; dir < 2; dir++) {
int val = sum(j, tr[i][dir]) + sum(i, tc[j][dir]);
if (val >= mod) val -= mod;
if (i == 0 && j == 0 && dir == 0) val++;
if (i == n - 1 && j == m - 1) {
ans = (ans + val) % mod;
continue;
}
int colRight = row[i][j + 1], colDown = column[j][i + 1];
if (s[i][j] == 'R' && dir == 0) colDown++;
if (s[i][j] == 'R' && dir == 1) colRight++;
if (colRight >= m - j) continue;
if (colDown >= n - i) continue;
if (i == n - 1) {
if (colRight == 0) ans = (ans + val) % mod;
continue;
}
if (j == m - 1) {
if (colDown == 0) ans = (ans + val) % mod;
continue;
}
inc(j + 1, val, tr[i + 1][0]);
inc(m - colRight, -val, tr[i + 1][0]);
inc(i + 1, val, tc[j + 1][1]);
inc(n - colDown, -val, tc[j + 1][1]);
}
}
}
cout << ans;
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<int, int> in;
vector<int> G[200010];
int n, a, b, ar[200010], ans[200010];
int dis[200010], Q[200010], parent[200010], L[200010], R[200010];
bool dfs(int i) {
int len = G[i].size();
for (int j = 0; j < len; j++) {
int x = G[i][j];
if (L[x] == -1 || (parent[L[x]] == i)) {
if (L[x] == -1 || dfs(L[x])) {
L[x] = i;
R[i] = x;
return (true);
}
}
}
return false;
}
bool bfs() {
int x, f = 0, l = 0;
memset(dis, -1, sizeof(dis));
for (int i = 1; i <= n; i++) {
if (R[i] == -1) {
Q[l++] = i;
dis[i] = 0;
}
}
while (f < l) {
int i = Q[f++];
int len = G[i].size();
for (int j = 0; j < len; j++) {
x = G[i][j];
if (L[x] == -1)
return true;
else if (dis[L[x]] == -1) {
parent[L[x]] = i;
dis[L[x]] = dis[i] + 1;
Q[l++] = L[x];
}
}
}
return false;
}
int hopcroft_karp() {
int counter = 0;
memset(L, -1, sizeof(L));
memset(R, -1, sizeof(R));
while (bfs()) {
for (int i = 1; i <= n; i++) {
if (R[i] == -1 && dfs(i)) counter++;
}
}
return counter;
}
int main() {
scanf("%d %d %d", &n, &a, &b);
for (int i = 1; i <= n; i++) scanf("%d", &ar[i]), in[ar[i]] = i;
for (int i = 1; i <= n; i++) {
int x = ar[i];
int y = a - ar[i];
if (in[y]) G[i].push_back(in[y]);
y = b - ar[i];
if (in[y]) G[i].push_back(in[y]);
}
int x = hopcroft_karp();
if (x != n) {
puts("NO");
return 0;
}
puts("YES");
for (int i = 1; i <= n; i++) {
x = R[i];
if (ar[x] + ar[i] == b) ans[i] = 1;
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
puts("");
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
struct P {
int x1, y1, x2, y2, z, id;
void in() { scanf("%d%d%d%d%d", &x1, &x2, &y1, &y2, &z); }
} dt[N];
struct kd {
int l, r, x1, x2, y1, y2, key, fa;
} tree[N];
bool cmp(P x, P y) { return x.z < y.z; }
int x[N], y[N], b[N];
bool us[N];
int min(int x, int y) { return x < y ? x : y; }
int max(int x, int y) { return x > y ? x : y; }
bool cmpx(int a, int b) { return x[a] < x[b]; }
bool cmpy(int a, int b) { return y[a] < y[b]; }
void up(int t) {
tree[t].x1 = tree[t].x2 = x[t];
tree[t].y1 = tree[t].y2 = y[t];
if (!us[t])
tree[t].key = t;
else
tree[t].key = N;
if (tree[t].l) {
tree[t].key = min(tree[t].key, tree[tree[t].l].key);
tree[t].x1 = min(tree[t].x1, tree[tree[t].l].x1);
tree[t].x2 = max(tree[t].x2, tree[tree[t].l].x2);
tree[t].y1 = min(tree[t].y1, tree[tree[t].l].y1);
tree[t].y2 = max(tree[t].y2, tree[tree[t].l].y2);
}
if (tree[t].r) {
tree[t].key = min(tree[t].key, tree[tree[t].r].key);
tree[t].x1 = min(tree[t].x1, tree[tree[t].r].x1);
tree[t].x2 = max(tree[t].x2, tree[tree[t].r].x2);
tree[t].y1 = min(tree[t].y1, tree[tree[t].r].y1);
tree[t].y2 = max(tree[t].y2, tree[tree[t].r].y2);
}
}
int build(int L, int R, int f, int c) {
if (L > R) return 0;
int m = (L + R) / 2;
nth_element(b + L, b + m, b + R + 1, c ? cmpx : cmpy);
int nd = b[m];
tree[nd].fa = f;
tree[nd].l = build(L, m - 1, nd, 1 - c);
tree[nd].r = build(m + 1, R, nd, 1 - c);
tree[nd].key = nd;
up(nd);
return nd;
}
int ret, rt[N];
void work(int x1, int x2, int y1, int y2, int t) {
if (!t || x1 > tree[t].x2 || x2 < tree[t].x1 || y1 > tree[t].y2 ||
y2 < tree[t].y1 || ret <= tree[t].key)
return;
if (x1 <= tree[t].x1 && x2 >= tree[t].x2 && y1 <= tree[t].y1 &&
y2 >= tree[t].y2) {
ret = tree[t].key;
return;
}
if (!us[t] && x1 <= x[t] && x2 >= x[t] && y1 <= y[t] && y2 >= y[t]) {
ret = min(ret, t);
}
work(x1, x2, y1, y2, tree[t].l);
work(x1, x2, y1, y2, tree[t].r);
}
int main() {
int n, m, i;
scanf("%d", &m);
for (i = 0; i < m; i++) {
dt[i].in();
dt[i].id = i;
}
sort(dt, dt + m, cmp);
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &x[i], &y[i]);
b[i] = i;
}
int root = build(1, n, 0, 0);
for (i = 0; i < m; i++) {
ret = N;
work(dt[i].x1, dt[i].x2, dt[i].y1, dt[i].y2, root);
if (ret != N) {
rt[ret] = dt[i].id + 1;
int u = ret;
tree[u].key = N;
us[u] = true;
while (u) {
up(u);
u = tree[u].fa;
}
}
}
for (i = 1; i <= n; i++) printf("%d\n", rt[i]);
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> m >> k;
cout << (m - 1) * 9 + k << "\n";
}
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int u[300005] = {0}, va[300005] = {0}, p[300005] = {0};
int main() {
long long int a1 = 0, b1 = 0, a = 0, q = 0, cnt = 0, sum = 0, v = 0, b = 0,
c = 0, m = 0, i = 0;
char s[10] = {0};
scanf("%I64d %I64d %I64d", &a, &b, &c);
scanf("%I64d", &m);
for (i = 1; i <= m; i++) {
scanf("%I64d %s", &v, s);
if (strcmp(s, "USB") == 0) {
u[a1] = v;
a1++;
} else {
p[b1] = v;
b1++;
}
}
sort(u, u + a1);
sort(p, p + b1);
for (i = 0; i <= min(a1 - 1, a - 1); i++) {
sum += u[i];
cnt++;
}
for (i = 0; i <= min(b1 - 1, b - 1); i++) {
sum += p[i];
cnt++;
}
if (m - cnt > 0) {
for (i = min(a1 - 1, a - 1) + 1; i < a1; i++) {
va[q] = u[i];
q++;
}
for (i = min(b1 - 1, b - 1) + 1; i < b1; i++) {
va[q] = p[i];
q++;
}
sort(va, va + q);
long long int e = m - cnt - 1;
for (i = 0; i <= min(e, c - 1); i++) {
sum += va[i];
cnt++;
}
}
printf("%I64d %I64d\n", cnt, sum);
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string t1, t2;
cin >> t1 >> t2;
int n;
cin >> n;
int cost[26][26], dest[26][26];
for (int i = 0; i < 26; ++i)
for (int j = 0; j < 26; ++j) cost[i][j] = 100000;
for (int i = 0; i < 26; ++i) cost[i][i] = 0;
while (n--) {
char a, b;
int c;
cin >> a >> b >> c;
cost[a - 'a'][b - 'a'] = min(cost[a - 'a'][b - 'a'], c);
}
for (int k = 0; k < 26; ++k)
for (int i = 0; i < 26; ++i)
for (int j = 0; j < 26; ++j)
cost[i][j] = min(cost[i][j], cost[i][k] + cost[k][j]);
for (int i = 0; i < 26; ++i) {
for (int j = 0; j < 26; ++j) {
int c = min(cost[i][j], cost[j][i]);
int d = 100000;
for (int k = 0; k < 26; ++k) {
if (c > cost[i][k] + cost[j][k]) {
d = k;
c = cost[i][k] + cost[j][k];
}
}
dest[i][j] = d;
}
}
if (t1.size() != t2.size()) {
cout << -1 << endl;
return 0;
}
if (t1 == t2) {
cout << 0 << endl;
cout << t1 << endl;
return 0;
}
long long res = 0;
for (int i = 0; i < t1.size(); ++i) {
int p1 = t1[i] - 'a';
int p2 = t2[i] - 'a';
if (p1 == p2) continue;
int c1 = cost[p1][p2];
int c2 = cost[p2][p1];
if (dest[p1][p2] == 100000) {
if (c1 == 100000 && c2 == 100000) break;
if (c1 < c2) {
t1[i] = t2[i];
res += c1;
} else {
t2[i] = t1[i];
res += c2;
}
} else {
t1[i] = t2[i] = char(dest[p1][p2] + 'a');
res += cost[p1][dest[p1][p2]] + cost[p2][dest[p1][p2]];
}
}
if (t1 != t2) {
cout << -1 << endl;
return 0;
}
cout << res << endl;
cout << t1 << endl;
return 0;
}
| 1,800 | CPP |
def main():
k, n, w = [int(v) for v in input().split()]
c = w * (w + 1) // 2
print(max(0,c * k - n))
if __name__ == "__main__":
main() | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int md = 1e9 + 7;
const int maxn = 1e5 + 5;
struct Marix {
long long maze[2][2];
Marix() { memset(maze, 0, sizeof maze); }
void One() {
maze[0][0] = maze[1][1] = 1;
maze[0][1] = maze[1][0] = 0;
}
Marix operator+(const Marix& tmp) const {
Marix ret;
ret.maze[0][0] = (maze[0][0] + tmp.maze[0][0]) % md;
ret.maze[0][1] = (maze[0][1] + tmp.maze[0][1]) % md;
ret.maze[1][0] = (maze[1][0] + tmp.maze[1][0]) % md;
ret.maze[1][1] = (maze[1][1] + tmp.maze[1][1]) % md;
return ret;
}
Marix operator*(const Marix& tmp) const {
Marix ret;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
ret.maze[i][j] += maze[i][k] * tmp.maze[k][j] % md;
ret.maze[i][j] %= md;
}
}
}
return ret;
}
} B;
Marix quick_pow(Marix a, long long k) {
Marix ans;
ans.One();
while (k) {
if (k & 1) ans = ans * a;
a = a * a;
k >>= 1;
}
return ans;
}
struct SegTree {
int l, r;
Marix sum, add;
void Add(const Marix& A) {
sum = A * sum;
add = A * add;
}
} tree[maxn << 2];
void push_up(int rt) {
tree[rt].sum = tree[rt << 1].sum + tree[rt << 1 | 1].sum;
}
void push_down(int rt) {
tree[rt << 1].Add(tree[rt].add);
tree[rt << 1 | 1].Add(tree[rt].add);
tree[rt].add.One();
}
void build(int l, int r, int rt) {
tree[rt].l = l;
tree[rt].r = r;
tree[rt].add.maze[0][0] = 1;
tree[rt].add.maze[0][1] = 0;
tree[rt].add.maze[1][0] = 0;
tree[rt].add.maze[1][1] = 1;
if (l == r) {
int x;
scanf("%d", &x);
tree[rt].sum = quick_pow(B, x);
return;
}
int mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
push_up(rt);
}
void update(int l, int r, int rt, const Marix& A) {
if (l <= tree[rt].l && tree[rt].r <= r) {
tree[rt].Add(A);
return;
}
push_down(rt);
int mid = (tree[rt].l + tree[rt].r) >> 1;
if (l <= mid) update(l, r, rt << 1, A);
if (mid < r) update(l, r, rt << 1 | 1, A);
push_up(rt);
}
Marix ans;
void query(int l, int r, int rt) {
if (l <= tree[rt].l && tree[rt].r <= r) {
ans = ans + tree[rt].sum;
return;
}
push_down(rt);
int mid = (tree[rt].l + tree[rt].r) >> 1;
if (l <= mid) query(l, r, rt << 1);
if (mid < r) query(l, r, rt << 1 | 1);
push_up(rt);
}
int main() {
B.maze[0][0] = B.maze[0][1] = B.maze[1][0] = 1;
int n, m, opt, l, r, x;
scanf("%d%d", &n, &m);
build(1, n, 1);
while (m--) {
scanf("%d", &opt);
if (opt == 1) {
scanf("%d%d%d", &l, &r, &x);
Marix A = quick_pow(B, x);
update(l, r, 1, A);
} else {
scanf("%d%d", &l, &r);
ans.maze[0][0] = ans.maze[0][1] = ans.maze[1][0] = ans.maze[1][1] = 0;
query(l, r, 1);
cout << ans.maze[0][1] << '\n';
}
}
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000");
using namespace std;
long double smallscore[1008], bigscore[1008], smalltime[1008], bigtime[1008];
double probfail[1008];
pair<long double, pair<long double, long double> > dp[1008][1562];
int id[1008];
bool cmp(int x, int y) {
int i = x, j = y;
return probfail[j] * bigtime[j] + probfail[i] * probfail[j] * bigtime[i] >
probfail[i] * bigtime[i] + probfail[j] * probfail[i] * bigtime[j];
}
pair<long double, pair<long double, long double> > maxa(
pair<long double, pair<long double, long double> > a,
pair<long double, pair<long double, long double> > b) {
if (a.first != b.first) return max(a, b);
if (a.second.first + a.second.second < b.second.first + b.second.second)
return a;
return b;
}
int main() {
int n, t;
cin >> n >> t;
for (int i = 1; i <= n; i++) {
cin >> smallscore[i] >> bigscore[i] >> smalltime[i] >> bigtime[i] >>
probfail[i];
id[i] = i;
}
dp[1][t] = make_pair(0, make_pair(0, 0));
sort(id + 1, id + n + 1, cmp);
for (int ii = 1; ii <= 1 + n; ii++) {
int i = id[ii];
for (int j = t; j >= 0; j--) {
dp[ii][j] = maxa(dp[ii][j], dp[ii][j + 1]);
dp[ii + 1][j] = maxa(dp[ii][j], dp[ii + 1][j]);
if (ii == n + 1) continue;
pair<long double, pair<long double, long double> > tem = dp[ii][j];
tem = make_pair(dp[ii][j].first + smallscore[i],
make_pair(dp[ii][j].second.first + smalltime[i],
dp[ii][j].second.second + smalltime[i]));
if (j >= smalltime[i])
dp[ii + 1][j - (int)smalltime[i]] =
maxa(dp[ii + 1][j - (int)smalltime[i]], tem);
if (j >= smalltime[i] + bigtime[i]) {
pair<long double, long double> jk, kl = dp[ii][j].second;
jk = make_pair(
kl.first + smalltime[i] + bigtime[i],
(kl.second + smalltime[i]) * (probfail[i]) +
(kl.first + smalltime[i] + bigtime[i]) * (1 - probfail[i]));
tem = make_pair(
dp[ii][j].first + smallscore[i] + bigscore[i] * (1 - probfail[i]),
jk);
dp[ii + 1][j - (int)smalltime[i] - (int)bigtime[i]] =
maxa(dp[ii + 1][j - (int)smalltime[i] - (int)bigtime[i]], tem);
}
}
}
cout << setprecision(11);
cout.setf(ios::fixed, ios::floatfield);
n++;
cout << dp[n][0].first << " " << dp[n][0].second.second;
return 0;
}
| 2,800 | CPP |
def fun(A,B):
j = 0
x = 0
while (A or B):
if ((A & 1) and (B & 1)):
x += (1 << j)
A >>= 1
B >>= 1
j += 1
return x
for _ in range(int(input())):
a,b=list(map(int,input().split()))
x=fun(a,b)
print((a^x)+(b^x)) | 800 | PYTHON3 |
a,b,c = map(int, input().split())
data = list(map(int, input().split()))
datb = list(map(int, input().split()))
res = []
for i in range(1, a+1):
if i in data:
res.append("1")
else:
res.append("2")
print(" ".join(res)) | 800 | PYTHON3 |
t = int(input())
for r in range(t):
n = int(input())
x = [];p=[]
q = "";s=""
q = str(n)
s=q[::-1]
for i in range(len(s)):
x.append(int(s[i]) * 10 ** (i))
for i in x:
if i>0:
p.append(i)
print(len(p))
for i in p:
print(i, end=" ")
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400019, K = 26, mod = 1e9 + 7, base = 911;
string s;
int ls1[N], fen1[N], ls2[N], fen2[N];
int n, d, inv, po[N], poi[N];
void upd(int p, int val, int *f, int *l) {
val = (val + mod - l[p]) % mod;
l[p] += val;
l[p] %= mod;
for (p++; p < N; p += p & -p) f[p] += val, f[p] %= mod;
return;
}
int get(int p, int *f) {
int ret = 0;
for (; p > 0; p -= p & -p) ret = (ret + f[p]) % mod;
return ret;
}
int inc(int p) {
int flg = 0;
for (int i = p - 1; i >= 0; i--) {
if (s[i] != 'z') {
s[i]++;
long long vl1 = 1LL * s[i] * po[n - i - 1];
vl1 %= mod;
upd(i, vl1, fen1, ls1);
long long vl2 = 1LL * s[i] * po[i];
vl2 %= mod;
upd(i, vl2, fen2, ls2);
return i + 1;
break;
} else {
s[i] = 'a';
long long vl1 = 1LL * s[i] * po[n - i - 1];
vl1 %= mod;
upd(i, vl1, fen1, ls1);
long long vl2 = 1ll * s[i] * po[i];
vl2 %= mod;
upd(i, vl2, fen2, ls2);
}
}
if (!flg) {
cout << "Impossible\n";
exit(0);
}
return flg;
}
int le_ri(int l, int r) {
long long ret = get(r, fen1) + mod - get(l, fen1);
ret %= mod;
ret *= poi[n - r];
ret %= mod;
return ret;
}
int ri_le(int l, int r) {
long long ret = get(r, fen2) + mod - get(l, fen2);
ret %= mod;
ret *= poi[l];
ret %= mod;
return ret;
}
int power(int a, int b) {
if (b == 0) return 1;
long long ret = power(a, b / 2);
ret *= ret;
ret %= mod;
if (b & 1) ret *= a, ret %= mod;
return ret;
}
bool check(int len) {
if (len >= d)
if (le_ri(len - d, len) == ri_le(len - d, len)) return false;
if (len >= d + 1)
if (le_ri(len - d - 1, len) == ri_le(len - d - 1, len)) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> d;
cin >> s;
n = s.size();
inv = power(base, mod - 2);
po[0] = poi[0] = 1;
for (int i = 1; i <= n; i++)
po[i] = (1LL * po[i - 1] * base) % mod,
poi[i] = (1LL * poi[i - 1] * inv) % mod;
for (int i = 0; i < n; i++) {
long long vl1 = 1LL * s[i] * po[n - i - 1];
vl1 %= mod;
upd(i, vl1, fen1, ls1);
long long vl2 = 1LL * s[i] * po[i];
vl2 %= mod;
upd(i, vl2, fen2, ls2);
}
inc(n);
int id = -1;
for (int i = 1; i <= n; i++) {
int len = i;
if (!check(i)) {
while (true) {
int c = inc(len);
bool flg = true;
int b = len;
for (int k = len; k >= c; k--)
if (!check(k)) flg = false, b = k;
len = b;
if (flg) break;
}
id = len;
break;
}
}
if (id == -1) return cout << s << endl, 0;
for (int i = id; i < n; i++) {
for (int k = 'a'; k < 'd'; k++) {
s[i] = k;
long long vl1 = 1LL * s[i] * po[n - i - 1];
vl1 %= mod;
upd(i, vl1, fen1, ls1);
long long vl2 = 1LL * s[i] * po[i];
vl2 %= mod;
upd(i, vl2, fen2, ls2);
if (check(i + 1)) break;
}
}
cout << s << endl;
}
| 2,800 | CPP |
def func(n):
for i in range(n):
k = int(input())
s = input()
l = []
l2 = []
counter = 0
for i in s:
if i=='(':
l.append(i)
else:
if l:
if l.pop()!='(':
l2.append(i)
counter += 1
else:
l2.append(i)
counter += 1
print(counter)
n = int(input())
func(n) | 1,000 | PYTHON3 |
for _ in range(int(input())):
n,m=[int(i) for i in input().split()]
a=[int(i) for i in input().split()]
p=[int(i) for i in input().split()]
for i in range(m):
for j in p:
if a[j-1]>a[j]:
a[j],a[j-1]=a[j-1],a[j]
if a==sorted(a):
print("YES")
else:
print("NO") | 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> prefix_function(string& s) {
int n = (int)s.length();
vector<int> pi(n);
for (int i = 1; i < n; ++i) {
int j = pi[i - 1];
while (j > 0 && s[i] != s[j]) j = pi[j - 1];
if (s[i] == s[j]) ++j;
pi[i] = j;
}
return pi;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, a, b, c;
cin >> n >> a >> b >> c;
long long r = n % 4;
if (r == 0) {
cout << 0 << endl;
return 0;
}
if (r == 1) {
long long res = c;
res = min(res, 3 * a);
res = min(res, a + b);
cout << res << endl;
return 0;
}
if (r == 2) {
long long res = b;
res = min(res, 2 * a);
res = min(res, 2 * c);
cout << res << endl;
}
if (r == 3) {
long long res = a;
res = min(res, b + c);
res = min(res, 3 * c);
cout << res << endl;
}
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct IO {
IO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
} _;
long long n, m, len, k, t, a, b;
long long arr[200010];
vector<long long> Adj[200010];
bool vis[200010];
map<long long, set<long long>> cnt;
stack<long long> finish;
long long modpow(long long x, long long y, long long m) {
long long res = 1;
x = x % m;
while (y) {
if (y & 1LL) res = (res * x) % m;
y >>= 1LL;
x = (x * x) % m;
}
return res;
}
void dfs(long long u) {
vis[u] = true;
if (!vis[arr[u]]) dfs(arr[u]);
finish.push(u);
}
void dfs2(long long u, long long sccno) {
vis[u] = true;
cnt[sccno].insert(u);
for (auto v : Adj[u])
if (!vis[v]) dfs2(v, sccno);
}
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> arr[i], Adj[arr[i]].push_back(i);
long long ans = 1;
for (long long i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
long long scc = 0;
memset(vis, false, sizeof(vis));
while (!finish.empty()) {
long long u = finish.top();
finish.pop();
if (!vis[u]) dfs2(u, scc++);
}
for (long long i = 0; i < scc; i++) {
if (((long long)cnt[i].size()) == 1)
ans <<= 1LL, (((ans %= 1000000007LL) += 1000000007LL) %= 1000000007LL);
else {
long long mult = modpow(2LL, ((long long)cnt[i].size()), 1000000007LL);
(((mult %= 1000000007LL) += 1000000007LL) %= 1000000007LL);
mult -= 2LL;
(((mult %= 1000000007LL) += 1000000007LL) %= 1000000007LL);
ans *= mult;
(((ans %= 1000000007LL) += 1000000007LL) %= 1000000007LL);
}
}
cout << ans << "\n";
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool is_power(int n) {
if (n == 1) return true;
int rem = n % 2;
if (!rem)
return is_power(n / 2);
else
return false;
}
struct player {
double prob;
double score;
};
void printMap(map<int, player> map) {
cout.precision(10);
for (auto& i : map)
cout << i.first << " " << i.second.prob << "," << i.second.score << endl;
}
map<int, player> update(map<int, player> map1, map<int, player> map2,
int reward, vector<vector<double>>& probs) {
map<int, player> res;
for (auto& i : map1) {
player p;
player player1 = i.second;
double max = -1.0;
double score;
double prob = 0;
for (auto& j : map2)
prob += player1.prob * j.second.prob * probs[i.first - 1][j.first - 1];
for (auto& j : map2) {
player player2 = j.second;
score = player1.score + player2.score + prob * reward;
if (score > max) {
max = score;
}
p.score = max;
p.prob = prob;
}
res[i.first] = p;
}
return res;
}
map<int, player> compute_block(int start, int size,
vector<vector<double>>& probs) {
assert(is_power(size));
if (size == 2) {
player player1, player2;
player1.prob = probs[start - 1][start];
player2.prob = probs[start][start - 1];
player1.score = player1.prob;
player2.score = player2.prob;
map<int, player> res;
res[start] = player1;
res[start + 1] = player2;
return res;
}
int middle = start + size / 2 - 1;
map<int, player> map1 = compute_block(start, size / 2, probs);
map<int, player> map2 = compute_block(middle + 1, size / 2, probs);
map<int, player> res1 = update(map1, map2, size / 2, probs);
map<int, player> res2 = update(map2, map1, size / 2, probs);
res1.insert(res2.begin(), res2.end());
return res1;
}
int main() {
int m;
cin >> m;
int n = 1 << m;
vector<vector<double>> probs;
for (int i = 0; i < n; i++) {
probs.push_back(vector<double>());
for (int j = 0; j < n; j++) {
int temp;
cin >> temp;
probs[i].push_back((double)temp / 100);
}
}
map<int, player> res = compute_block(1, n, probs);
double max = -1.0;
cout.precision(10);
for (auto& p : res) {
if (p.second.score > max) max = p.second.score;
}
cout << max << endl;
return 0;
}
| 2,100 | CPP |
def main_function():
from sys import stdin
from sys import stdout
input = stdin.readline
print = stdout.write
t = int(input())
for _ in range(t):
n = int(input())
considered_permutation = list(map(int, input().split()))
if n <= 2:
print('Yes\n')
continue
ix_in_permutation = [0] * n
for i in range(n):
ix_in_permutation[considered_permutation[i] - 1] = i
count = [1] * n + [0]
max_count = 1
for i in range(n - 1):
if count[ix_in_permutation[i]] != max_count:
print('No\n')
break
if count[ix_in_permutation[i] + 1] == 0:
max_count = 1
else:
max_count += 1
count[ix_in_permutation[i] + 1] += count[ix_in_permutation[i]]
count[ix_in_permutation[i]] = 0
else:
print('Yes\n')
if __name__ == '__main__':
main_function() | 1,500 | PYTHON3 |
string = input()
print('YES') if string.find('H') != -1 or string.find('Q') != -1 or string.find('9') != -1 else print('NO')
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct aaa {
aaa() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} aaa;
bool ok(char s1, char s2, char s3) {
return (s1 == s2 && s2 == s3) || (s1 != s2 && s2 != s3 && s3 != s1);
}
int main() {
int n, k;
int ans = 0;
cin >> n >> k;
vector<string> s(n);
map<string, int> u;
for (int i = 0; i < n; i++) {
cin >> s[i];
u[s[i]] = i + 1;
}
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
string si;
for (long long l = 0; l < k; l++) {
if (s[i][l] == s[j][l])
si += s[i][l];
else
si += (char)(((int)'S' + 'E' + 'T') - s[i][l] - s[j][l]);
}
if (u[si] > j + 1) ans++;
}
}
cout << ans << endl;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
const int Q = 1e5 + 5;
int row[N];
int shelfs[N][N];
bool is_inverted[N];
int n, m, q;
vector<int> four[Q];
int qt[Q], ii[Q], jj[Q];
int ans[Q];
void solve(int i = 0, int books = 0) {
if (int(four[i].size())) {
for (int r = 0; r < int(int(four[i].size())); r++) {
ans[four[i][r] - 1] = books;
solve(four[i][r], books);
}
}
if (qt[i] == 1) {
if (!shelfs[ii[i]][jj[i]] && !is_inverted[ii[i]]) {
shelfs[ii[i]][jj[i]] = 1;
row[ii[i]]++;
books++;
ans[i] = books;
solve(i + 1, books);
shelfs[ii[i]][jj[i]] = 0;
row[ii[i]]--;
books--;
} else if (shelfs[ii[i]][jj[i]] && is_inverted[ii[i]]) {
shelfs[ii[i]][jj[i]] = 0;
row[ii[i]]++;
books++;
ans[i] = books;
solve(i + 1, books);
shelfs[ii[i]][jj[i]] = 1;
row[ii[i]]--;
books--;
} else {
ans[i] = books;
solve(i + 1, books);
}
} else if (qt[i] == 2) {
if (shelfs[ii[i]][jj[i]] && !is_inverted[ii[i]]) {
shelfs[ii[i]][jj[i]] = 0;
row[ii[i]]--;
books--;
ans[i] = books;
solve(i + 1, books);
shelfs[ii[i]][jj[i]] = 1;
row[ii[i]]++;
books++;
} else if (!shelfs[ii[i]][jj[i]] && is_inverted[ii[i]]) {
shelfs[ii[i]][jj[i]] = 1;
row[ii[i]]--;
books--;
ans[i] = books;
solve(i + 1, books);
shelfs[ii[i]][jj[i]] = 0;
row[ii[i]]++;
books++;
} else {
ans[i] = books;
solve(i + 1, books);
}
} else if (qt[i] == 3) {
is_inverted[ii[i]] = !is_inverted[ii[i]];
books -= row[ii[i]];
books += m - row[ii[i]];
row[ii[i]] = m - row[ii[i]];
ans[i] = books;
solve(i + 1, books);
is_inverted[ii[i]] = !is_inverted[ii[i]];
row[ii[i]] = m - row[ii[i]];
books -= m - row[ii[i]];
books += row[ii[i]];
} else {
return;
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < int(q); i++) {
scanf("%d", &qt[i]);
if (qt[i] == 1)
scanf("%d%d", &ii[i], &jj[i]);
else if (qt[i] == 2)
scanf("%d%d", &ii[i], &jj[i]);
else if (qt[i] == 3)
scanf("%d", &ii[i]);
else {
scanf("%d", &ii[i]);
four[ii[i]].push_back(i + 1);
}
}
solve();
for (int i = 0; i < int(q); i++) printf("%d\n", ans[i]);
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, c = 0, m = 0, b = 0, ost = 0, x = 0, y = 0, k = 0;
cin >> n;
if (n == 0) {
cout << 0 << ' ' << 0;
return 0;
}
k = sqrt(n / 3.0);
while (k * (k + 1) * 3 >= n) k--;
n -= 3 * (k + 1) * k;
k++;
if (n % k == 0) {
m = n / k;
b = k;
} else {
m = n / k + 1;
b = n % k;
}
switch (m) {
case 1:
x = 2 * k - b;
y = 2 * b;
break;
case 2:
x = k - 2 * b;
y = 2 * k;
break;
case 3:
x = -k - b;
y = 2 * (k - b);
break;
case 4:
x = -(2 * k - b);
y = -2 * b;
break;
case 5:
x = -(k - 2 * b);
y = -2 * k;
break;
case 6:
x = k + b;
y = 2 * (b - k);
break;
}
cout << x << ' ' << y;
return 0;
}
| 2,100 | CPP |
t = int(input())
v1,v2=0,0
for i in range(t):
n=int(input())
flag="NO"
a=list(map(int,input().split()))
for j in range(len(a)-1):
if abs(a[j+1]-a[j])>=2:
flag="YES"
v1=j
v2=j+1
break
if flag=="NO":
print("NO")
else:
print("YES")
print(v1+1,v2+1,end=" ")
print("") | 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(n - a, b + 1);
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-10;
int enc(int x, int y, int dp, int cp) {
int res = 0;
res = x;
res = res * 100 + y;
res = res * 100 + dp;
res = res * 100 + cp;
return res;
}
int main() {
char buf[128][128];
int h, n;
scanf("%d%d", &h, &n);
for (int i = 0; i < h; ++i) scanf("%s", buf[i]);
int w = strlen(buf[0]);
int pix[128][128];
memset(pix, 0, sizeof(pix));
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) pix[i + 1][j + 1] = buf[i][j] - '0';
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
pair<int, int> dd[128][128][4];
for (int y = 1; y <= h; ++y) {
for (int x = 1; x <= w; ++x) {
if (pix[y][x] == 0) continue;
for (int d = 0; d < 4; ++d) {
int tx = x, ty = y;
while (true) {
int nx = tx + dx[d], ny = ty + dy[d];
if (pix[ny][nx] != pix[ty][tx]) break;
tx = nx, ty = ny;
}
dd[y][x][d] = pair<int, int>(tx, ty);
}
}
}
int x, y, dp, cp;
x = y = 1;
dp = 0;
cp = -1;
map<int, int> memo;
memo.insert(pair<int, int>(enc(x, y, dp, cp), 0));
bool skip = false;
for (int move = 1; move <= n; ++move) {
int xe, ye;
pair<int, int> t = dd[y][x][dp];
xe = t.first, ye = t.second;
int nx, ny;
t = dd[ye][xe][(dp + cp + 4) % 4];
nx = t.first, ny = t.second;
int tx, ty;
tx = nx + dx[dp], ty = ny + dy[dp];
if (pix[ty][tx]) {
x = tx, y = ty;
} else {
if (cp == 1) dp = (dp + 1) % 4;
cp *= -1;
}
int en = enc(x, y, dp, cp);
if (!skip) {
if (!memo.count(en))
memo[en] = move;
else {
int around = move - memo[en];
move += around * ((n - move) / around);
skip = true;
}
}
}
printf("%d\n", pix[y][x]);
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int ans = -1e9;
vector<int> v;
int F(int i) {
int t;
cin >> t;
v.push_back(t);
return (i - 1) ? F(i - 1) : 0;
}
int F4(int i, int j, int k) {
v[(j - 1) * n + k - 1] = min(v[(j - 1) * n + k - 1],
v[(j - 1) * n + i - 1] + v[(i - 1) * n + k - 1]);
return (k - 1) ? F4(i, j, k - 1) : 0;
}
int F3(int i, int j) {
F4(i, j, n);
return (j - 1) ? F3(i, j - 1) : 0;
}
int F2(int i) {
F3(i, n);
return (i - 1) ? F2(i - 1) : 0;
}
int F5(int i) {
ans = max(ans, v[i - 1]);
return (i - 1) ? F5(i - 1) : 0;
}
int main() {
cin >> n;
F(n * n);
F2(n);
F5(n * n);
cout << ans;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int x[5], y[5], ans, i;
map<int, int> mp;
int main() {
for (i = 1; i <= 3; i++) {
cin >> x[i] >> y[i];
mp[x[i]] = y[i];
}
sort(x + 1, x + 4);
sort(y + 1, y + 4);
ans = x[3] - x[1] + y[3] - y[1] + 1;
cout << ans << endl;
for (i = x[1]; i < x[2]; i++) {
cout << i << " " << mp[x[1]] << endl;
}
for (i = x[3]; i > x[2]; i--) {
cout << i << " " << mp[x[3]] << endl;
}
for (i = y[1]; i <= y[3]; i++) {
cout << x[2] << " " << i << endl;
}
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int k;
vector<vector<pair<long long, long long>>> adja_list;
vector<int> parent;
vector<long long> size_sub_tree;
long long min_ans, max_ans;
void dfs(int cur = 0, int cant = -1) {
for (auto &[x, w] : adja_list[cur]) {
if (x == cant) continue;
parent[x] = cur;
dfs(x, cur);
size_sub_tree[cur] += size_sub_tree[x];
}
}
void another_dfs(int cur = 0, int cant = -1) {
for (auto &[x, w] : adja_list[cur]) {
if (x == cant) continue;
max_ans += w * min(size_sub_tree[x], 2 * k - size_sub_tree[x]);
min_ans += (size_sub_tree[x] % 2) * w;
another_dfs(x, cur);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
cin >> k;
adja_list.assign(2 * k, vector<pair<long long, long long>>());
parent.assign(2 * k, -1);
size_sub_tree.assign(2 * k, 1);
min_ans = 0;
max_ans = 0;
for (int i = 0; i < 2 * k - 1; i++) {
int inp1, inp2, inp3;
cin >> inp1 >> inp2 >> inp3;
inp1--;
inp2--;
adja_list[inp1].emplace_back(inp2, inp3);
adja_list[inp2].emplace_back(inp1, inp3);
}
dfs();
another_dfs();
cout << min_ans << ' ' << max_ans << '\n';
}
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
map<string, string> mp;
while (q--) {
string str1, str2;
cin >> str1 >> str2;
if (mp.find(str1) == mp.end()) {
mp[str2] = str1;
} else {
mp[str2] = mp[str1];
mp.erase(str1);
}
}
cout << mp.size() << endl;
map<string, string>::iterator it;
for (it = mp.begin(); it != mp.end(); it++) {
cout << it->second << " " << it->first << endl;
}
return 0;
}
| 1,100 | CPP |
n=input()
s=""
v=0
w=0
x=0
y=0
z=0
for i in range(len(n)):
if (n[i]=="h"):
s=s+n[i]
v=i
break
for j in range(v+1,len(n)):
if (n[j]=="e"):
s=s+n[j]
w=j
break
for k in range(w+1,len(n)):
if (n[k]=="i"):
s=s+n[k]
x=k
break
for l in range(x+1,len(n)):
if (n[l]=="d"):
s=s+n[l]
y=l
break
for m in range(y+1,len(n)):
if (n[m]=="i"):
s=s+n[m]
break
if s=="heidi":
print("YES")
else:
print("NO")
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e9 + 14;
int a, b;
vector<pair<int, int> > segs;
void unite(vector<pair<int, int> > &v) {
int sz = 0;
sort(v.begin(), v.end());
for (auto [l, r] : v)
if (!sz || v[sz - 1].second < l)
v[sz++] = {l, r};
else
v[sz - 1].second = max(v[sz - 1].second, r);
v.resize(sz);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> a >> b;
auto process = [](int k) {
if (k < 1) return;
int nl = (a + k) / (k + 1), nr = a / k;
int ml = (b + k) / (k + 1), mr = b / k;
if (nr < nl || mr < ml) return;
segs.push_back({nl + ml, nr + mr});
};
for (int delta = -1; delta <= 1; delta++) {
for (int i = 1; i * i <= a; i++) process(i + delta);
for (int i = 1; i * i <= b; i++) process(i + delta);
for (int i = 1; i * i <= a; i++) process(a / i + delta);
for (int i = 1; i * i <= b; i++) process(a / i + delta);
}
unite(segs);
int ans = 0;
for (auto [l, r] : segs) ans += r - l + 1;
cout << ans << '\n';
}
| 2,700 | CPP |
w = int(input(''))
if (w%2 == 0 and w != 2):
print('YES')
else:
print('NO') | 800 | PYTHON3 |
for i in range(int(input())):
a,b=map(int,input().split())
if b>a:
print(b-a)
elif b==a or a%b==0:
print(0)
else:
y=(a%b)
print(b-y) | 1,500 | PYTHON3 |
Subsets and Splits