solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
for _ in range(1):
x=set(list(input()))
if len(x)%2==0:
print('CHAT WITH HER!')
else:
print("IGNORE HIM!")
| 7 | PYTHON3 |
#include <iostream>
#include <cstdio>
#define int long long
#define N 200002
using namespace std;
const int mod=1000000007;
int a,b,x,y,i,j,f[N],inv[N];
int poww(int a,int b)
{
int ans=1,base=a;
while(b){
if(b&1) ans=ans*base%mod;
base=base*base%mod;
b>>=1;
}
return ans;
}
int C(int n,int m)
{
return f[n]*inv[m]%mod*inv[n-m]%mod;
}
signed main()
{
cin>>a>>b>>x>>y;
f[0]=1;
for(i=1;i<=200000;i++) f[i]=f[i-1]*i%mod;
inv[200000]=poww(f[200000],mod-2);
for(i=199999;i>=0;i--) inv[i]=inv[i+1]*(i+1)%mod;
int ans=C(a+b-2,b-1);
for(i=a-x+1;i<=a-x+1;i++){
for(j=1;j<=y;j++) ans=(ans-C(i+j-3,j-1)*C(a+b-i-j,b-j)%mod+mod)%mod;
}
cout<<(ans+mod)%mod<<endl;
return 0;
}
| 0 | CPP |
#119A-Epic Game
a,b,n=[int(x) for x in input().split(' ')]
def f(x,y):
a=max(x,y)
b=min(x,y)
c=a-b
if c == 0:
return b
else:
while True:
a=max(b,c)
b=min(b,c)
c=a-b
if c == 0:
return b
break
while True:
n-=f(a,n)
if n == 0:
print('0')
break
else:
n-=f(b,n)
if n == 0:
print('1')
break
| 7 | PYTHON3 |
import os,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)
try:sys.stdin,sys.stdout=open('in.txt','r'),open('out.txt','w')
except:pass
ii1=lambda:int(sys.stdin.readline().strip()) # for interger
is1=lambda:sys.stdin.readline().strip() # for str
iia=lambda:list(map(int,sys.stdin.readline().strip().split())) # for List[int]
isa=lambda:sys.stdin.readline().strip().split() # for List[str]
mod=int(1e9 + 7);from collections import *;from math import *
# abc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
# sys.setrecursionlimit(500000)
###################### Start Here ######################
# from functools import lru_cache
# from collections import defaultdict as dd
from collections import deque as dq
def solve(N,K):
dp = [[[-1 for k in range(2)] for j in range(K+1)] for i in range(N+1)]
for i in range(1,N+1):
dp[i][1][0]=1
dp[i][1][1]=1
for k in range(2,K+1):
for n in range(N,0,-1):
ans = 2
if n<N:
ans += dp[n+1][k][0]-1
ans%=mod
if n>1:
ans+=dp[n-1][k-1][1]-1
ans%=mod
dp[n][k][0]= ans
for n in range(1,N+1):
ans = 2
if n<N:
ans+=dp[n+1][k-1][0]-1
ans%=mod
if n>1:
ans+=dp[n-1][k][1]-1
ans%=mod
dp[n][k][1]=ans
print(dp[1][K][0])
for _ in range(ii1()):
n,k = iia()
solve(n,k)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int d[70], e[70];
int valid(string a, int base, int lim) {
int p = 1, x = 0;
for (int i = int(a.size()) - 1; i >= 0; i--) {
int digit = (a[i] <= '9' ? a[i] - '0' : a[i] - 'A' + 10);
if (digit >= base) return 0;
x += digit * p;
p *= base;
if (x >= lim) return 0;
}
return 1;
}
int infinity(string a, int d[], int lim) {
if (int(a.size()) == 1) {
for (int i = 1; i <= 60; i++) d[i] = valid(a, i, lim);
return valid(a, lim, lim);
} else {
for (int i = 1; i <= lim; i++) d[i] = valid(a, i, lim);
return 0;
}
}
int main() {
string a, b;
cin >> a;
for (int i = 0; i < int(a.size()); i++)
if (a[i] == ':') {
b = a.substr(i + 1, int(a.size()) - i);
a.erase(i, int(a.size()) - i + 1);
}
while (int(a.size()) > 1 && a[0] == '0') a.erase(0, 1);
while (int(b.size()) > 1 && b[0] == '0') b.erase(0, 1);
if (infinity(a, d, 24) + infinity(b, e, 60) == 2) {
puts("-1");
return 0;
}
int haveAns = 0;
for (int i = 1; i <= 60; i++)
if (d[i] && e[i]) cout << i << ' ', haveAns = 1;
if (!haveAns) puts("0");
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << (((a ^ b) && (c || d)) ^ ((b && c) || (d ^ a))) << endl;
}
| 11 | CPP |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int a[200005];
int n,k;
int check( int x )
{
int res=k;
for( int i=1;i<=n;i++ )
{
res-=(a[i]+x-1)/x-1;
}
return res>=0;
}
int main()
{
cin>>n>>k;
for( int i=1;i<=n;i++ ) cin>>a[i];
int l=1,r=1e9,ans=1;
while( l<=r )
{
int mid=l+r>>1;
if( check(mid) )
{
ans=mid;
r=mid-1;
}
else l=mid+1;
}
cout<<ans<<endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int l;
string s;
cin >> l;
cin >> s;
int n = s.length();
if (l > n) {
cout << '1';
for (int i = 0; i < l - 1; ++i) cout << '0';
cout << endl;
} else if (n % l != 0) {
string t = "1";
for (int i = 0; i < l - 1; ++i) t = t + '0';
for (int i = 0; i < n / l + 1; ++i) cout << t;
cout << endl;
}
if (n % l == 0) {
int all_9 = 1;
for (int i = 0; i < n; ++i)
if (s[i] != '9') {
all_9 = 0;
break;
}
if (all_9) {
string t = "1";
for (int i = 0; i < l - 1; ++i) t = t + '0';
for (int i = 0; i < n / l + 1; ++i) cout << t;
cout << endl;
return 0;
}
string x = s.substr(0, l);
int all_greater_mx = 1;
for (int i = l; i < n; i += l) {
if (s.substr(i, l) < x) {
all_greater_mx = 0;
break;
}
}
if (all_greater_mx) {
for (int i = l - 1; i >= 0; --i) {
if (x[i] == '9')
x[i] = '0';
else {
x[i] += 1;
break;
}
}
for (int i = 0; i < n / l; ++i) cout << x;
cout << endl;
return 0;
}
for (int i = 0; i < n / l; ++i) cout << x;
cout << endl;
}
return 0;
}
| 9 | CPP |
from collections import deque
n, k = map(int, input().split())
nums = list(map(int, input().split()))
if k == 1:
print(min(nums))
elif k == 2:
prefix = []
postfix = deque()
current = float('inf')
for i in nums:
current = min(i, current)
prefix.append(current)
current = float('inf')
for i in range(len(nums) - 1, -1, -1):
current = min(current, nums[i])
postfix.appendleft(current)
best = float('-inf')
for i in range(len(nums)):
best = max(best, max(prefix[i], postfix[i]))
print(best)
else:
print(max(nums)) | 8 | PYTHON3 |
import math
from decimal import Decimal
import heapq
import copy
import heapq
from collections import deque
from collections import defaultdict
MOD = 1000000007
def na():
n = int(input())
b = [int(x) for x in input().split()]
return n,b
def nab():
n = int(input())
b = [int(x) for x in input().split()]
c = [int(x) for x in input().split()]
return n,b,c
def dv():
n, m = map(int, input().split())
return n,m
def da():
n, m = map(int, input().split())
a = list(map(int, input().split()))
return n,m, a
def dva():
n, m = map(int, input().split())
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
return n,m,b
def eratosthenes(n):
sieve = list(range(n + 1))
for i in sieve:
if i > 1:
for j in range(i + i, len(sieve), i):
sieve[j] = 0
return sorted(set(sieve))
def lol(lst,k):
k=k%len(lst)
ret=[0]*len(lst)
for i in range(len(lst)):
if i+k<len(lst) and i+k>=0:
ret[i]=lst[i+k]
if i+k>=len(lst):
ret[i]=lst[i+k-len(lst)]
if i+k<0:
ret[i]=lst[i+k+len(lst)]
return(ret)
def nm():
n = int(input())
b = [int(x) for x in input().split()]
m = int(input())
c = [int(x) for x in input().split()]
return n,b,m,c
def dvs():
n = int(input())
m = int(input())
return n, m
def fact(n):
tc = []
ans = {}
d = 2
while d * d <= n:
if n % d == 0:
tc.append(d)
n //= d
else:
d += 1
if n > 1:
tc.append(n)
for i in tc:
ans[i] = ans.get(i, 0) + 1
return ans
def to_zero(n, s):
lst = s[0]
ans = []
for i in range(n):
if lst == s[i]:
continue
else:
if lst == '0':
lst = '1'
ans.append(i)
else:
lst = '0'
ans.append(i)
if lst == '1':
ans.append(n)
return ans
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
for x in range(513):
ff = True
for i in a:
f = False
for j in b:
if (i&j) | x == x:
f = True
break
if not f:
ff = False
break
if ff:
print(x)
exit()
| 9 | PYTHON3 |
test = int(input())
for t in range(test):
n = int(input())
a = list(map(int, input().split()))
attendance = [False for i in range(n)]
for i in range(1,n+1):
x = (i + a[i%n])%n
if attendance[x] == True:
print('NO')
break
else:
attendance[x] = True
if False not in attendance:
print('YES') | 7 | PYTHON3 |
l,r,d=map(int,input().split())
def calc(x,d):
return x//d
print(calc(r,d)-calc(l-1,d)) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
cin >> n;
int in[n];
int count[101] = {0};
for (int i = 0; i < n; i++) {
cin >> in[i];
count[in[i]]++;
}
int niceCount = 0;
int gtTwoInd = -1;
string res;
for (int i = 0; i < n; i++) {
if (count[in[i]] > 0) {
if (count[in[i]] == 1) {
niceCount++;
if (niceCount % 2) {
res += "A";
} else {
res += "B";
}
} else {
if (count[in[i]] > 2) {
gtTwoInd = i;
}
res += "A";
}
}
}
if (niceCount % 2) {
if (gtTwoInd == -1) {
cout << "NO" << endl;
} else {
res[gtTwoInd] = 'B';
cout << "YES" << endl;
cout << res << endl;
}
} else {
cout << "YES" << endl;
cout << res << endl;
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n ;
cin >> n ;
int a,b,c=0;
while(n--){
cin >> a >> b ;
c=(a==b)?c+1:0;
if(c==3){
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl ;
}
| 0 | CPP |
from functools import reduce
n = int(input())
limit = int(pow(n, 1 / 2)) + 1
primes = []
bs = [True] * limit
def sieve():
bs[0] = False
bs[1] = False
for i in range(2, limit):
if bs[i]:
for j in range(i * i, limit, i):
bs[j] = False
primes.append(i)
def prime_factors():
pfs = set()
temp = n
p_idx = 0
while temp > 1 and p_idx < len(primes):
prime = primes[p_idx]
while temp % prime == 0:
pfs.add(prime)
temp //= prime
p_idx += 1
if temp > 1:
pfs.add(temp)
return pfs
sieve()
pfs = prime_factors()
ans = 1 if not pfs else reduce(lambda x,y: x * y, pfs)
print(ans)
| 8 | PYTHON3 |
sa = input()
sb = input()
ln = len(sa)
for i in range(ln):
if int(sa[i]) and int(sb[i]):
print(0, end='')
elif int(sa[i]) or int(sb[i]):
print(1, end='')
else:
print(0, end='')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> primes;
void sieve() {
int i, j;
bitset<1010> bs;
bs.set();
bs[0] = bs[1] = 0;
for (i = 2; i <= 1010; i++) {
if (bs[i] == 1) {
for (j = i * i; j <= 1010; j += i) bs[j] = 0;
primes.push_back(i);
}
}
}
int main() {
int i, n, j;
sieve();
cin >> n;
vector<int>::iterator it;
it = lower_bound(primes.begin(), primes.end(), n);
int index = it - primes.begin();
cout << primes[index] << '\n';
for (i = 1; i < n; i++) cout << i << ' ' << i + 1 << '\n';
cout << n << " 1\n";
j = 1;
for (i = n; i < primes[index]; i++) {
if (i != n && (i - n) % 2 == 0) j += 2;
cout << j << ' ' << j + 2 << '\n';
j++;
}
}
| 10 | CPP |
// This amazing code is by Eric Sunli Chen.
#include<bits/stdc++.h>
using namespace std;
template<typename T> bool get_int(T &x)
{
char t=getchar();
bool neg=false;
x=0;
for(; (t>'9'||t<'0')&&t!='-'&&t!=EOF; t=getchar());
if(t=='-')neg=true,t=getchar();if(t==EOF)return false;
for(; t<='9'&&t>='0'; t=getchar())x=x*10+t-'0';
if(neg)x=-x;return true;
}
template<typename T> void print_int(T x)
{
if(x<0)putchar('-'),x=-x;
short a[20]= {},sz=0;
while(x>0)a[sz++]=x%10,x/=10;
if(sz==0)putchar('0');
for(int i=sz-1; i>=0; i--)putchar('0'+a[i]);
}
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define get1(a) get_int(a)
#define get2(a,b) (get1(a)&&get1(b))
#define get3(a,b,c) (get1(a)&&get2(b,c))
#define printendl(a) print_int(a),puts("")
typedef long long LL;
typedef unsigned long long uLL;
typedef pair<int,int> pii;
const int inf=0x3f3f3f3f;
const LL Linf=1ll<<61;
const double pi=acos(-1.0);
const int mod=1e9+7;
int n,k,comb[233][233],tot,tot2,ma[111],mb[111];
char s[111];
int c[111],ans,use[111];
void dfs(int mx,int cnt,int sum,int coef)
{
if(cnt+sum-1>n)return;
if(cnt>tot)return;
if(mx==0)
{
if(cnt==0)
{
ans++;if(ans>=mod)ans-=mod;
return;
}
if(cnt-c[1]>tot2)return;
bool ok=1;int cur=0;
memset(use,0,sizeof(use));
for(int i=(n+3)>>1;i>0;i--)
{
for(int j=1;j<=c[i];j++)
{
cur++;
use[ma[cur]]=1;
use[mb[cur]]=i-1;
}
}
cur=0;
for(int i=k;i>=1&&ok;i--)
{
cur++;
if(cur<use[i])ok=0;
else cur-=use[i];
}
if(ok)
{
int have=n-cnt-sum+1,need=sum+cnt+1+(cnt-c[1])*2;
ans=(ans+1ll*coef*comb[have+need-1][need-1])%mod;
}
return;
}
for(c[mx]=0;c[mx]<=n;c[mx]++)dfs(mx-1,cnt+c[mx],sum+c[mx]*(mx==1?1:mx+mx-3),coef*1ll*comb[cnt+c[mx]][cnt]%mod);
}
int main()
{
for(int i=0;i<233;i++)
{
comb[i][0]=1;
for(int j=1;j<=i;j++)
{
comb[i][j]=comb[i-1][j]+comb[i-1][j-1];
if(comb[i][j]>=mod)comb[i][j]-=mod;
}
}
get2(n,k);
scanf("%s",s+1);
for(int i=1;i<=k;i++)if(s[i]=='r')
{
int j=i;
for(;j<=k;j++)if(s[j]=='b'&&!use[j])break;
tot++;tot2+=(j<=k);
ma[tot]=i;mb[tot]=j;
use[j]=1;
}
dfs((n+3)/2,0,0,1);
printendl(ans);
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long cap[350][350];
long long flw[350][350];
char vis[350];
long long maxcr;
int in[350], out[350];
int cnum;
int from[100000], to[100000];
long long mov[100000];
long long cur[350];
int n, e;
long long st, beg;
long long scnd;
int fulkerson(int u, long long cur) {
if (u == n + 1) {
st += cur;
return cur;
}
vis[u] = 1;
for (int v = n + 1; v >= 0; v--)
if (vis[v] == 0)
if (flw[u][v] < cap[u][v]) {
long long code = fulkerson(v, min(cur, cap[u][v] - flw[u][v]));
if (code > 0) {
flw[u][v] += code;
flw[v][u] -= code;
return code;
}
}
return 0;
}
void discharge(int u) {
if (cur[u] == 0) return;
for (int v = 1; v <= n; v++)
if (flw[u][v] > 0) {
if (cur[v] + min(flw[u][v], cur[u]) > maxcr) discharge(v);
long long kre = min(flw[u][v], cur[u]);
cnum++;
from[cnum] = u;
to[cnum] = v;
mov[cnum] = kre;
cur[u] -= kre;
cur[v] += kre;
flw[u][v] -= kre;
if (flw[u][v] == 0) {
in[v]--;
out[u]--;
}
if (cur[u] == 0) break;
}
}
int main() {
scanf("%d", &n);
cin >> maxcr;
scanf("%d", &e);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
cur[i] = x;
cap[0][i] = x;
beg += x;
}
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
cap[i][n + 1] = x;
scnd += x;
}
if (beg != scnd) {
printf("NO\n");
return 0;
}
while (e--) {
int x, y;
scanf("%d%d", &x, &y);
cap[x][y] = (1000000000000ll);
cap[y][x] = (1000000000000ll);
}
while (fulkerson(0, (1000000000000ll))) {
for (int i = 0; i <= n + 1; i++) vis[i] = 0;
}
if (beg != st) {
printf("NO\n");
return 0;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (flw[i][j] > 0) {
in[j]++;
out[i]++;
}
char ch = 1;
while (ch) {
ch = 0;
for (int i = 1; i <= n; i++)
if (out[i] > 0) {
discharge(i);
ch = 1;
}
}
printf("%d\n", cnum);
for (int i = 1; i <= cnum; i++)
cout << from[i] << ' ' << to[i] << ' ' << mov[i] << '\n';
}
| 9 | CPP |
#-------------Program-------------
#----KuzlyaevNikita-Codeforces----
#---------------------------------
n=int(input())
a=list(map(int,input().split()))
d=[];s=[0]
for i in range(2000):
d.append(0)
for i in range(n):
d[a[i]-1]+=1
for i in range(2000):
s.append(s[-1]+d[i])
del(s[0])
for i in range(n):
print(1+n-s[a[i]-1],end=' ') | 7 | PYTHON3 |
f1 = lambda : list(map(int,input().split()))
f2 = lambda : map(int,input().split())
n = int(input())
arr = f1()
arr = sorted(arr)
ans = sum(arr)
res = 0
for i in range(n):
res += ans + arr[i]
ans -= arr[i]
print(res - arr[-1])
| 7 | PYTHON3 |
def countRhombus(i):
if i <= 1:
return 1
return 4*(i-1) + countRhombus(i-1)
n = int(input())
print(countRhombus(n))
| 7 | PYTHON3 |
from collections import deque
n,m=map(int,input().split())
data=[[] for i in range(n+1)]
for i in range(m):
a,b=map(int,input().split())
data[a].append(b)
data[b].append(a)
flag=[0]*(n+1)
cnt=-1
for i in range(1,n+1):
if flag[i]==0:
flag[i]=1
que=deque([i])
while que:
h=que.popleft()
for u in data[h]:
if flag[u]==0:
flag[u]=1
que.append(u)
cnt+=1
print(cnt) | 0 | PYTHON3 |
a = int(input())
l = list(map(int, input().rstrip().split(" ")))
s = sum(l)
c = 0
li = []
for i in range(a):
if (s - l[i])/(a-1) == l[i]:
li.append(i+1)
c+=1
if not c:
print(0)
else:
print(c)
print(*li) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
if (s.size() < 26) {
cout << -1 << endl;
return 0;
}
char pos = '!';
bool flag = false;
for (int i = 0; i < s.size(); i++) {
if (pos == '!') {
if (s[i] == 'a') pos = 'a';
} else if (s[i] <= pos + 1) {
s[i] = pos + 1;
pos++;
}
if (pos == 'z') {
flag = true;
break;
}
}
if (flag)
cout << s << endl;
else
cout << -1 << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
constexpr int DEBUG = 0;
constexpr int NUM_BITS = 60;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int64> xs(n);
for (int i = 0; i < n; i++) {
cin >> xs[i];
}
int64 xor_all = 0;
for (int64 x : xs) {
xor_all ^= x;
}
for (int i = 0; i < n; i++) {
xs[i] &= ~xor_all;
}
int c = 0;
for (int b = NUM_BITS - 1; b >= 0; b--) {
int pivot_i = -1;
for (int i = c; i < n; i++) {
if (xs[i] & (1L << b)) {
pivot_i = i;
break;
}
}
if (pivot_i < 0) continue;
swap(xs[pivot_i], xs[c]);
for (int i = 0; i < n; i++) {
if (i == c) continue;
if (xs[i] & (1L << b)) {
xs[i] ^= xs[c];
}
}
c++;
}
int64 xor_all_2 = 0;
for (int i = 0; i < n; i++) {
xor_all_2 ^= xs[i];
}
cout << xor_all + xor_all_2 * 2 << endl;
} | 0 | CPP |
import math
for _ in range(int(input())):
x,y,n = list(map(int, input().split()))
p = math.floor((n - y) / x)
k = p*x + y
print(k)
# m = 0
# o = n%x
# if o<y:
# m = o+x-y
# print(n-m)
# else:
# print(n-m+y) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using LL = long long;
struct Edge {
int v, a, b;
};
struct Line {
Line(LL a = 0, LL b = 0) : a(a), b(b) {}
LL at(LL x) const { return a * x + b; }
LL a, b;
};
bool operator<(const Line& u, const Line& v) {
return u.a == v.a ? u.b < v.b : u.a < v.a;
}
using LineList = std::vector<Line>;
const int N = 100000;
const int M = 1000000;
int n, m, size[N], imbl[N];
bool resolved[N];
std::vector<int> vertices;
std::vector<Edge> edges[N];
Line tree[M << 1];
void prepare(int p, int u) {
size[u] = 1;
imbl[u] = 0;
vertices.push_back(u);
for (auto&& e : edges[u]) {
if (e.v != p && !resolved[e.v]) {
prepare(u, e.v);
size[u] += size[e.v];
imbl[u] = std::max(imbl[u], size[e.v]);
}
}
}
struct Cmp {
bool operator()(LineList* a, LineList* b) const {
return a->size() > b->size();
}
};
void dfs(LineList& lst, int p, int u, LL a, LL b) {
lst.push_back(Line{a, b});
for (auto&& e : edges[u]) {
if (e.v != p && !resolved[e.v]) {
dfs(lst, u, e.v, a + e.a, b + e.b);
}
}
}
int get_id(int l, int r) { return l + r | l != r; }
void update(int l, int r, Line u) {
auto& v = tree[get_id(l, r)];
if (u.at(l) > v.at(l)) {
std::swap(u, v);
}
if (l < r && u.at(r) > v.at(r)) {
int m = l + r >> 1;
if (u.at(m) > v.at(m)) {
std::swap(u, v);
update(l, m, u);
} else {
update(m + 1, r, u);
}
}
}
void merge(const LineList& u, const LineList& v, int ub, int ue, int vb, int ve,
int l, int r) {
int m = l + r >> 1;
std::pair<LL, int> ubest{-1, 0}, vbest{-1, 0};
for (int z = ub; z < ue; ++z) {
ubest = std::max(ubest, std::make_pair(u[z].at(m), z));
}
for (int z = vb; z < ve; ++z) {
vbest = std::max(vbest, std::make_pair(v[z].at(m), z));
}
if (l == r || (ub + 1 == ue && vb + 1 == ve)) {
auto&& x = u[ubest.second];
auto&& y = v[vbest.second];
update(l, r, Line{x.a + y.a, x.b + y.b});
} else {
merge(u, v, ub, ubest.second + 1, vb, vbest.second + 1, l, m);
merge(u, v, ubest.second, ue, vbest.second, ve, m + 1, r);
}
}
void divide(int root) {
vertices.clear();
prepare(-1, root);
std::pair<int, int> best{imbl[root], root};
for (int v : vertices) {
best = std::min(best,
std::make_pair(std::max(imbl[v], size[root] - size[v]), v));
}
root = best.second;
resolved[root] = true;
std::priority_queue<LineList*, std::vector<LineList*>, Cmp> pq;
pq.emplace(new LineList{Line{0, 0}});
for (auto&& e : edges[root]) {
if (!resolved[e.v]) {
auto l = new LineList{};
dfs(*l, root, e.v, e.a, e.b);
pq.emplace(l);
}
}
while (pq.size() > 1) {
auto a = pq.top();
pq.pop();
auto b = pq.top();
pq.pop();
std::sort(a->begin(), a->end());
std::sort(b->begin(), b->end());
merge(*a, *b, 0, a->size(), 0, b->size(), 0, m - 1);
for (auto&& l : *a) {
b->push_back(l);
}
delete a;
pq.emplace(b);
}
delete pq.top();
for (auto&& e : edges[root]) {
if (!resolved[e.v]) {
divide(e.v);
}
}
}
LL query(int l, int r, int x) {
int m = l + r >> 1;
return std::max(tree[get_id(l, r)].at(x),
l == r ? 0 : (x <= m ? query(l, m, x) : query(m + 1, r, x)));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0, u, v, a, b; i < n - 1; ++i) {
scanf("%d%d%d%d", &u, &v, &a, &b);
u--;
v--;
edges[u].push_back(Edge{v, a, b});
edges[v].push_back(Edge{u, a, b});
}
divide(0);
for (int i = 0; i < m; ++i) {
printf("%lld%c", query(0, m - 1, i), " \n"[i == m - 1]);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops")
std::pair<int, int> DR[] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, 1}, {-1, -1}, {1, 1}, {1, -1}};
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
~debug() { cerr << endl; }
template <class c>
typename enable_if<sizeof dud<c>(0) != 1, debug&>::type operator<<(c i) {
cerr << boolalpha << i;
return *this;
}
template <class c>
typename enable_if<sizeof dud<c>(0) == 1, debug&>::type operator<<(c i) {
return *this << range(begin(i), end(i));
}
template <class c, class b>
debug& operator<<(pair<b, c> d) {
return *this << "(" << d.first << ", " << d.second << ")";
}
template <class c>
debug& operator<<(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it) *this << ", " + 2 * (it == d.b) << *it;
return *this << "]";
}
};
int gcd(int a, int b) {
if (b) return gcd(b, a % b);
return a;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int l[1 << 18], r[1 << 18], L, occ[1 << 20], a[1 << 18], n, t;
vector<int> vec;
long long sum, ans[1 << 18];
inline void rem(int val) {
sum -= 1ll * occ[val] * occ[val] * val;
occ[val]--;
sum += 1ll * occ[val] * occ[val] * val;
}
inline void add(int val) {
sum -= 1ll * occ[val] * occ[val] * val;
occ[val]++;
sum += 1ll * occ[val] * occ[val] * val;
}
bool comp(int a, int b) {
if (l[a] / L != l[b] / L) return (l[a] / L) < (l[b] / L);
return r[a] < r[b];
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n >> t;
L = sqrt(n);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= t; i++) {
cin >> l[i] >> r[i];
vec.push_back(i);
}
sort(vec.begin(), vec.end(), comp);
int pointa = 1;
int pointb = 1;
add(a[1]);
for (auto it : vec) {
while (pointb != r[it]) {
if (pointb > r[it])
rem(a[pointb--]);
else
add(a[++pointb]);
}
while (pointa != l[it]) {
if (pointa > l[it])
add(a[--pointa]);
else
rem(a[pointa++]);
}
ans[it] = sum;
}
for (int i = 1; i <= t; i++) cout << ans[i] << '\n';
return 0;
}
| 10 | CPP |
#include<iostream>
using namespace std;
int main(){
int i,o=0;
string s;
cin>>s;
for(i=0;i<s.size();i++){
if(s[i]=='o') o++;
}
if((15-s.size())+o>=8) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
return 0;
} | 0 | CPP |
#include <iostream>
#include <cmath>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
cout << K * (int)pow(K-1, N - 1);
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
char a[1111][1111];
int mx[1111][1111][4];
map<char, int> dir;
int n, m, k;
pair<int, int> inst[111111];
void go(int i, int j, int l) {
if (mx[i][j][l] != -1) return;
if (a[i][j] == '#') {
mx[i][j][l] = 0;
return;
}
if (a[i + dx[l]][j + dy[l]] == '#') {
mx[i][j][l] = 0;
return;
}
go(i + dx[l], j + dy[l], l);
mx[i][j][l] = mx[i + dx[l]][j + dy[l]][l] + 1;
}
int main() {
dir['N'] = 0;
dir['E'] = 1;
dir['S'] = 2;
dir['W'] = 3;
memset(mx, -1, sizeof(mx));
gets(a[0]);
sscanf(a[0], "%d%d", &n, &m);
for (int(i) = 0; (i) < (n); ++(i)) gets(a[i]);
gets(a[n]);
sscanf(a[n], "%d", &k);
for (int(i) = 0; (i) < (k); ++(i)) {
gets(a[n]);
char ch;
sscanf(a[n], "%c%d", &ch, &inst[i].first);
inst[i].second = dir[ch];
}
for (int(i) = 0; (i) < (n); ++(i))
for (int(j) = 0; (j) < (m); ++(j))
for (int(l) = 0; (l) < (4); ++(l))
if (mx[i][j][l] == -1) go(i, j, l);
string ans = "";
for (int(i) = 0; (i) < (n); ++(i))
for (int(j) = 0; (j) < (m); ++(j))
if (a[i][j] >= 'A' && a[i][j] <= 'Z') {
int ci = i, cj = j;
bool ok = 1;
for (int(l) = 0; (l) < (k); ++(l))
if (mx[ci][cj][inst[l].second] < inst[l].first) {
ok = 0;
break;
} else {
ci += dx[inst[l].second] * inst[l].first;
cj += dy[inst[l].second] * inst[l].first;
}
if (ok) ans += a[i][j];
}
sort((ans).begin(), (ans).end());
if (!(int)(ans).size()) ans = "no solution";
cout << ans << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
set<pair<int, bool> > edges[100001];
int main() {
stack<pair<int, int> > stk;
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y), --x, --y;
edges[x].insert(make_pair(y, 0));
edges[y].insert(make_pair(x, 0));
}
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y), --x, --y;
edges[x].insert(make_pair(y, 1));
edges[y].insert(make_pair(x, 1));
stk.push(make_pair(x, y));
}
int cnt = 0;
while (!stk.empty()) {
pair<int, int> edge = stk.top();
stk.pop();
int x = edge.first, y = edge.second;
auto it = edges[x].find(make_pair(y, 0));
if (it != edges[x].end()) {
__typeof(it) it2 = it;
++it2;
if (it2 != edges[x].end() && it2->first == y) {
if (edges[x].size() < edges[y].size()) swap(x, y);
++cnt;
edges[x].erase(make_pair(y, 0));
edges[x].erase(make_pair(y, 1));
edges[y].erase(make_pair(x, 0));
edges[y].erase(make_pair(x, 1));
for (auto it3 = edges[y].begin(); it3 != edges[y].end();) {
stk.push(make_pair(x, it3->first));
edges[it3->first].erase(make_pair(y, it3->second));
edges[it3->first].insert(make_pair(x, it3->second));
edges[x].insert(*it3);
it3 = edges[y].erase(it3);
}
}
}
}
puts(cnt == n - 1 ? "YES" : "NO");
} | 0 | CPP |
t=int(input())
while t:
t=t-1
p=list(map(int,input().split()))
n=p[0]
m=p[1]
a=list(map(int,input().split()))
b=list(map(int,input().split()))
l=list(set(a).intersection(b))
if len(l)>0:
print("YES")
print(1,l[0])
else:
print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > gr[2 * 100005 + 5];
int d[2 * 100005 + 5], cost[2 * 100005 + 5];
long long minim = 0, maxim = 0;
void dfs(int node, int dad) {
bool ok = 0;
for (int i = 0; i < gr[node].size(); i++) {
int newnode = gr[node][i].first;
if (newnode != dad) {
dfs(newnode, node);
d[node] += d[newnode];
cost[newnode] = gr[node][i].second;
}
}
}
void solve() {
int n;
cin >> n;
for (int i = 1; i <= 2 * n; i++) gr[i].clear();
vector<bool> used(2 * n + 5, 0);
for (int i = 1; i < 2 * n; i++) {
int x, y, c;
cin >> x >> y >> c;
gr[x].push_back({y, c});
gr[y].push_back({x, c});
}
n = n * 2;
for (int i = 1; i <= n; i++) d[i] = 1;
dfs(1, 0);
maxim = 0, minim = 0;
for (int i = 2; i <= n; i++) {
maxim = maxim + 1LL * cost[i] * min(d[i], n - d[i]);
minim = minim + 1LL * cost[i] * (d[i] % 2);
}
cout << minim << " " << maxim << '\n';
}
int main() {
cin.tie(0)->sync_with_stdio(0);
int T;
cin >> T;
while (T--) {
solve();
}
}
| 11 | CPP |
#include<bits/stdc++.h>
#define maxn 310
#define N 90010
#define mod 998244353
#define ll long long
using namespace std;
int a[maxn], f[maxn][N], g[maxn][N];
int calc(int a, int k)
{
int ans = 1;
while (k)
{
if (k % 2) ans = (ll)ans * a % mod;
a = (ll)a * a % mod;
k /= 2;
}
return ans;
}
int main()
{
int n, sum = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
f[0][0] = 1;
g[0][0] = 1;
for (int i = 0; i <= n - 1; i++)
{
for (int j = 0; j <= sum; j++)
{
f[i + 1][j] = (f[i + 1][j] + f[i][j] * 2LL) % mod;
g[i + 1][j] = (g[i + 1][j] + g[i][j]) % mod;
f[i + 1][j + a[i + 1]] = (f[i + 1][j + a[i + 1]] + f[i][j]) % mod;
g[i + 1][j + a[i + 1]] = (g[i + 1][j + a[i + 1]] + g[i][j]) % mod;
}
sum += a[i + 1];
}
int res = 1;
for (int i = 1; i <= n; i++)
res = res * 3LL % mod;
for (int i = (sum + 1) / 2; i <= sum; i++)
res = (res - f[n][i] * 3LL % mod + mod) % mod;
if (sum % 2 == 0) res = (res + g[n][sum / 2] * 3LL % mod) % mod;
printf("%d\n", res);
return 0;
} | 0 | CPP |
a,b,c,d=map(int,input().split());print("YNeos"[(abs(a-b)>d or abs(b-c)>d)and abs(a-c)>d::2]) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, c = 0;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
vector<long long int> k(a, a + n);
sort(a, a + n);
vector<long long int> v;
for (int i = 0; i < n; i++) {
if (a[i] != k[i] && c < 2) {
v.push_back(i);
c++;
}
}
if (v.size() == 2) {
int x = v[0], b = v[1];
swap(k[x], k[b]);
}
bool x = 1;
for (int i = 0; i < n; i++) {
if (k[i] != a[i]) {
x = 0;
cout << "NO\n";
break;
}
}
if (x) cout << "YES\n";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10, MOD = 1000000007;
string s;
long long prefix[maxn], suffix[maxn], power[maxn];
long long exp(long long int base, long long exponent) {
long long res = 1;
while (exponent) {
if (exponent & 1) res = (base * res) % MOD;
exponent = exponent / 2;
base = (base * base) % MOD;
}
return res;
}
long long inverse(long long n) { return exp(n, MOD - 2); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
power[0] = 1;
for (int i = 1; i < maxn - 5; i++) power[i] = (power[i - 1] * 101LL) % MOD;
while (t--) {
cin >> s;
int n = (int)s.size();
if (n == 1) {
cout << s << "\n";
continue;
}
int i = -1, j = n;
string ans, ans2, ans3;
while (i + 1 < j) {
if (i + 1 == j - 1)
ans += s[++i];
else if (s[i + 1] == s[j - 1]) {
ans += s[++i];
j--;
} else
break;
}
if (i + 1 == j) {
cout << s << "\n";
continue;
}
for (int i = 0; i < ans.size(); i++) {
ans2 += ans[i];
ans3 += ans[i];
}
int l = i + 1, r = j - 1;
prefix[0] = 0;
prefix[1] = s[0];
for (int i = 2; i <= n; i++) {
prefix[i] = (prefix[i - 1] + (s[i - 1] * power[i - 1]) % MOD) % MOD;
}
suffix[0] = 0;
suffix[1] = s[n - 1];
for (int i = n - 2, j = 2; i >= 0 and j <= n; i--, j++) {
suffix[j] = (suffix[j - 1] + (s[i] * power[j - 1]) % MOD) % MOD;
}
int id1 = l;
for (int i = l; i <= r; i++) {
long long hash1 =
((prefix[i + 1] - prefix[l] + MOD) % MOD * inverse(power[l])) % MOD;
long long hash2 = ((suffix[n - l] - suffix[n - i - 1] + MOD) % MOD *
inverse(power[n - i - 1])) %
MOD;
if (hash1 == hash2) {
id1 = i;
}
}
int id2 = r;
for (int i = r; i >= l; i--) {
long long hash1 =
((prefix[r + 1] - prefix[i] + MOD) % MOD * inverse(power[i])) % MOD;
long long hash2 = ((suffix[n - i] - suffix[n - r - 1] + MOD) % MOD *
inverse(power[n - r - 1])) %
MOD;
if (hash1 == hash2) {
id2 = i;
}
}
for (int i = l; i <= id1; i++) ans2 += s[i];
for (int i = id2; i <= r; i++) ans3 += s[i];
for (int i = (int)ans.size() - 1; i >= 0; i--) {
ans2 += ans[i];
ans3 += ans[i];
}
if ((int)ans2.size() > (int)ans3.size())
cout << ans2 << "\n";
else
cout << ans3 << "\n";
}
return 0;
}
| 10 | CPP |
n=int(input())
l=sorted(map(int,input().split()))
ans = 0
for i in range(n):ans+=abs(i+1-l[i])
print(ans) | 9 | PYTHON3 |
n=int(input())
print(3*n+4)
print(0,0)
for i in range(1,n+2):
print(i,i)
print(i-1,i)
print(i,i-1) | 9 | PYTHON3 |
#include <bits/stdc++.h>
int par[100010], v[100010];
int root(int a) {
if (par[a] == a) return a;
return par[a] = root(par[a]);
}
int main() {
int n, m, k, a, b;
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
for (int i = 1; i <= n; ++i) par[i] = i, v[i] = 0;
while (m--) {
scanf("%d%d", &a, &b);
a = root(a), b = root(b);
if (a != b) par[a] = b;
}
for (int i = 1; i <= n; ++i) v[root(i)]++;
long long ans = 1;
int cnt = 0;
for (int i = 1; i <= n; ++i)
if (v[i]) ans = ans * v[i] % k, ++cnt;
if (cnt == 1) ans = 1 % k;
for (int i = 0; i < cnt - 2; ++i) ans = ans * n % k;
printf("%d\n", (int)ans);
}
return 0;
}
| 10 | CPP |
for _ in range(int(input())):
a,b = map(int, input().split())
e = max(a,b)
z =min(a,b)
z =2*z
if z>e:
print(z*z)
elif e==z:
print(e*z)
elif e>z:
print(e*e)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
const int mod = (1e9) + 7, mod2 = 998244353;
const double eps = 1e-10;
const int siz = 1e5 + 5, siz2 = 19, lg = 31, block = 317, block2 = 1000,
mxv = 5e5;
int n, lvldeg[siz], ndlvl[siz];
vector<int> adj[siz], chns[siz];
bool valid;
queue<pair<int, int> > q;
void check(int node, int p, int lvl) {
if (lvldeg[lvl] == 0) {
lvldeg[lvl] = adj[node].size();
} else if (lvldeg[lvl] != adj[node].size()) {
valid = false;
return;
}
for (int a : adj[node]) {
if (a != p) {
check(a, node, lvl + 1);
if (!valid) {
return;
}
}
}
}
int main() {
scanf("%d", &n);
if (n == 1) {
printf("1\n");
return 0;
}
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
if (adj[i].size() == 1) {
q.push({i, 1});
ndlvl[i] = 1;
}
}
while (!q.empty()) {
pair<int, int> top = q.front();
q.pop();
int node = top.first, lvl = top.second;
if (lvldeg[lvl] == 0) {
lvldeg[lvl] = adj[node].size();
} else if (lvldeg[lvl] != adj[node].size()) {
break;
}
int nummore = 0;
for (int a : adj[node]) {
if (ndlvl[a] == 0) {
ndlvl[a] = lvl + 1;
q.push({a, lvl + 1});
nummore++;
} else if (ndlvl[a] == lvl + 1) {
nummore++;
} else if (ndlvl[a] != lvl - 1) {
goto aftbfs;
}
}
if (nummore > 1) {
break;
}
if (nummore == 0) {
printf("%d\n", node);
return 0;
}
}
aftbfs:
memset(lvldeg, 0, sizeof lvldeg);
for (int i = 1; i <= n; i++) {
if (adj[i].size() == 1) {
int last = i, cur = adj[i][0];
while (adj[cur].size() == 2) {
for (int node : adj[cur]) {
if (node == last) {
continue;
}
last = cur;
cur = node;
break;
}
}
chns[cur].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
if (chns[i].size() == 1) {
valid = true;
check(chns[i][0], 0, 0);
if (valid) {
printf("%d\n", chns[i][0]);
} else {
printf("-1\n");
}
return 0;
}
chns[i].clear();
}
memset(lvldeg, 0, sizeof lvldeg);
for (int i = 1; i <= n; i++) {
if (adj[i].size() == 1) {
int last = i, cur = adj[i][0], len = 1;
while (adj[cur].size() == 2) {
len++;
for (int node : adj[cur]) {
if (node == last) {
continue;
}
last = cur;
cur = node;
break;
}
}
chns[len].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
if (chns[i].size() == 1) {
valid = true;
check(chns[i][0], 0, 0);
if (valid) {
printf("%d\n", chns[i][0]);
} else {
printf("-1\n");
}
return 0;
}
chns[i].clear();
}
printf("-1\n");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string str;
cin >> str;
cout << str[0];
for (int i = 1; i < str.size() - 1; i++) {
cout << str[i];
i++;
}
cout << str[str.size() - 1] << endl;
}
return 0;
}
| 7 | CPP |
a=int(input())
for i in range(a):
n,s=map(str,input().split())
n=int(n)
ans=[]
flag=1
glag=1
for i in range(len(s)):
if(i==0):
if(s[i]=='<'):
ans.append(-flag*n)
ans.append(ans[-1]+1)
else:
ans.append(-glag*n*n)
ans.append(ans[-1]-1)
else:
if(s[i]==s[i-1]=='<'):
ans.append(ans[-1]+1)
elif(s[i]==s[i-1]=='>'):
ans.append(ans[-1]-1)
elif(s[i]=='>'):
flag+=1
ans.append(-glag*n*n)
else:
glag+=1
ans.append(-flag*n)
t=abs(min(ans))
for i in range(len(ans)):
ans[i]+=t+1
big=[]
for i in range(len(ans)):
big.append([ans[i],i])
big.sort()
gam=[0 for i in range(n)]
for i in range(len(big)):
gam[big[i][1]]=i+1
print(*gam)
ans=[]
if(s[0]=='>'):
ans.append(-1)
ans.append(-2)
else:
ans.append(1)
ans.append(2)
mini=-3
maxa=3
for i in range(1,len(s)):
if(s[i]=='>'):
ans.append(mini)
mini-=1
else:
ans.append(maxa)
maxa+=1
t=abs(min(ans))
for i in range(len(ans)):
ans[i]+=t+1
big=[]
for i in range(len(ans)):
big.append([ans[i],i])
big.sort()
gam=[0 for i in range(n)]
for i in range(len(big)):
gam[big[i][1]]=i+1
print(*gam)
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::vector;
int next(int i, int n) {
if (i + 1 < n) return i + 1;
return 0;
}
int prev(int i, int n) {
if (i - 1 >= 0) return i - 1;
return n - 1;
}
int myabs(int x) {
if (x < 0) return -x;
return x;
}
int length(int x1, int y1, int x2, int y2) {
return myabs(x1 - x2) + myabs(y1 - y2);
}
void get_sums(const vector<int>& x, const vector<int>& y, int first,
vector<int>* result) {
int n = x.size();
result->clear();
bool first_time = true;
for (int i = first; i != first || first_time;
i = next(i, n), first_time = false) {
int len1 = length(x[i], y[i], x[prev(i, n)], y[prev(i, n)]);
int len2 = length(x[i], y[i], x[next(i, n)], y[next(i, n)]);
result->push_back(len1 + len2);
}
}
int main() {
int n, m;
cin >> n >> m;
vector<int> x(n), y(n);
vector<int> l(m);
vector<bool> u(m, false);
for (int i = 0; i < n; ++i) cin >> x[i] >> y[i];
for (int i = 0; i < m; ++i) cin >> l[i];
vector<int> sums;
get_sums(x, y, 0, &sums);
vector<int> ans(n, -2);
int count = sums.size() / 2;
for (int i = 0; i < sums.size(); i += 2) {
int lj = -1;
for (int j = 0; lj == -1 && j < l.size(); ++j)
if (!u[j] && l[j] == sums[i]) {
u[j] = true;
ans[i] = j;
count--;
break;
}
}
if (count == 0) {
cout << "YES" << endl;
for (int i = 0; i < ans.size(); ++i) cout << ans[i] + 1 << " ";
return 0;
}
get_sums(x, y, 1, &sums);
u = vector<bool>(m, false);
ans = vector<int>(n, -2);
count = sums.size() / 2;
for (int i = 0; i < sums.size(); i += 2) {
int lj = -1;
for (int j = 0; lj == -1 && j < l.size(); ++j)
if (!u[j] && l[j] == sums[i]) {
u[j] = true;
ans[i + 1] = j;
count--;
break;
}
}
if (count == 0) {
cout << "YES" << endl;
for (int i = 0; i < ans.size(); ++i) cout << ans[i] + 1 << " ";
return 0;
}
cout << "NO";
return 0;
}
| 7 | CPP |
n,t=map(int,input().split())
if(len(str(t))<=n):
if("0" in str(t)):
print(str(str(t)[0]*(n-1))+"0")
else:
print(str(t)*n)
else:
print("-1") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long fac[1000006];
inline long long exp(long long x, long long n) {
long long r = 1;
x = x % 1000000000000000000;
while (n) {
if (n % 2) r = (r * x) % 1000000000000000000;
x = (x * x) % 1000000000000000000;
n = n / 2;
}
return r;
}
inline long long mmi(long long a) {
return exp(a, 1000000000000000000 - 2) % 1000000000000000000;
}
inline long long fact(long long n) {
long long res = 1;
for (long long i = 1; i < (n + 1); ++i) {
res = (res * i) % 1000000000000000000;
}
return res;
}
inline void fact_a() {
fac[0] = 1;
fac[1] = 1;
for (long long i = 1; i < (105); ++i) {
fac[i] = (fac[i - 1] * i) % 1000000000000000000;
}
}
inline long long inv_fact(long long n) {
long long par = fac[n];
long long res = mmi(par);
return res;
}
inline long long comb(long long n, long long r) {
if (n == r && r == 0) return 1;
if (n < r) return 0;
return ((fac[n] * inv_fact(r)) % 1000000000000000000 * inv_fact(n - r)) %
1000000000000000000;
}
struct triplet {
long long a, b, c;
};
bool operator<(const triplet &t1, const triplet &t2) {
if (t1.a < t2.a) return true;
if (t1.a == t2.a && t1.b < t2.b) return true;
if (t1.a == t2.a && t1.b == t2.b && t1.c < t2.c) return true;
return false;
}
pair<long long, pair<long long, long long> > ex_gcd(long long a, long long b) {
if (b == 0) {
return make_pair(a, make_pair(1, 0));
}
pair<long long, pair<long long, long long> > p = ex_gcd(b, a % b);
long long gcd = p.first;
long long x1 = p.second.first;
long long y1 = p.second.second;
long long x = y1;
long long y = x1 - (a / b) * y1;
return make_pair(gcd, make_pair(x, y));
}
long long prime[1000006];
long long spf_prime[1000006];
void sieve() {
for (long long i = 2; i * i <= 1000000; i++)
if (prime[i] == 0)
for (long long j = i * i; j <= 1000000; j += i) prime[j] = 1;
}
void spf() {
for (long long i = 2; i * i <= 1000000; i++)
if (!spf_prime[i])
for (long long j = i * i; j <= 1000000; j += i)
if (!spf_prime[j]) spf_prime[j] = i;
for (long long i = 2; i <= 1000000; i++)
if (!spf_prime[i]) spf_prime[i] = i;
}
long long getparent_BIT(long long idx) { return idx - (idx & -idx); }
long long getnext_BIT(long long idx) { return idx + (idx & -idx); }
long long getsum_BIT(long long idx, long long BIT[], long long n) {
long long sum = 0;
while (idx > 0) {
sum += BIT[idx];
idx = getparent_BIT(idx);
}
return sum;
}
void update_BIT(long long idx, long long BIT[], long long val, long long n) {
while (idx <= n) {
BIT[idx] += val;
idx = getnext_BIT(idx);
}
}
void build_BIT(long long BIT[], long long a[], long long n) {
for (long long i = 0; i < (n); ++i) {
update_BIT(i, BIT, a[i], n);
}
}
void comp_lps(string s, long long lps[], long long n) {
long long i = 1, j = 0;
while (i < n) {
if (s[i] == s[j]) {
lps[i++] = ++j;
} else {
if (j != 0)
j = lps[j - 1];
else
lps[i++] = 0;
}
}
}
void dfs_l(long long u, vector<vector<long long> > &adj, long long status[]) {
if (status[u] == 1) return;
status[u] = 1;
for (long long i = 0; i < (adj[u].size()); ++i) dfs_l(adj[u][i], adj, status);
}
bool chk(int x, int y) {
cout << "? " << x << ' ' << y << "\n";
string a;
cin >> a;
return a == "x";
}
int main() {
string s;
cin >> s;
long long low, high;
while (s == "start") {
if (s != "start") break;
if (chk(0, 1)) {
cout << "! " << 1 << "\n";
} else {
int st = 1, end = 2;
while (!chk(st, end)) {
st = 2 * st;
end = 2 * end;
if (end > 1000000000) break;
}
low = st + 1, high = end;
while (low < high) {
int mid = (low + high) / 2;
if (chk(st, mid))
high = mid;
else
low = mid + 1;
}
cout << "! " << low << "\n";
}
cin >> s;
}
}
| 8 | CPP |
for _ in range(int(input())):
text = "YES"
a, b, c = input(), input(), input()
for i in range(len(a)):
if not(a[i] == c[i] or b[i] == c[i]):
text = "NO"
break
print(text)
| 7 | PYTHON3 |
t = int(input())
for i in range(t):
p = sorted(input())
h = input()
j = 0
res = 'NO'
while (j < len(h)):
if(p == sorted(h[j : len(p) + j])):
res = 'YES'
break
j += 1
print(res)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int main() {
cin >> n >> k;
if (k >= n / 2) {
cout << n * (n - 1) / 2;
} else {
cout << k * (2 * n - 2 * k - 1);
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int const N = 300009;
long long w[N], f[N];
vector<pair<int, long long>> adj[N];
long long ans = 0;
long long const inf = -1e16;
void dfs(int v, int p) {
vector<long long> bin;
f[v] = w[v];
ans = max(ans, f[v]);
for (auto it : adj[v]) {
int u = it.first;
if (u != p) {
dfs(u, v);
f[v] = max(f[v], f[u] - it.second + w[v]);
bin.push_back(f[u] - it.second);
}
}
sort(bin.begin(), bin.end(), greater<long long>());
if (bin.size() >= 1) ans = max(bin[0] + w[v], ans);
if (bin.size() >= 2) ans = max(ans, bin[0] + bin[1] + w[v]);
}
int main() {
clock_t begin = clock();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a, b;
long long ww;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 0; i < n - 1; i++) {
cin >> a >> b >> ww;
adj[a].push_back({b, ww});
adj[b].push_back({a, ww});
}
dfs(1, -1);
cout << ans << '\n';
return 0;
}
| 10 | CPP |
#include<iostream>
#include<sstream>
#include<algorithm>
#include<set>
#include<map>
#include<queue>
#include<complex>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cassert>
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define all(c) (c).begin(),(c).end()
#define mp make_pair
#define pb push_back
#define each(i,c) for(__typeof((c).begin()) i=(c).begin();i!=(c).end();i++)
#define dbg(x) cerr<<__LINE__<<": "<<#x<<" = "<<(x)<<endl
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pi;
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
int n, m;
bool ok(string &s, const set<string> &d, const set<string> &f){
string t = s;
bool flag = 0;
if(t[t.size() - 1] == '/') t += "index.html", flag = 1;
each(i, t) if(*i == '/') *i = ' ';
stringstream ss(t);
s = "";
while(ss >> t){
//dbg(s);
if(!d.count(s)) return 0;
if(t == ".") continue;
if(t == ".."){
int p = s.rfind("/");
if(p != s.npos) s = s.substr(0, p);
}
else{
s += "/" + t;
}
}
if(!flag && !f.count(s)) s += "/index.html";
return f.count(s);
}
int main(){
while(cin >> n >> m, n){
set<string> dir, file;
string s, t;
rep(i, n){
cin >> s;
file.insert(s);
int p;
while((p = s.rfind("/")) != s.npos){
s = s.substr(0, p);
dir.insert(s);
}
}
rep(i, m){
cin >> s >> t;
if(!ok(s, dir, file) || !ok(t, dir, file)) cout << "not found" << endl;
else cout << (s == t ? "yes" : "no") << endl;
}
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int score(int p, int t) { return (1000 - p) * 1000 + t; }
int main(int argc, const char* argv[]) {
int n, k;
cin >> n >> k;
--k;
map<int, int> ts;
for (int i = 0; i < n; ++i) {
int p, t;
cin >> p >> t;
ts[score(p, t)] += 1;
}
int res = 0;
for (auto p : ts) {
if (p.second > k) {
res = p.second;
break;
}
k -= p.second;
}
cout << res;
return 0;
}
| 7 | CPP |
n, x, y = map(int, input().split())
a = 0
s = list(input())
s.reverse()
for i in range(x):
if i <= y:
if s[i] == '1' and i != y: a += 1
elif i == y and s[i] == '0': a += 1
else:
if s[i] == '1' and i != x: a += 1
elif i == x and s[i] == '0': a += 1
print(a) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long p1, p2, x1, y1, x2, y2, a, b, c, n, cnt = 0;
cin >> x1 >> y1 >> x2 >> y2 >> n;
while (n--) {
cin >> a >> b >> c;
p1 = x1 * a + y1 * b + c;
p2 = x2 * a + y2 * b + c;
if (p1 > 0 && p2 < 0) cnt++;
if (p1 < 0 && p2 > 0) cnt++;
}
cout << cnt;
return 0;
}
| 7 | CPP |
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <valarray>
#include <vector>
#define EPS 1e-9
#define INF 1070000000LL
#define MOD 1000000007LL
#define fir first
#define foreach(it,X) for(__typeof((X).begin()) it=(X).begin();it!=(X).end();it++)
#define ite iterator
#define mp make_pair
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define pb push_back
#define sec second
#define sz(x) ((int)x.size())
using namespace std;
struct timer{
time_t start;
timer(){start=clock();}
~timer(){cerr<<1.*(clock()-start)/CLOCKS_PER_SEC<<" secs"<<endl;}
};
typedef istringstream iss;
typedef long long ll;
typedef pair<int,int> pi;
typedef stringstream sst;
typedef vector<int> vi;
int N,Q,c[300010],ans[300010];
int p[601];
int main(){
cin.tie(0);
ios_base::sync_with_stdio(0);
cin>>N>>Q;
rep(i,N)cin>>c[i];
sort(c,c+N);
fill(p+1,p+601,N-1);
for(int i=300000;i>=601;i--){
rep2(j,1,601){
while(p[j]>=0 && c[p[j]] >= i*j) p[j]--;
if(p[j]>=0) ans[i]=max(ans[i],c[p[j]]-i*(j-1));
}
}
rep2(i,1,601){
rep(j,N)ans[i]=max(ans[i],c[j]%i);
}
rep(i,Q){
int q;
cin>>q;
cout<<ans[q]<<endl;
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
srand(time(0));
int t;
cin >> t;
while (t--) {
int n, ans = -1;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
for (int i = 1; i < 1024; i++) {
vector<int> t(n);
for (int j = 0; j < n; j++) {
t[j] = v[j] ^ i;
}
sort(t.begin(), t.end());
if (t == v) {
ans = i;
break;
}
}
cout << ans << "\n";
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a, b, n;
cin >> t;
while (t--) {
cin >> a >> b >> n;
if (n % 3 == 0) {
cout << a;
} else if (n % 3 == 1) {
cout << b;
} else
cout << (a ^ b);
cout << "\n";
}
return 0;
}
| 7 | CPP |
a = [0 for i in range(100)]
b = [0 for i in range(100)]
for i in range(1, 100):
a[i] = a[i - 1] * 2 + 1
b[i] = b[i - 1] + a[i]
def calc(x):
return (4 ** x - 1) // 3
for i in range(int(input())):
n, k = map(int, input().split())
if n > 35:
print("YES " + str(n - 1))
elif 1 + calc(n - 1) >= k:
print("YES " + str(n - 1))
elif calc(n) < k:
print("NO")
else:
for i in range(1, (n + 1)):
if b[i] <= k and k <= calc(n) - (2 ** (i + 1) - 1) * calc(n - i):
print("YES " + str(n - i))
break
else:
print("NO") | 10 | PYTHON3 |
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().strip().split(" "))
def msi(): return map(str,input().strip().split(" "))
def li(): return list(mi())
def gcd(x, y):
while y:
x, y = y, x % y
return x
for _ in range(ii()):
n=ii()
a=li()
f=[0]*(n+5)
a.sort(reverse=True)
ans=[a[0]]
f[0]=1
g=a[0]
while len(ans)!=n:
mx=0
pos=-1
for i in range(n):
if f[i]==0:
if gcd(g,a[i])>mx:
mx=gcd(g,a[i])
pos=i
if pos==-1:
print('Adding this if statement its getting accepted')
f[pos]=1
ans.append(a[pos])
g=gcd(g,a[pos])
print(*ans) | 8 | PYTHON3 |
# B
n = int(input())
ls=[]
for i in range(n):
ls.append(list(map(int,input().split())))
ls = list(reversed(ls))
#print(ls)
for i in range(n):
if ( not i and ls[0][0] < ls[0][1] ) : ls[0][0],ls[0][1] = ls[0][1] , ls[0][0]
elif not i : continue
elif ls[i-1][1]<= min(ls[i][0],ls[i][1]):
if ls[i][0] < ls[i][1] : ls[i][0],ls[i][1] = ls[i][1] , ls[i][0]
elif ls[i-1][1]<= max(ls[i][0],ls[i][1]):
if ls[i][0] > ls[i][1]: ls[i][0], ls[i][1] = ls[i][1], ls[i][0]
else:
print("NO")
exit()
print("YES") | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
int tc;
cin >> tc;
while (tc--) {
int ss[26] = {0}, tt[26] = {0};
cin >> s >> t;
for (int i = 0; s[i]; i++) {
ss[s[i] - 'a']++;
}
for (int i = 0; t[i]; i++) {
tt[t[i] - 'a']++;
}
bool is_true = false;
for (int i = 0; i < 26; i++) {
if (ss[i] > 0 && tt[i] > 0) is_true = true;
}
if (is_true)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 8 | CPP |
# Problem URL: https://codeforces.com/contest/1335/problem/0
t = int(input())
for _ in range(t):
n = int(input())
print((n - 1) // 2) | 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
long long int n,m,ans[100010],i,x,a,b;
vector<long long int> adj[100010];
bool vis[100010];
queue<long long int> q;
signed main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin>>n>>m;
for (i=1;i<m+1;i++)
{
cin>>a>>b;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (i=2;i<n+1;i++) vis[i]=false;vis[1]=true;
q.push(1);
while (!q.empty())
{
a=q.front();q.pop();
for (auto u:adj[a])
{
if (vis[u]) continue;
vis[u]=true;ans[u]=a;
q.push(u);
}
}
cout<<"Yes"<<"\n";
for (i=2;i<n+1;i++) cout<<ans[i]<<"\n";
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, M;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
vector<vector<long long>> Map(N + 5);
vector<long long> R(N + 5, 0), C(M + 5, 0);
long long Ai;
for (int i = 0; i <= N - 1; i++)
for (int j = 0; j <= M - 1; j++) {
cin >> Ai;
Map[i].push_back(Ai);
R[i] += Ai;
C[j] += Ai;
}
long long ans = 0;
priority_queue<long long> PQ;
for (int i = 0; i <= N - 1; i++) PQ.push(R[i]);
long long tmp = 0;
for (int i = 0; i <= 3; i++) {
if (PQ.empty()) break;
tmp += PQ.top();
PQ.pop();
}
ans = max(ans, tmp);
PQ = priority_queue<long long>();
for (int i = 0; i <= M - 1; i++) PQ.push(C[i]);
tmp = 0;
for (int i = 0; i <= 3; i++) {
if (PQ.empty()) break;
tmp += PQ.top();
PQ.pop();
}
ans = max(ans, tmp);
for (int i = 0; i <= N - 1; i++) {
priority_queue<long long> PQ;
for (int j = 0; j <= M - 1; j++) PQ.push(C[j] - Map[i][j]);
tmp = R[i];
for (int j = 0; j <= 2; j++) {
if (PQ.empty()) break;
tmp += PQ.top();
PQ.pop();
}
ans = max(ans, tmp);
}
for (int i = 0; i <= M - 1; i++) {
priority_queue<long long> PQ;
for (int j = 0; j <= N - 1; j++) PQ.push(R[j] - Map[j][i]);
tmp = C[i];
for (int j = 0; j <= 2; j++) {
if (PQ.empty()) break;
tmp += PQ.top();
PQ.pop();
}
ans = max(ans, tmp);
}
if (M < N) {
vector<vector<long long>> Max(M + 5, vector<long long>(M + 5));
for (int j = 0; j <= M - 2; j++)
for (int k = j + 1; k <= M - 1; k++) {
Max[j][k] = R[0] + C[j] + C[k] - Map[0][j] - Map[0][k];
}
for (int i = 1; i <= N - 1; i++) {
long long sm = 0;
for (int j = 0; j <= M - 2; j++)
for (int k = j + 1; k <= M - 1; k++)
sm = max(sm, Max[j][k] - Map[i][j] - Map[i][k]);
sm += R[i];
ans = max(ans, sm);
if (i != N - 1)
for (int j = 0; j <= M - 2; j++)
for (int k = j + 1; k <= M - 1; k++) {
Max[j][k] =
max(Max[j][k], R[i] + C[j] + C[k] - Map[i][j] - Map[i][k]);
}
}
} else {
vector<vector<long long>> Max(N + 5, vector<long long>(N + 5));
for (int j = 0; j <= N - 2; j++)
for (int k = j + 1; k <= N - 1; k++) {
Max[j][k] = C[0] + R[j] + R[k] - Map[j][0] - Map[k][0];
}
for (int i = 1; i <= M - 1; i++) {
long long sm = 0;
for (int j = 0; j <= N - 2; j++)
for (int k = j + 1; k <= N - 1; k++)
sm = max(sm, Max[j][k] - Map[j][i] - Map[k][i]);
sm += C[i];
ans = max(ans, sm);
if (i != M - 1)
for (int j = 0; j <= N - 2; j++)
for (int k = j + 1; k <= N - 1; k++) {
Max[j][k] =
max(Max[j][k], C[i] + R[j] + R[k] - Map[j][i] - Map[k][i]);
}
}
}
cout << ans << '\n';
return 0;
}
| 13 | CPP |
#include<bits/stdc++.h>
#define fo(i,a,b) for(int i=(a);i<=(b);++i)
#define rv(i,a,b) for(int i=(a);i>=(b);--i)
#define SZ(x) ((int)x.size())
using namespace std;
const int M = 420000;
typedef long long ll;
int n,m,k;
vector<int> g[M];
vector<int> p[2];
int ans[M];
void dfs(int u,int c,int f){
p[c].push_back(u);
for(int to:g[u]){
if(to==f) continue;
dfs(to,c^1,u);
}
}
int t[3];
int num(int x){
if(x==0) return t[0]--*3;
return --t[x]*3+x;
}
int num(){
if(t[1]) return num(1);
if(t[0]) return num(0);
if(t[2]) return num(2);
return -1;
}
int main(){
cin>>n;
int u,v;
fo(i,1,n-1){
cin>>u>>v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1,0,1);
int b=0,w=1;
if(SZ(p[b])>SZ(p[w]))
swap(b,w);
t[0]=n/3;t[1]=(n+2)/3;t[2]=(n+1)/3;
if(SZ(p[b])<=t[0]){
for(int val:p[b])
ans[val]=num(0);
for(int val:p[w])
ans[val]=num();
}
else{
for(int val:p[b])
ans[val]=num();
for(int val:p[w])
ans[val]=num();
}
fo(i,1,n) cout<<ans[i]<<' ';
cout<<endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
const int INF = 2147483647;
const int MOD = 1000000007;
const long long INF64 = 9223372036854775807;
const long double EPS = 1e-7;
const long double PI = acosl(-1);
using namespace std;
long double get(long double alp, int a, int cnt) {
long double l = sqrtl(a * a / (2 - 2 * cosl(alp)));
long double h = sqrtl(a * a - l * l);
long double p = (l + l + a) / 2;
long double s = sqrtl((p - l) * (p - l) * (p - a) * p) * cnt;
return s * h / 3;
}
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
printf("%.15Lf\n",
get(2 * PI / 3, a, 3) + get(2 * PI / 4, b, 4) + get(2 * PI / 5, c, 5));
}
| 24 | CPP |
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, char **argv) {
long long t, k;
cin >> t;
while (t--) {
cin >> k;
if (k & 1) {cout << -1 << endl;continue;}
k = (k - 2) >> 1;
vector<int> n(1, 1);
int p = -1;
while (k) {
if (k & 1) {
n.push_back(1);
if (p >= 0) {
n.insert(n.end(), p, 0);
n.push_back(1);
}
}
k >>= 1;
p++;
}
cout << n.size() << endl;
for (int i = 0; i < n.size(); i++) cout << (i ? " " : "") << n[i];
cout << endl;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
long long int n, w;
vector<pair<int, int>> v;
cin >> n >> w;
long long int res[n + 2];
long long int sum = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(make_pair(x, i));
sum = sum + ceil(x / 2.0);
}
sort(v.rbegin(), v.rend());
if (sum > w) {
cout << -1 << endl;
} else {
for (int i = 0; i < n; i++) {
long long int min = ceil(v[i].first / 2.0);
res[v[i].second] = min;
}
long long int diff = w - sum;
int index = 0;
while (res[v[index].second] < v[index].first && diff > 0) {
while (diff > 0 && res[v[index].second] < v[index].first) {
res[v[index].second]++;
diff--;
}
index++;
}
for (int i = 0; i < n; i++) {
cout << res[i] << " ";
}
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793238462643383279502884;
const long long PRIME1 = 1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long a[200010], b[200010];
void rev(long long *x, int n) {
for (int i = 0; i < n / 2; i++) {
swap(x[i], x[n - i - 1]);
}
}
void pref_back(long long *x, int n) {
for (int i = n - 1; i > 0; i--) {
x[i] -= x[i - 1];
}
}
bool checksort(long long *x, int n) {
bool f = 1;
int i = 0;
while (f && i < (n - 1)) {
f = x[i + 1] > x[i];
i++;
}
return f;
}
bool checksort_back(long long *x, int n) {
bool f = 1;
int i = 0;
while (f && i < (n - 1)) {
f = x[i + 1] < x[i];
i++;
}
return f;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int i;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
cin >> b[i];
}
if (n == 1) {
if (a[0] == b[0]) {
cout << "SMALL"
<< "\n"
<< 0;
} else {
cout << "IMPOSSIBLE";
}
return 0;
}
if (n == 2) {
string s0 = "";
long long count = 0;
if (!checksort(a, n) && !checksort(b, n) && a[0] == b[0] && a[1] == b[1]) {
cout << "SMALL"
<< "\n"
<< 0 << "\n";
return 0;
}
if (!checksort(b, n)) {
rev(b, n);
s0 += "R";
}
bool f1 = 0;
if (a[0] > a[1]) {
rev(a, n);
f1 = 1;
}
if (a[0] <= b[0] && a[1] <= b[1] && (gcd(a[1], a[0]) == gcd(b[1], b[0]))) {
long long g = gcd(a[1], a[0]);
a[1] /= g;
a[0] /= g;
b[0] /= g;
b[1] /= g;
while (a[0] < b[0] || a[1] < b[1]) {
if (a[0] == b[0]) {
if ((b[1] % a[0]) == (a[1] % a[0])) {
count += (b[1] - a[1]) / a[0];
if (count <= 200000) {
for (i = 0; i < ((b[1] - a[1]) / a[0]); i++) {
s0 += "P";
}
}
b[1] = a[1];
} else {
cout << "IMPOSSIBLE";
return 0;
}
} else {
count += b[1] / b[0];
if (count <= 200000) {
for (i = 0; i < (b[1] / b[0]); i++) {
s0 += "P";
}
}
b[1] %= b[0];
swap(b[1], b[0]);
s0 += "R";
}
}
if (f1) {
s0 += "R";
}
if (count > 200000) {
cout << "BIG"
<< "\n"
<< count;
} else {
reverse(s0.begin(), s0.end());
cout << "SMALL"
<< "\n"
<< s0.length() << "\n"
<< s0;
}
} else {
cout << "IMPOSSIBLE";
return 0;
}
return 0;
}
if (n > 2) {
long long count = 0;
string s0 = "";
bool f1 = 1;
for (int i = 0; i < n && f1; i++) {
f1 = a[i] == b[i];
}
if (f1) {
cout << "SMALL"
<< "\n"
<< 0 << "\n";
return 0;
}
f1 = 1;
for (int i = 0; i < n && f1; i++) {
f1 = a[i] == b[n - i - 1];
}
if (f1) {
cout << "SMALL"
<< "\n"
<< 1 << "\n"
<< "R";
return 0;
}
while (1) {
if (!checksort(b, n)) {
if (checksort_back(b, n)) {
rev(b, n);
pref_back(b, n);
count++;
if (count <= 200000) {
s0 += "RP";
}
} else {
cout << "IMPOSSIBLE";
return 0;
}
} else {
pref_back(b, n);
count++;
if (count <= 200000) {
s0 += "P";
}
}
f1 = 1;
for (int i = 0; i < n && f1; i++) {
f1 = a[i] == b[n - i - 1];
}
if (f1) {
s0 += "R";
break;
}
f1 = 1;
for (int i = 0; i < n && f1; i++) {
f1 = a[i] == b[i];
}
if (f1) {
break;
}
f1 = 1;
for (int i = 0; i < n && f1; i++) {
f1 = b[i] > 0;
}
if (!f1) {
cout << "IMPOSSIBLE";
return 0;
}
}
if (count <= 200000) {
reverse(s0.begin(), s0.end());
cout << "SMALL"
<< "\n"
<< s0.length() << "\n"
<< s0;
} else {
cout << "BIG"
<< "\n"
<< count << "\n";
}
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int sign(double x, double eps = 1e-8) { return (x < -eps ? -1 : x > eps); }
struct Point {
double x, y;
void input() {
double a, b, c, d, l;
scanf("%lf%lf%lf%lf", &a, &b, &c, &d);
x = a / b;
y = c / d;
l = x * x + y * y;
x = x / l;
y = y / l;
}
Point(double x = 0, double y = 0) : x(x), y(y) {}
bool operator<(Point const& o) const {
if (sign(o.x - x) == 0) {
return sign(o.y - y) < 0;
} else {
return sign(o.x - x) < 0;
}
}
bool operator==(Point const& o) const {
return sign(x - o.x) == 0 && sign(y - o.y) == 0;
}
Point operator+(Point const& o) const { return Point(x + o.x, y + o.y); }
Point operator-(Point const& o) const { return Point(x - o.x, y - o.y); }
Point operator*(double o) const { return Point(x * o, y * o); }
Point operator/(double o) const { return Point(x / o, y / o); }
Point init() const {
double _x = x, _y = y;
double l = sqrt(_x * _x + _y * _y);
if (_x < 0) {
_x = -_x;
_y = -_y;
}
return Point(_x / l, _y / l);
}
double angle() const { return (atan2(y, x)); }
void output() const { printf("%lf %lf\n", x, y); }
} point[1111];
struct Pair {
Point mid;
double a;
Pair() {}
Pair(Point const& mid, double a) : mid(mid), a(a) {}
bool operator<(Pair const& o) const {
if (o.mid == mid) {
return sign(o.a - a) < 0;
} else {
return o.mid < mid;
}
}
};
map<Pair, int> m;
map<Pair, int>::iterator mi, mj;
Pair makePair(Point const& a, Point const& b) {
return Pair((a + b) / 2, (a - b).angle());
}
int main() {
int n, i, j;
long long ans, sum, cnt;
while (~scanf("%d", &n)) {
m.clear();
for (i = 0; i < n; i++) {
point[i].input();
}
sort(point, point + n);
for (i = 0; i < n; i++) {
for (j = i + 1; j < n; j++) {
m[makePair(point[i], point[j])]++;
}
}
ans = 0;
for (mi = m.begin(); mi != m.end(); mi = mj) {
sum = 1, cnt = 0;
for (mj = mi; mj != m.end() && mi->first.mid == mj->first.mid; mj++) {
sum = sum * (mj->second + 1) % mod;
cnt = (cnt + mj->second) % mod;
}
ans = (ans + sum - cnt - 1) % mod;
}
printf("%lld\n", (ans + mod) % mod);
}
return 0;
}
| 11 | CPP |
s = input()
result = False
ab = s.find('AB')
ba = -1
if ab != -1:
ba = s.find('BA', ab+2)
if ba != -1:
result = True
if not result:
ba = s.find('BA')
if ba != -1:
ab = s.find('AB', ba+2)
if ab != -1:
result = True
if result:
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
n = int(input())
ar = [ord(x)-97 for x in input()]
ans = 0
flag = True
while flag:
temp = -1
ind = -1
for k in range(1,len(ar)-1):
if (ar[k] == ar[k-1]+1 or ar[k] == ar[k+1]+1) and ar[k] > temp:
ind = k
temp = ar[k]
if len(ar) > 1 and ar[0] == ar[1]+1 and ar[0] > temp:
ind = 0
temp = ar[0]
if len(ar) > 1 and ar[-1] == ar[-2]+1 and ar[-1] > temp:
ind = len(ar)-1
temp = ar[-1]
if temp != -1:
ar = ar[:ind]+ar[ind+1:]
ans += 1
else:
flag = False
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > e;
vector<pair<int, int> > ans;
vector<bool> g;
void dfs(int v) {
if (g[v]) return;
g[v] = 1;
for (int i = 0; i < e[v].size(); i++) dfs(e[v][i]);
}
int main() {
int n, m, v;
cin >> n >> m >> v;
v--;
int tg = (v == n - 1 ? 0 : n - 1);
e.resize(n);
for (int i = 0; (m) && (i < n); i++)
if (v != i) {
e[v].push_back(i);
e[i].push_back(v);
ans.push_back(make_pair(v, i));
m--;
}
for (int i = 0; (m) && (i < n); i++) {
if (i == v) continue;
if (i == tg) continue;
for (int j = i + 1; (m) && (j < n); j++)
if (v != j && j != tg) {
e[i].push_back(j);
e[j].push_back(i);
ans.push_back(make_pair(i, j));
m--;
}
}
g.resize(n, false);
dfs(v);
for (int i = 0; i < n; i++)
if (!g[i]) {
printf("-1");
return 0;
}
if (m != 0) {
printf("-1");
return 0;
}
for (int i = 0; i < ans.size(); i++) {
printf("%d %d", ans[i].first + 1, ans[i].second + 1);
printf("\n");
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, res, cont = 0, baj = 1, alt, mid, nn, cnt1, cnt2, tt, ll;
int main() {
cin >> n;
alt = n;
while (baj <= alt) {
mid = (alt + baj) / 2;
nn = n;
cnt1 = 0;
cnt2 = 0;
tt = 0;
while (nn > 0) {
if (tt % 2 == 0) {
if (nn > mid) {
cnt1 += mid;
nn -= mid;
} else {
cnt1 += nn;
nn -= nn;
}
} else {
cnt2 = (nn / 10);
nn -= cnt2;
}
tt++;
}
if (n % 2 == 0)
ll = n / 2;
else
ll = (n / 2) + 1;
if (cnt1 >= ll) {
alt = mid - 1;
} else {
baj = mid + 1;
}
}
cout << baj << "\n";
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
int N;
int A[35];
int Log(int X) {
int Ans = 0;
if (X >> 16) {
X >>= 16;
Ans |= 16;
}
if (X >> 8) {
X >>= 8;
Ans |= 8;
}
if (X >> 4) {
X >>= 4;
Ans |= 4;
}
if (X >> 2) {
X >>= 2;
Ans |= 2;
}
if (X >> 1) {
X >>= 1;
Ans |= 1;
}
return Ans;
}
void Init() {
Get(N);
for (int i = 1; i <= N; i++) Get(A[i]);
}
vector<int> OK[105];
int F[16777225];
int Ans;
void Work() {
for (int i = 1; i <= N; i++)
for (int j = 1; j < i; j++)
for (int k = j; k < i; k++) {
if (A[j] + A[k] == A[i])
OK[i - 1].push_back((1 << (j - 1)) | (1 << (k - 1)));
}
F[1] = 1;
for (int k = 1; k < (1 << N); k++) {
if (F[k] == 0) continue;
int Pos = Log(k) + 1;
bool Yes = 0;
for (typeof(OK[Pos].begin()) i = OK[Pos].begin(); i != OK[Pos].end(); i++) {
if ((k & (*i)) == (*i)) {
Yes = 1;
break;
}
}
if (Yes == 0) continue;
F[k | (1 << Pos)] = 1;
for (int i = 0, j; i < Pos; i++) {
j = 1 << i;
F[(k & (~j)) | (1 << Pos)] = 1;
}
}
Ans = 0x2f2f2f2f;
for (int k = (1 << (N - 1)); k < (1 << N); k++) {
if (F[k] == 0) continue;
if (Ans > __builtin_popcount(k)) Ans = __builtin_popcount(k);
}
if (Ans >= 0x2f2f2f2f) Ans = -1;
}
void Output() { printf("%d\n", Ans); }
int main() {
Init();
Work();
Output();
return 0;
}
| 10 | CPP |
n = int(input())
a = list(map(int, input().split()))
a.sort()
result = 0
begin = 0
end = 0
while end != n:
while a[end] - a[begin] > 5:
begin += 1
result = max(result, end - begin + 1)
if a[end] - a[begin] <= 5:
end += 1
print(result) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template<typename T>
void out(T x) { cout << x << endl; exit(0); }
#define watch(x) cout << (#x) << " is " << (x) << endl
const int maxn = 4e5 + 5;
int n,cnt[105],dp[105];
int main() {
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin>>n;
for (int i=2; i<=n; i++) {
int x = i;
for (int j=2; x>1; j++) {
while (x%j == 0) {
cnt[j]++;
x=x/j;
}
}
}
dp[1]=1;
for (int i=100; i>=1; i--) {
if (cnt[i]>0) {
for (int j=75; j>=1; j--) {
for (int x=1; x<=cnt[i]; x++) {
if ((x+1)*j <= 75) {
dp[(x+1)*j] += dp[j];
}
}
}
}
}
cout<<dp[75]<<endl;
return 0;
}
| 0 | CPP |
# -*- coding: utf-8 -*-
"""
Created on Mon Jul 2 21:59:21 2018
@author: Duy SoCiu
"""
lst = input().split()
lst = list(map(lambda x: int(x), lst))
#print(lst)
#for i in range(n):
lst2 = input().split()
lst2 = list(map(lambda x: int(x), lst2))
#print(lst2)
#print(lst2)
#print(a_sort)
#print('k-1',lst2[lst[1]-1])
z=lst2[lst[1]-1]
lst2.reverse()
tem=lst2.index(z)
#print('k',tem)
tem2=0
for i in range(tem,lst[0]):
if(lst2[i]>0):
tem2+=1;
print(tem2)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (islower(s[0])) s[0] = toupper(s[0]);
cout << s;
}
| 7 | CPP |
coins=[100,20,10,5,1]
n=int(input())
cnt=0
i=0
for c in coins:
tmp=n//c
cnt+=tmp
n-=c*tmp
print(cnt) | 7 | PYTHON3 |
n,x=map(int,input().split())
a=[0]*(n+1)
a[0]=1
p=[0]*(n+1)
p[0]=1
for i in range(n):
a[i+1]=2*a[i]+3
p[i+1]=2*p[i]+1
def f(n,x):
if x==a[n]:
return p[n]
elif x==0:
return 0
elif x<=1+a[n-1]:
return f(n-1,x-1)
elif x>=2+a[n-1]:
return p[n-1]+1+f(n-1,x-2-a[n-1])
print(f(n,x))
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
int solve()
{
int n;
cin >>n;
int ct[3]={};
rep(i,n)
{
int a;
cin >>a;
++ct[a%3];
}
int x=ct[1], y=ct[2];
if(x>y) swap(x,y);
if(y==0) return 1;
int ret = 1+ct[0];
--y;
int k = min(x,y);
ret += 2*k;
x-=k;
y-=k;
if(y>=2) ret+=2;
else ret+=(x>0 || y>0);
return ret;
}
int main()
{
cout << solve() << endl;
return 0;
} | 0 | CPP |
from collections import Counter
from collections import defaultdict
import math
import random
import heapq as hq
from math import sqrt
import sys
from functools import reduce
def input():
return sys.stdin.readline().strip()
def iinput():
return int(input())
def tinput():
return input().split()
def rinput():
return map(int, tinput())
def rlinput():
return list(rinput())
mod = int(1e9)+7
def factors(n):
return set(reduce(list.__add__,
([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))
# ----------------------------------------------------
if __name__ == "__main__":
for _ in range(iinput()):
n=iinput()
a=rlinput()
# kadane algo
dp=[a[i] for i in range(n)]
start=[0 for i in range(n)]
mx=dp[0]
for i in range(1,n):
if dp[i-1]+a[i]>a[i]:
dp[i]=dp[i-1]+a[i]
start[i]=start[i-1]
else:
start[i]=i
mx=max(dp)
end=dp.index(mx)
start=start[end]
if start==0 and end==n-1:
dp.remove(mx)
if max(dp)<sum(a):
print('YES')
else:
print('YES')
else:
if mx<sum(a):
print('YES')
else:
print('NO')
| 8 | PYTHON3 |
#include <bits/stdc++.h>
double a[100001], b[100001];
int main() {
int i, j, k;
int n;
double p, q;
scanf("%d%lf%lf", &n, &p, &q);
for (i = 0; i < n; i++) {
scanf("%lf%lf", &a[i], &b[i]);
a[i] /= p;
b[i] /= q;
}
double min = 0, max = 1e18;
int tt = 500;
while (tt--) {
double mid = (min + max) / 2;
bool okp = false, okq = false, okr = false, okpq = false;
for (i = 0; i < n; i++) {
if (a[i] > mid && b[i] > mid) okr = true;
if (a[i] > mid) okp = true;
if (b[i] > mid) okq = true;
}
if (!okr && okp && okq) {
double bp = 1, bq = 1;
for (i = 0; i < n; i++) {
if (a[i] > mid) {
double t = 1 + (a[i] - mid) / (mid - b[i]);
if (bp < t) bp = t;
}
if (b[i] > mid) {
double t = 1 + (b[i] - mid) / (mid - a[i]);
if (bq < t) bq = t;
}
}
if ((bq - 1) * (bp - 1) >= 1 * 1) okpq = 1;
}
if (okr || okpq) {
min = mid;
} else {
max = mid;
}
}
printf("%.18f\n", 1.0 / min);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MM = 1010101, MN = 101010;
bool good[MM];
int mini[MM];
int dist[MM];
int main() {
int n, x, y, i;
scanf("%d", &n);
for (i = 0; i < n; ++i) {
scanf("%d %d", &x, &y);
good[x] = true;
mini[x] = 1;
dist[x] = y;
}
for (i = 0; i < MM; ++i) {
if (!good[x]) {
if (i) mini[i] = mini[i - 1];
} else {
if (i - dist[i] - 1 >= 0) mini[i] += mini[i - dist[i] - 1];
}
}
int ans = MN;
for (i = 0; i < MM; ++i) ans = min(ans, n - mini[i]);
printf("%d\n", ans);
return 0;
}
| 9 | CPP |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
int n, a, b[10], c[10][10], ans;
string s;
int main(){
cin >> n >> s;
for(char t: s){
int d = t - '0';
rep(i,10) c[d][i] = b[i];
b[d] = a;
a |= 1<<d;
}
rep(i,10) rep(j,10) rep(k,10) if(c[i][j]>>k&1) ans++;
printf("%d\n", ans);
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T& x) {
int f = 0, c = getchar();
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + c - 48, c = getchar();
if (f) x = -x;
}
template <typename T, typename... Args>
inline void read(T& x, Args&... args) {
read(x);
read(args...);
}
template <typename T>
void write(T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
void writes(T x) {
write(x);
putchar(' ');
}
template <typename T>
void writeln(T x) {
write(x);
puts("");
}
template <typename T>
inline bool chkmin(T& x, const T& y) {
return y < x ? (x = y, true) : false;
}
template <typename T>
inline bool chkmax(T& x, const T& y) {
return x < y ? (x = y, true) : false;
}
const int maxn = (int)3e5 + 10;
const long long inf = (long long)1e18;
const int mod = (int)1e9 + 7;
int n, a[55][55], dp[55][55][55][55];
char ch;
int dfs(int x1, int y1, int x2, int y2) {
if (x1 > x2 || y1 > y2) return 0;
if (~dp[x1][y1][x2][y2]) return dp[x1][y1][x2][y2];
if (x1 == x2 && y1 == y2) return a[x1][y1];
int res = max(x2 - x1 + 1, y2 - y1 + 1);
for (int i = (x1); i < (x2); i++) {
res = min(res, dfs(x1, y1, i, y2) + dfs(i + 1, y1, x2, y2));
}
for (int i = (y1); i < (y2); i++) {
res = min(res, dfs(x1, y1, x2, i) + dfs(x1, i + 1, x2, y2));
}
return dp[x1][y1][x2][y2] = res;
}
int main() {
read(n);
for (int i = (1); i < (n + 1); i++) {
for (int j = (1); j < (n + 1); j++) {
cin >> ch;
a[i][j] = (ch == '#');
}
}
memset(dp, -1, sizeof dp);
writeln(dfs(1, 1, n, n));
}
| 12 | CPP |
n, m = map(int, input().split())
a = []
for i in range(n):
a.append(input().split())
del a[i][0]
# print(a)
for i in range(1, n):
a[0] += a[i]
l = []
l = a[0]
l = list(set(l))
l.sort()
# print(l)
if(len(l) == m):
print('YES')
else: print('NO') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int N, s, t;
int a[100000 + 5], visted[100000 + 5];
int main() {
int cnt = 0;
scanf("%d %d %d", &N, &s, &t);
for (int i = 1; i <= N; i++) {
scanf("%d", &a[i]);
}
while (s != t && !visted[s]) {
cnt++;
visted[s] = 1;
s = a[s];
}
if (s != t) {
cout << -1 << endl;
} else {
cout << cnt << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx2,fma")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
int n, q, P[300005][19], p[300005], timer, in[300005], out[300005];
int mod = 1000000009, lvl[300005];
long long hr[300005], hv[300005], hash1, pw[300005], paw[300005], ans1, xar, z;
int aa[300005];
vector<int> v[300005];
int x, y, a, b, c, d, ans[1000005], p1, p2;
int ka[1000005], kb[1000005], kc[1000005], kd[1000005], kp1[1000005],
kp2[1000005];
vector<pair<int, int> > g[300005];
int w[300005], sz;
int pro[2000005], raod = 0;
int l[1000005], r[1000005], mid[1000005];
string second;
inline int po(int a, int b) {
ans1 = 1;
xar = a;
while (b > 0) {
if (b % 2 == 1) ans1 = (ans1 * xar) % mod;
b >>= 1;
xar = (xar * xar) % mod;
}
return ans1;
}
inline void dfs(int x, int par) {
P[x][0] = par;
p[x] = par;
for (int i = 1; i <= 18; i++) P[x][i] = P[P[x][i - 1]][i - 1];
timer++;
in[x] = timer;
for (int i = 0; i < v[x].size(); i++)
if (v[x][i] != par) {
lvl[v[x][i]] = lvl[x] + 1;
dfs(v[x][i], x);
}
out[x] = timer;
}
inline int lca(int a, int b) {
if (lvl[a] > lvl[b]) swap(a, b);
if (in[a] <= in[b] && out[b] <= out[a]) return a;
for (int i = 18; i >= 0; i--)
if (P[a][i])
if (!(in[P[a][i]] <= in[b] && out[b] <= out[P[a][i]])) a = P[a][i];
return P[a][0];
}
inline void has(int x, int par, int dep) {
hr[x] = hr[par] * 1013 + aa[x];
hr[x] %= mod;
hv[x] = pw[dep] * aa[x] + hv[par];
hv[x] %= mod;
for (int i = 0; i < v[x].size(); i++) {
if (v[x][i] != par) {
has(v[x][i], x, dep + 1);
}
}
}
inline void whatcheck1(int x) {
if (-lvl[p1] + lvl[a] + 1 >= x) {
raod++;
g[a].push_back(make_pair(lvl[a] - x, raod));
} else {
z = x - (lvl[a] - lvl[p1]);
z += lvl[p1] - 1;
raod++;
g[b].push_back(make_pair(z, raod));
}
}
inline void whatcheck2(int x) {
if (-lvl[p2] + lvl[c] + 1 >= x) {
raod++;
g[c].push_back(make_pair(lvl[c] - x, raod));
} else {
z = x - (lvl[c] - lvl[p2]);
z += lvl[p2] - 1;
raod++;
g[d].push_back(make_pair(z, raod));
}
}
inline int check1(int x) {
hash1 = 0;
if (-lvl[p1] + lvl[a] + 1 >= x) {
raod++;
z = pro[raod];
hash1 = hv[a] - hv[z] + mod;
if (hash1 > mod) hash1 -= mod;
hash1 = hash1 * paw[lvl[z]];
hash1 %= mod;
} else {
hash1 = hv[a] - hv[p1] + mod;
if (hash1 > mod) hash1 -= mod;
z = x - (lvl[a] - lvl[p1]);
hash1 = (hash1 * paw[lvl[p1]]) % mod * pw[z] % mod;
raod++;
z = pro[raod];
z = hr[z] - pw[lvl[z] - lvl[p1] + 1] * hr[p[p1]];
z %= mod;
z += mod;
if (z > mod) z -= mod;
hash1 += z;
if (hash1 > mod) hash1 -= mod;
}
return hash1;
}
inline int check2(int x) {
hash1 = 0;
if (-lvl[p2] + lvl[c] + 1 >= x) {
raod++;
z = pro[raod];
hash1 = hv[c] - hv[z] + mod;
if (hash1 > mod) hash1 -= mod;
hash1 = hash1 * paw[lvl[z]];
hash1 %= mod;
} else {
hash1 = hv[c] - hv[p2] + mod;
if (hash1 > mod) hash1 -= mod;
z = x - (lvl[c] - lvl[p2]);
hash1 = (hash1 * paw[lvl[p2]]) % mod * pw[z] % mod;
raod++;
z = pro[raod];
z = hr[z] - pw[lvl[z] - lvl[p2] + 1] * hr[p[p2]];
z %= mod;
z += mod;
if (z > mod) z -= mod;
hash1 += z;
if (hash1 > mod) hash1 -= mod;
}
return hash1;
}
inline void findall(int x, int par) {
w[sz] = x;
sz++;
for (int i = 0; i < g[x].size(); i++) {
if (g[x][i].first > 0)
pro[g[x][i].second] = w[g[x][i].first - 1];
else
pro[g[x][i].second] = 0;
}
for (int i = 0; i < v[x].size(); i++) {
if (v[x][i] != par) {
findall(v[x][i], x);
}
}
sz--;
}
int read() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x;
}
int main() {
scanf("%d", &n);
cin >> second;
for (int i = 1; i < n; i++) {
x = read();
y = read();
v[x].push_back(y);
v[y].push_back(x);
}
cin >> q;
for (int i = 1; i <= n; i++) {
aa[i] = (second[i - 1] - 'a') + 1;
}
lvl[1] = 1;
dfs(1, 0);
pw[0] = 1;
paw[0] = 1;
for (int i = 1; i <= 300000; i++) {
pw[i] = pw[i - 1] * 1013;
pw[i] %= mod;
paw[i] = po(pw[i], mod - 2);
}
has(1, 0, 0);
for (int i = 1; i <= q; i++) {
ka[i] = read();
kb[i] = read();
kc[i] = read();
kd[i] = read();
kp1[i] = lca(ka[i], kb[i]);
kp2[i] = lca(kc[i], kd[i]);
l[i] = 0;
r[i] = lvl[ka[i]] + lvl[kb[i]] - 2 * lvl[kp1[i]] + 1;
r[i] = min(r[i], lvl[kc[i]] + lvl[kd[i]] - 2 * lvl[kp2[i]] + 1);
}
for (int uu = 0; uu <= 18; uu++) {
raod = 0;
for (int i = 1; i <= n; i++) g[i].clear();
for (int i = 1; i <= q; i++) {
if (l[i] > r[i]) continue;
mid[i] = (l[i] + r[i]) >> 1;
a = ka[i];
b = kb[i];
c = kc[i];
d = kd[i];
p1 = kp1[i];
p2 = kp2[i];
whatcheck1(mid[i]);
whatcheck2(mid[i]);
}
findall(1, 1);
raod = 0;
for (int i = 1; i <= q; i++) {
if (l[i] > r[i]) continue;
a = ka[i];
b = kb[i];
c = kc[i];
d = kd[i];
p1 = kp1[i];
p2 = kp2[i];
if (check1(mid[i]) == check2(mid[i])) {
l[i] = mid[i] + 1;
ans[i] = mid[i];
} else {
r[i] = mid[i] - 1;
}
}
}
for (int i = 1; i <= q; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 11 | CPP |
# import sys
# sys.stdin = open("#input.txt", "r")
n = int(input())
st = input()*2
print(max(map(len,st.replace(' ','').split('0')))) | 8 | PYTHON3 |
t = int(input())
for q in range(t):
n = int(input())
arr = input().split()
new = [int(arr[i]) for i in range(n)]
x = 0
for i in range(n-1):
if new[i] != new[i+1]:
x = 1
if x == 1:
print(1)
else:
print(n) | 7 | PYTHON3 |
n,m=map(int,input().split());print((min(2*n,m)+m)//4) | 0 | PYTHON3 |
a = str(input())
s = list(a)
a = []
for i in range (0,len(s),2):
a.append(s[i])
x = sorted(a)
m = list("+".join(x))
print(''.join(m)) | 7 | PYTHON3 |
a, b = map(int, input().split())
answer = a
while a >= b:
answer += a // b
a = a % b + a // b
print(answer) | 7 | PYTHON3 |
from itertools import combinations
from sys import stdin
def main():
input = lambda: stdin.readline()[:-1]
T = int(input())
for _ in [0] * T:
N = int(input())
if N < 31:
print("NO")
continue
n = [6, 10, 14, 15, 21, 22, 26, 33]
for n1, n2, n3 in combinations(n, 3):
n4 = N - n1 - n2 - n3
if n4 > 0 and n4 not in n:
print("YES")
print(n1, n2, n3, n4)
break
main()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
int dist[10005][1005];
vector<int> d;
int n, m, g, r;
int main() {
memset(dist, 0x7f, sizeof dist);
scanf("%d%d", &n, &m);
d.assign(m, 0);
for (int i = 0; i < m; ++i) scanf("%d", &d[i]);
sort(d.begin(), d.end());
d.resize(unique(d.begin(), d.end()) - d.begin());
if (d[0] != 0) d.insert(d.begin(), 0);
if (d.back() != n) d.push_back(n);
m = d.size();
scanf("%d%d", &g, &r);
int ans = INF;
deque<pair<int, int> > dq;
dist[0][g] = 0;
dq.push_back(pair<int, int>(0, g));
while (dq.size()) {
int pos = dq.front().first, green = dq.front().second;
dq.pop_front();
if (pos == m - 1) {
ans = min(ans, dist[pos][green] * (g + r) + (g - green));
} else if (green == 0) {
if (dist[pos][g] > dist[pos][0] + 1) {
dist[pos][g] = dist[pos][0] + 1;
dq.push_back(pair<int, int>(pos, g));
}
} else {
if (pos > 0) {
if (green >= d[pos] - d[pos - 1] &&
dist[pos - 1][green - d[pos] + d[pos - 1]] > dist[pos][green]) {
dist[pos - 1][green - d[pos] + d[pos - 1]] = dist[pos][green];
dq.push_front(pair<int, int>(pos - 1, green - d[pos] + d[pos - 1]));
}
}
if (green >= d[pos + 1] - d[pos] &&
dist[pos + 1][green - d[pos + 1] + d[pos]] > dist[pos][green]) {
dist[pos + 1][green - d[pos + 1] + d[pos]] = dist[pos][green];
dq.push_front(pair<int, int>(pos + 1, green - d[pos + 1] + d[pos]));
}
}
}
printf("%d\n", ans >= INF ? -1 : ans);
}
| 9 | CPP |
Subsets and Splits