_id
stringlengths 2
5
| partition
stringclasses 2
values | text
stringlengths 5
289k
| language
stringclasses 1
value | meta_information
dict | title
stringclasses 1
value |
|---|---|---|---|---|---|
d2101 | train | n = int(input())
l = list(map(int, input().split()))
stack = []
for v in l:
currVal = v
currSize = 1
div = v
while stack:
nex, nexS, nDiv = stack[-1]
if div < nDiv:
currSize += nexS
currVal += nex
stack.pop()
div = currVal / currSize
else:
break
stack.append((currVal, currSize, div))
out = []
for a, b, d in stack:
thingy = str(d)
for _ in range(b):
out.append(thingy)
print('\n'.join(out))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1299/C"
} | |
d2102 | train | import sys
input = lambda: sys.stdin.readline().rstrip()
N, M = list(map(int, input().split()))
D = [{} for _ in range(N)]
for _ in range(M):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
D[a][b] = 1
D[b][a] = 1
L = [i-1 for i in range(N)]
R = [i+1 for i in range(N)]
F = [0] * N
for i in range(N):
if F[i]: continue
f = 1
while f:
f = 0
j = R[i]
while j < N:
if j in D[i]:
j = R[j]
continue
F[j] = 1
A = [a for a in D[i] if a not in D[j]]
if A: f = 1
for a in A:
if a in D[i]: del D[i][a]
if i in D[a]: del D[a][i]
A = [a for a in D[j] if a not in D[i]]
if A: f = 1
for a in A:
if a in D[j]: del D[j][a]
if j in D[a]: del D[a][j]
if R[j] < N: L[R[j]] = L[j]
if L[j] >= 0: R[L[j]] = R[j]
j = R[j]
print(N - sum(F) - 1)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1242/B"
} | |
d2103 | train | k = int(input())
p = [['0'] * 100 for j in range(100)]
g = lambda n: n * (n * n - 1) // 6
i = n = 0
while g(n + 1) <= k: n += 1
while i < n + 1:
for j in range(i): p[i][j] = p[j][i] = '1'
i += 1
k -= g(n)
g = lambda n: n * n - n >> 1
while k:
n = 0
while g(n + 1) <= k: n += 1
for j in range(n): p[i][j] = p[j][i] = '1'
k -= g(n)
i += 1
print(i)
for j in range(i): print(''.join(p[j][:i])) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/232/A"
} | |
d2104 | train | #!/usr/bin/env python
# 556D_fug.py - Codeforces.com 556D Fug quiz
#
# Copyright (C) 2015 Sergey
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Input
The first line contains integers n and m - the number of islands and bridges.
Next n lines each contain two integers li and ri - the coordinates of the
island endpoints.
The last line contains m integer numbers a1..am - the lengths of the bridges
that Andrewid got.
Output
If it is impossible to place a bridge between each pair of adjacent islands
in the required manner, print on a single line "No" (without the quotes)
, otherwise print in the first line "Yes" (without the quotes), and in the
second line print n-1 numbers b1, bn-1, which mean that between islands
i and i+1 there must be used a bridge number bi.
If there are multiple correct answers, print any of them. Note that in this
problem it is necessary to print "Yes" and "No" in correct case
"""
# Standard libraries
import unittest
import sys
import re
# Additional libraries
import heapq
###############################################################################
# Fug Class
###############################################################################
class Fug:
""" Fug representation """
def __init__(self, args):
""" Default constructor """
self.list = args[0]
self.alist = args[1]
self.gn = len(self.list) - 1
# Sorted list of bridges
self.asrt = sorted((n, i) for i, n in enumerate(self.alist))
# List of gaps between islands
self.gaps = [()]*self.gn
prevli = self.list[0]
for i in range(self.gn):
li = self.list[i+1]
min = li[0] - prevli[1]
max = li[1] - prevli[0]
self.gaps[i] = (min, max, i)
prevli = li
# Sorted list of gaps between islands
self.gsrt = sorted(self.gaps)
self.gmin = [n[0] for n in self.gsrt]
self.result = [None]*self.gn
self.heap = []
def iterate(self):
j = 0
for (b, i) in self.asrt:
# Traverse gmin array
while j < self.gn and self.gmin[j] <= b:
it = self.gsrt[j]
heapq.heappush(self.heap, (it[1], it[0], it[2]))
j += 1
# Update result and remove the element from lists
if self.heap:
(mmax, mmin, mi) = self.heap[0]
if mmin <= b and mmax >= b:
self.result[mi] = i + 1
heapq.heappop(self.heap)
yield
def calculate(self):
""" Main calcualtion function of the class """
for it in self.iterate():
pass
answer = ""
for (i, n) in enumerate(self.result):
if n is None:
return "No"
answer += (" " if i > 0 else "") + str(n)
return "Yes\n" + answer
###############################################################################
# Executable code
###############################################################################
def get_inputs(test_inputs=None):
it = iter(test_inputs.split("\n")) if test_inputs else None
def uinput():
""" Unit-testable input function wrapper """
if it:
return next(it)
else:
return input()
# Getting string inputs. Place all uinput() calls here
num = [int(s) for s in uinput().split()]
list = [[int(s) for s in uinput().split()] for i in range(num[0])]
alist = [int(s) for s in uinput().split()]
# Decoding inputs into a list
inputs = [list, alist]
return inputs
def calculate(test_inputs=None):
""" Base class calculate method wrapper """
return Fug(get_inputs(test_inputs)).calculate()
###############################################################################
# Unit Tests
###############################################################################
class unitTests(unittest.TestCase):
def test_sample_tests(self):
""" Quiz sample tests. Add \n to separate lines """
# Sample test 1
test = "4 4\n1 4\n7 8\n9 10\n12 14\n4 5 3 8"
self.assertEqual(calculate(test), "Yes\n2 3 1")
self.assertEqual(
get_inputs(test),
[[[1, 4], [7, 8], [9, 10], [12, 14]], [4, 5, 3, 8]])
# My tests
test = "5 5\n1 1\n2 7\n8 8\n10 10\n16 16\n1 1 5 6 2"
self.assertEqual(calculate(test), "Yes\n1 2 5 4")
# Other tests
test = "2 2\n11 14\n17 18\n2 9"
self.assertEqual(calculate(test), "No")
# Other tests
test = (
"2 1\n1 1\n1000000000000000000 1000000000000000000" +
"\n999999999999999999")
self.assertEqual(calculate(test), "Yes\n1")
test = ("5 9\n1 2\n3 3\n5 7\n11 13\n14 20\n2 3 4 10 6 2 6 9 5")
self.assertEqual(calculate(test), "Yes\n1 6 3 2")
size = 100000
test = str(size) + " " + str(size) + "\n"
x = size*1000
for i in range(size):
x += 2
test += str(x) + " " + str(x+1) + "\n"
for i in range(size):
test += str(2) + " "
self.assertEqual(calculate(test)[0], "Y")
def test_Fug_class__basic_functions(self):
""" Fug class basic functions testing """
# Constructor test
d = Fug([[[1, 5], [7, 8], [9, 10], [12, 14]], [4, 5, 3, 8]])
self.assertEqual(d.list[0][0], 1)
self.assertEqual(d.alist[0], 4)
# Sort bridges
self.assertEqual(d.asrt[0], (3, 2))
# Sort Gaps
self.assertEqual(d.gaps[0], (2, 7, 0))
self.assertEqual(d.gsrt[0], (1, 3, 1))
iter = d.iterate()
next(iter)
self.assertEqual(d.gmin, [1, 2, 2])
self.assertEqual(d.heap, [(5, 2, 2), (7, 2, 0)])
def __starting_point():
# Avoiding recursion limitaions
sys.setrecursionlimit(100000)
if sys.argv[-1] == "-ut":
unittest.main(argv=[" "])
# Print the result string
print(calculate())
__starting_point() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/555/B"
} | |
d2105 | train | #
import collections, atexit, math, sys
from functools import cmp_to_key
#key=cmp_to_key(lambda x,y: 1 if x not in y else -1 )
sys.setrecursionlimit(1000000)
def getIntList():
return list(map(int, input().split()))
import bisect
try :
#raise ModuleNotFoundError
import numpy
def dprint(*args, **kwargs):
print(*args, **kwargs, file=sys.stderr)
dprint('debug mode')
except ModuleNotFoundError:
def dprint(*args, **kwargs):
pass
def memo(func):
cache={}
def wrap(*args):
if args not in cache:
cache[args]=func(*args)
return cache[args]
return wrap
@memo
def comb (n,k):
if k==0: return 1
if n==k: return 1
return comb(n-1,k-1) + comb(n-1,k)
inId = 0
outId = 0
if inId>0:
dprint('use input', inId)
sys.stdin = open('input'+ str(inId) + '.txt', 'r') #标准输出重定向至文件
if outId>0:
dprint('use output', outId)
sys.stdout = open('stdout'+ str(outId) + '.txt', 'w') #标准输出重定向至文件
atexit.register(lambda :sys.stdout.close()) #idle 中不会执行 atexit
N, = getIntList()
zz = getIntList()
zz.sort()
result = (zz[N-1] - zz[0]) * (zz[2*N-1] - zz[N])
dif = zz[2*N-1] - zz[0]
for i in range(N):
nd = zz[i+N-1] - zz[i]
result = min(result, nd*dif)
print(result)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1012/A"
} | |
d2106 | train | 3
n = int(input())
a = [True] * (n + 2)
for i in range(2, n + 2):
if not a[i]:
continue
j = i * i
while j < n + 2:
a[j] = False
j += i
if n <= 2:
print(1)
else:
print(2)
print(' '.join('1' if x else '2' for x in a[2:]))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/776/B"
} | |
d2107 | train | p, n = [], int(input())
a = b = 0
for i in range(n):
t = list(map(int, input().split()))
k = t[0] // 2 + 1
a += sum(t[1: k])
if t[0] & 1:
p.append(t[k])
b += sum(t[k + 1: ])
else: b += sum(t[k: ])
p.sort(reverse = True)
print(a + sum(p[0 :: 2]), b + sum(p[1 :: 2])) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/388/C"
} | |
d2108 | train |
def main():
s = input()
l = len(s)
pretty_count = 0
for i in range(l):
left_paren_count = 0
right_paren_count = 0
wild_count = 0
for j in range(i, l):
if s[j] == '(':
left_paren_count += 1
elif s[j] == ')':
right_paren_count += 1
else:
wild_count += 1
if left_paren_count + wild_count < right_paren_count:
break
if left_paren_count < wild_count + right_paren_count:
# Should fix one '?' as '('
wild_count -= 1
left_paren_count += 1
if wild_count < 0:
break
if left_paren_count == wild_count + right_paren_count:
pretty_count += 1
print(pretty_count)
def __starting_point():
main()
__starting_point() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/917/A"
} | |
d2109 | train | import sys
s1, s2 = input().split()
n = int(input())
for _ in range(n):
print(s1, s2)
killed, new = input().split()
if s1 == killed:
s1 = new
else:
s2 = new
print(s1, s2)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/776/A"
} | |
d2110 | train | def i1():
return int(input())
def i2():
return [int(i) for i in input().split()]
q=i1()
import math
y=[]
for i in range(q):
y.append(i2())
for a,b in y:
x=a*b
c=int(math.sqrt(x))
if c**2==x:
c-=1
z=2*c
if c>0 and (x//c)==c:
z-=1
if c>0 and x%c==0 and (x//c-1)==c:
z-=1
if a<=c:
z-=1
if b<=c:
z-=1
print(z) | PYTHON | {
"starter_code": "",
"url": "https://atcoder.jp/contests/arc094/tasks/arc094_b"
} | |
d2111 | train | n = int(input())
a = [int(x) for x in input().split()]
l = [0] * (10**6 + 100)
for x in a:
l[x] += 1
cur = 0
ans = 0
for x in l:
cur += x
if cur % 2:
ans += 1
cur //= 2
print(ans)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/587/A"
} | |
d2112 | train | import itertools
import bisect
n, A, cf, cm, m = [int(x) for x in input().split()]
skills = [int(x) for x in input().split()]
sorted_skills = list(sorted((k, i) for i, k in enumerate(skills)))
bottom_lift = [0 for i in range(n)]
for i in range(1, n):
bottom_lift[i] = bottom_lift[i-1] + i * (sorted_skills[i][0] - sorted_skills[i-1][0])
root_lift = [0 for i in range(n+1)]
for i in range(1, n+1):
root_lift[i] = root_lift[i-1] + A - sorted_skills[n-i][0]
max_level = -1
for i in range(n+1):
money_left = m - root_lift[i]
if money_left < 0: break
k = min(bisect.bisect(bottom_lift, money_left), n-i)
money_left -= bottom_lift[k-1]
min_level = min(A, sorted_skills[k-1][0] + money_left//k) if k > 0 else A
level = cf*i + cm*min_level
if max_level < level:
max_level = level
argmax = i
argmax_min_level = min_level
argmax_k = k
ans = [0 for i in range(n)]
for i, skill in enumerate(sorted_skills):
if i < argmax_k:
ans[skill[1]] = argmax_min_level
elif i >= n - argmax:
ans[skill[1]] = A
else:
ans[skill[1]] = skill[0]
print(max_level)
for a in ans:
print(a, end = ' ')
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/613/B"
} | |
d2113 | train | n = int(input())
l = list(map(int, input().split()))
inv = 0
out = 0
mult = 1
for i in range(32):
curr = dict()
opp = 0
same = 0
for v in l:
if v ^ 1 in curr:
if v & 1:
opp += curr[v ^ 1]
else:
same += curr[v ^ 1]
if v not in curr:
curr[v] = 0
curr[v] += 1
for i in range(n):
l[i] >>= 1
if same <= opp:
inv += same
else:
inv += opp
out += mult
mult *= 2
print(inv, out)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1416/C"
} | |
d2114 | train | 3
import sys
class CumTree:
def __init__(self, a, b):
self.a = a
self.b = b
self.count = 0
if a == b:
return
mid = (a + b) // 2
self.levo = CumTree(a, mid)
self.desno = CumTree(mid+1, b)
def manjsi(self, t):
if self.a >= t:
return 0
if self.b < t:
return self.count
return self.levo.manjsi(t) + self.desno.manjsi(t)
def vstavi(self, t):
if self.a <= t <= self.b:
self.count += 1
if self.a == self.b:
return
self.levo.vstavi(t)
self.desno.vstavi(t)
n = int(sys.stdin.readline())
p = [int(x) for x in sys.stdin.readline().strip().split()]
ct = CumTree(1, 4096)
vsota = 0
while len(p) > 0:
x = p.pop()
vsota += ct.manjsi(x)
ct.vstavi(x)
k, d = vsota // 2, vsota % 2
print("%f" % (4*k + d))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/351/B"
} | |
d2115 | train | """
Codeforces Round 254 Div 1 Problem A
Author : chaotic_iak
Language: Python 3.3.4
"""
def read(mode=2):
# 0: String
# 1: List of strings
# 2: List of integers
inputs = input().strip()
if mode == 0:
return inputs
if mode == 1:
return inputs.split()
if mode == 2:
return [int(x) for x in inputs.split()]
def write(s="\n"):
if isinstance(s, list): s = " ".join(map(str,s))
s = str(s)
print(s, end="")
################################################### SOLUTION
n,m = read()
v = read()
best = 0
for i in range(m):
a,b,c = read()
temp = (v[a-1] + v[b-1]) / c
best = max(best, temp)
print(best) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/444/A"
} | |
d2116 | train | def Search(L,aa,x):
a=aa
b=len(L)
while(b-a>1):
i=(b+a)//2
if(L[i]>x):
b=i
elif(L[i]<x):
a=i
else:
return (i+1)-aa-1
return b-aa-1
import math
n,d=list(map(int,input().split()))
P=list(map(int,input().split()))
ans=0
for i in range(n):
x=Search(P,i,P[i]+d)
if(x>1):
ans+=((x)*(x-1))//2
print(ans)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/251/A"
} | |
d2117 | train | m = int(input())
s = input().strip()
sa = [0] * len(s)
for i in range(len(s)):
sa[i] = ord(s[i]) - ord('a')
sa = [-1] + sa + [-1]
def check_value(sa, m, threshold):
prev_ind = 0
for i in range(len(sa)):
if sa[i] <= threshold:
if i - prev_ind <= m:
prev_ind = i
else:
return False
return True
def get_indexes(sa, threshold):
seq = [i for i in range(len(sa)) if sa[i] <= threshold]
# seq = []
# for i in range(len(sa)):
# if sa[i] < threshold:
# seq[i].append(sa[i], i)
return seq
def filter_indexes(sa, seq, el, m):
new_seq = [0]
for i in range(1, len(seq) - 1):
if sa[seq[i]] != el or (sa[seq[i]] == el and seq[i+1] - new_seq[-1] > m):
new_seq.append(seq[i])
return new_seq[1:]
threshold = -1
while (not check_value(sa, m, threshold)):
# print(threshold, get_indexes(sa, threshold))
threshold += 1
# print(threshold, get_indexes(sa, threshold), sa)
seq = get_indexes(sa, threshold)
seq = filter_indexes(sa, seq, threshold, m)
s = ''.join(sorted([chr(ord('a') + sa[x]) for x in seq]))
print(s) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/724/D"
} | |
d2118 | train | def read_data():
n = int(input())
hs = list(map(int, input().split()))
return n, hs
def solve(n, hs):
left = get_left_index(n, hs)
right = get_right_index(n, hs)
vals = [[] for i in range(n)]
for h, l, r in zip(hs, left, right):
vals[r - l - 2].append(h)
min_hs = []
min_h = - float('inf')
for val in vals[::-1]:
for v in val:
min_h = max(min_h, v)
min_hs.append(min_h)
print(* min_hs[::-1])
def get_left_index(n, hs):
left = []
stack = []
for i, h in enumerate(hs):
while stack and hs[stack[-1]] >= h:
del stack[-1]
if stack:
left.append(stack[-1])
else:
left.append(-1)
stack.append(i)
return left
def get_right_index(n, hs):
hs.reverse()
tmp = get_left_index(n, hs)
hs.reverse()
tmp.reverse()
right = [n - 1 - a for a in tmp]
return right
n, hs = read_data()
solve(n, hs) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/547/B"
} | |
d2119 | train | n = int(input())
arr = [int(input()) for i in range(n)]
b = [0 for i in range(n)]
s = 0
for i in range(n):
j = int((arr[i] << 1) ** 0.5)
if j * (j + 1) > (arr[i] << 1):
j -= 1
s ^= j
if s != 0:
print('NO')
else:
print('YES')
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/768/E"
} | |
d2120 | train | __author__ = 'Think'
n=int(input())
aints=[int(i) for i in input().split()]
permutes=[int(i)-1 for i in input().split()]
results=[0]
rebuilt={}
m=0
for numby in range(n-1, 0, -1):
p=permutes[numby]
below=False
above=False
if p-1 in rebuilt:
below=True
if p+1 in rebuilt:
above=True
if above and below:
bsum, bottom=rebuilt[p-1]
asum, top=rebuilt[p+1]
new=bsum+asum+aints[p]
rebuilt[bottom]=(new, top)
rebuilt[top]=(new, bottom)
elif above or below:
if above:
other=p+1
else:
other=p-1
psum, prev=rebuilt[other]
new=psum+aints[p]
rebuilt[prev]=(new, p)
rebuilt[p]=(new, prev)
else:
new=aints[p]
rebuilt[p]=(new, p)
m=max(new, m)
results.append(m)
for numby in range(n-1, -1, -1):
print(results[numby])
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/722/C"
} | |
d2121 | train | n = int(input())
a, b = [0] * (n + 2), [0] * (n + 2)
s, l = 0, 1
p = [0] * n
for i in range(n):
t = list(map(int, input().split()))
if t[0] == 1:
b[t[1] - 1] += t[2]
s += t[1] * t[2]
elif t[0] == 2:
a[l] = t[1]
l += 1
s += t[1]
else:
l -= 1
s -= a[l] + b[l]
b[l - 1] += b[l]
b[l] = 0
p[i] = str(s / l)
print('\n'.join(p)) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/283/A"
} | |
d2122 | train | # -*- coding: utf-8 -*-
from time import perf_counter
from sys import stdin
def run(n, s):
m = 0
small = n // 2
for big in range(n-1, (n+1)//2-1, -1):
while small >= 0 and s[small] > s[big] / 2:
small -= 1
if small == -1:
break
#print(small, big)
small -= 1
m += 1
print(n-m)
def run2(n, s):
r = n - 1
l = n // 2 - 1
result = 0
while l >= 0:
if s[l] * 2 <= s[r]:
result += 1
r -= 1
l -= 1
print(n - result)
n = int(input())
s = sorted([int(x) for x in stdin.read().strip().split('\n')])
run(n, s)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/372/A"
} | |
d2123 | train | from bisect import bisect_left, insort_left
a = []
n = int(input())
for _ in range(n):
#print(a)
s, d = list(map(int, input().split()))
if len(a) == 0:
print(s, s+d - 1)
a.append((s, s + d - 1))
continue
p = bisect_left(a, (s, s + d - 1))
#print('p', p)
ok = True
if p > 0 and a[p-1][1] >= s:
ok = False
if p < len(a) and a[p][0] <= s + d - 1:
ok = False
if ok:
insort_left(a, (s, s + d - 1))
print(s, s + d - 1)
else:
ok = False
for i in range(len(a)):
if i == 0:
if a[0][0] > d:
print(1,d)
a = [(1, d)] + a
ok = True
break
else:
if a[i - 1][1] + d < a[i][0]:
print(a[i - 1][1] + 1, a[i - 1][1] + d)
insort_left(a, (a[i - 1][1] + 1, a[i - 1][1] + d))
ok = True
break
if not ok:
print(a[-1][1] + 1, a[-1][1] + d)
insort_left(a, (a[-1][1] + 1, a[-1][1] + d))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/730/G"
} | |
d2124 | train | def evens(A):
n = len(A)
l = n//2-1; r = n//2
if len(A)%2 == 1: l+= 1
ans = [max(A[l], A[r])]
while r < n-1:
l-= 1; r+= 1
ans.append(max(ans[-1], A[l], A[r]))
return ans
def interleave(A, B):
q = []
for i in range(len(B)): q+= [A[i], B[i]]
if len(A) != len(B): q.append(A[-1])
return q
n = int(input())
A = list(map(int,input().split()))
M = [min(A[i],A[i+1]) for i in range(n-1)]
ansA = evens(A)
ansM = evens(M) if n>1 else []
if n%2 == 0: print(*interleave(ansA, ansM[1:]), max(A))
else: print(*interleave(ansM, ansA[1:]), max(A)) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/794/E"
} | |
d2125 | train | from collections import defaultdict, deque
adj = defaultdict(lambda: defaultdict(lambda: 0))
def bfs(graph, inicio, destino, parent):
parent.clear()
queue = deque()
queue.append([inicio, float("Inf")])
parent[inicio] = -2
while (len(queue)):
current, flow = queue.popleft()
for i in adj[current]:
if parent[i] == -1 and graph[current][i] > 0:
parent[i] = current
flow = min(flow, graph[current][i])
if i == destino:
return flow
queue.append((i, flow))
return 0
def maxflow(graph, inicio, destino):
flow = 0
parent = defaultdict(lambda: -1)
while True:
t = bfs(graph, inicio, destino, parent)
if t:
flow += t
current = destino
while current != inicio:
prev = parent[current]
graph[prev][current] -= t
graph[current][prev] += t
current = prev
else:
break
return flow
n, m, x = [int(i) for i in input().split()]
for _ in range(m):
t = [int(i) for i in input().split()]
adj[t[0]][t[1]] = t[2]
def check(k):
meh = defaultdict(lambda: defaultdict(lambda: 0))
for i in adj:
for j in adj[i]:
ww = adj[i][j] // k
meh[i][j] = ww
flow = maxflow(meh, 1, n)
return flow
lo = 1 / x
hi = check(1)
for _ in range(70):
mid = (hi + lo) / 2
if hi-lo<0.0000000001:
break
if check(mid)>=x:
lo = mid
else:
hi = mid
print(format(lo * x, '.9f')) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/653/D"
} | |
d2126 | train | # http://codeforces.com/problemset/problem/848/B
from collections import defaultdict
def get_dest(start, w, h):
if start[0] == 1:
return (str(start[1]), str(h))
else:
return (str(w), str(start[1]))
n, w, h = [int(x) for x in input().split()]
dancers = []
groups = defaultdict(list)
destinations = [None for x in range(n)]
for ii in range(n):
g, p, t = [int(x) for x in input().split()]
dancers.append((g, p, t))
groups[p-t].append(ii)
for gg in list(groups.values()):
V, H = [], []
for ii in gg:
dancer = dancers[ii]
if dancer[0] == 1:
V.append(dancer)
else:
H.append(dancer)
V.sort(key=lambda x: -x[1])
H.sort(key=lambda x: x[1])
table = {orig: get_dest(new, w, h) for orig, new in zip(V+H, H+V)}
for ii in gg:
destinations[ii] = table[dancers[ii]]
# print(destinations)
for dd in destinations:
print(" ".join(dd))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/848/B"
} | |
d2127 | train |
def Sieve(n):
ret = []
divlis = [-1] * (n+1)
flag = [True] * (n+1)
flag[0] = False
flag[1] = False
ind = 2
while ind <= n:
if flag[ind]:
ret.append(ind)
ind2 = ind ** 2
while ind2 <= n:
flag[ind2] = False
divlis[ind2] = ind
ind2 += ind
ind += 1
return ret,divlis
sev,divlis = Sieve(210000)
n = int(input())
a = list(map(int,input().split()))
dic = {}
for i in range(n):
nd = {}
na = a[i]
while divlis[na] != -1:
if divlis[na] not in nd:
nd[divlis[na]] = 0
nd[divlis[na]] += 1
na //= divlis[na]
if na != 1:
if na not in nd:
nd[na] = 1
else:
nd[na] += 1
for x in nd:
if x not in dic:
dic[x] = []
dic[x].append(nd[x])
ans = 1
for i in dic:
if len(dic[i]) < n-1:
#print (i,"a")
continue
dic[i].sort()
if len(dic[i]) == n:
ans *= i ** dic[i][1]
#print (i,"b")
else:
ans *= i ** dic[i][0]
#print (i,"c")
print (ans)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1349/A"
} | |
d2128 | train | class DisjointSet(object):
def __init__(self, n):
self.parent = list(range(n))
self.rank = [0] * n
self.num = n # number of disjoint sets
def union(self, x, y):
self._link(self.find_set(x), self.find_set(y))
def _link(self, x, y):
if x == y:
return
self.num -= 1
if self.rank[x] > self.rank[y]:
self.parent[y] = x
else:
self.parent[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def find_set(self, x):
xp = self.parent[x]
if xp != x:
self.parent[x] = self.find_set(xp)
return self.parent[x]
def solve():
n, m = list(map(int, input().split()))
ds = DisjointSet(n * 2)
for i in range(m):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
aA = a * 2
aB = aA + 1
bA = b * 2
bB = bA + 1
if c == 0:
if ds.find_set(aA) == ds.find_set(bA):
return 0
ds.union(aA, bB)
ds.union(aB, bA)
else:
if ds.find_set(aA) == ds.find_set(bB):
return 0
ds.union(aA, bA)
ds.union(aB, bB)
return pow(2, (ds.num // 2) - 1, 10**9 + 7)
print(solve())
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/553/C"
} | |
d2129 | train | __author__ = 'Pavel Mavrin'
n = int(input())
a = [int(x) for x in input().split()]
s = 0
res = 0
for i in a:
if i == 0:
res += s
else:
s += 1
print(res)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/383/A"
} | |
d2130 | train |
import sys
#sys.stdin=open("data.txt")
input=sys.stdin.readline
mii=lambda:list(map(int,input().split()))
n,m=mii()
a=[0 for _ in range(n)]
c=[123456 for _ in range(n)]
for _ in range(m):
u,v=mii()
u%=n
v%=n
if v<u: v+=n
a[u]+=1
if c[u]>v: c[u]=v
ans=[]
for i in list(range(1,n))+[0]:
out=0
for j in range(i,n):
if not a[j]: continue
tmp=(j-i)+(a[j]-1)*n+(c[j]-j)
out=max(out,tmp)
#print(1,i,j,tmp)
for j in range(i):
if not a[j]: continue
tmp=(j+n-i)+(a[j]-1)*n+(c[j]-j)
out=max(out,tmp)
#print(2,i,j,tmp)
ans.append(out)
print(" ".join(map(str,ans)))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1129/A2"
} | |
d2131 | train | 3
import sys
from functools import lru_cache
MOD = 1000000007
cnk = [[1 for i in range(1001)] for j in range(1001)]
for i in range(1, 1001):
for j in range(1, i):
cnk[i][j] = cnk[i - 1][j - 1] + cnk[i - 1][j]
k = int(input())
cs = [int(input()) for i in range(k)]
ans = 1
sm = 0
for c in cs:
sm += c
ans = (ans * cnk[sm - 1][c - 1]) % MOD
print(ans)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/553/A"
} | |
d2132 | train | m = 1000000007
n = int(input())
a = list(map(int, input().split()))
print(pow(2,n-1,m)-1 - sum(pow(2,a.count(x),m)-1 for x in set(a) if x != -1) % m) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1025/G"
} | |
d2133 | train | import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def pe(s): return print(str(s), file=sys.stderr)
def JA(a, sep): return sep.join(map(str, a))
def main():
n = I()
aa = [LI() for _ in range(n-1)]
e = collections.defaultdict(set)
for a,b in aa:
e[a].add(b)
e[b].add(a)
q = [[(1,-1)]]
qi = 0
while 1:
t = q[qi]
nq = []
for i,p in t:
for c in e[i]:
if c == p:
continue
nq.append((c,i))
if len(nq) < 1:
break
q.append(nq)
qi += 1
gm = [1]
for i in range(1,n+1):
gm.append(i*gm[-1]%mod)
m = {}
def f(i, p):
t = 1
r = 1
for c in e[i]:
if c == p:
continue
# print('c',c)
r *= m[c]
r %= mod
t += 1
if p == -1:
r *= gm[t-1]
r *= n
else:
r *= gm[t]
r %= mod
m[i] = r
# print('r',i,p,r)
# print('g',gm[t],t)
return r
for qt in q[::-1]:
for i,p in qt:
# print('ip', i,p)
f(i,p)
r = f(1,-1)
return r
print(main())
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1172/B"
} | |
d2134 | train | strings = int(input())
count = [0 for x in range(7)]
for k in range(strings):
s = input()
for index in range(7):
if s[index] == '1':
count[index] += 1
print(max(count))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/847/G"
} | |
d2135 | train | from collections import defaultdict, deque
n = int(input())
adj = [[] for _ in range(n)]
v = [0] * n
l = list(map(int, input().split()))
for i, f in enumerate(l):
adj[f - 1].append(i + 1)
s = list(map(int, input().split()))
Q = deque([(0, s[0], s[0])])
ans = 0
flag = False
possible = True
while Q and possible:
# print(Q)
flag = not flag
for _ in range(len(Q)):
cur, v, curs = Q.popleft()
if v < 0:
possible = False
ans = -1
break
ans += v
if flag:
for i in adj[cur]:
if len(adj[i]) <= 1:
Q.append((i, 0, curs))
else:
temp = min([s[k] for k in adj[i]])
Q.append((i, temp - curs, temp))
else:
for i in adj[cur]:
Q.append((i, s[i] - curs, s[i]))
print(ans)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1098/A"
} | |
d2136 | train | from time import time
opposite = {
'N': 'S',
'S': 'N',
'E': 'W',
'W': 'E'
}
otr = str.maketrans(opposite)
bits = {
'N': 0,
'S': 1,
'E': 2,
'W': 3,
}
Q = 4294967291
def combine(h, v, q):
return (h<<2 | v) % q
def combinel(h, v, q, s):
return (v*s + h) % q
def flip(s):
return ''.join(reversed(s.translate(otr)))
def solvable(p1, p2):
h1 = 0
h2 = 0
s = 1
for i in reversed(list(range(len(p1)))):
n1 = bits[p1[i]]
n2 = bits[opposite[p2[i]]]
h1 = combine(h1, n1, Q)
h2 = combinel(h2, n2, Q, s)
if h1 == h2 and p1[i:] == flip(p2[i:]):
return False
s = (s<<2) % Q
return True
def __starting_point():
n = int(input())
p1 = input()
p2 = input()
print('YES' if solvable(p1, p2) else 'NO')
__starting_point() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/607/C"
} | |
d2137 | train | import sys
readline = sys.stdin.readline
N = int(readline())
A = list(map(int, readline().split()))
BW = [0, 0]
for i in range(N):
a = A[i]
BW[i%2] += a//2
BW[(i+1)%2] += -(-a//2)
print(min(BW))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1268/B"
} | |
d2138 | train | n, k = map(int, input().split())
t = set(map(int, input().split()))
y = x = min(t)
t = list(t)
while True:
for i in t:
if i % x > k: x = i // (i // x + 1)
if y == x: break
y = x
print(y) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/354/C"
} | |
d2139 | train | print('YES' if input().count('1')+1>>1<<1 >= input().count('1') else 'NO') | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/297/A"
} | |
d2140 | train |
import sys
from sys import stdin
def modfac(n, MOD):
f = 1
factorials = [1]
for m in range(1, n + 1):
f *= m
f %= MOD
factorials.append(f)
inv = pow(f, MOD - 2, MOD)
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
return factorials, invs
def modnCr(n,r,mod,fac,inv):
return fac[n] * inv[n-r] * inv[r] % mod
mod = 998244353
n = int(stdin.readline())
a = list(map(int,stdin.readline().split()))
a.sort()
fac,inv = modfac(2*n+10,mod)
print( (modnCr(2*n,n,mod,fac,inv) * (sum(a[n:]) - sum(a[:n]))) % mod )
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1444/B"
} | |
d2141 | train | n = int(input())
b = list(map(int, input().split()))
m, M = min(b), max(b)
if m == M:
if M == 0:
print('YES')
print(' '.join(['1' for i in range(n)]))
else:
print('NO')
else:
print('YES')
pos = list([i for i in range(n) if b[i] == M and b[i - 1] < M])[0]
a = [0 for i in range(n)]
a[pos] = M
a[pos - 1] = (M << 1) + b[pos - 1]
for i in range(2, n):
a[pos - i] = a[pos - i + 1] + b[pos - i]
print(*a)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1028/E"
} | |
d2142 | train | import sys
readline = sys.stdin.readline
def parorder(Edge, p):
N = len(Edge)
par = [0]*N
par[p] = -1
stack = [p]
order = []
visited = set([p])
ast = stack.append
apo = order.append
while stack:
vn = stack.pop()
apo(vn)
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
ast(vf)
return par, order
def getcld(p):
res = [[] for _ in range(len(p))]
for i, v in enumerate(p[1:], 1):
res[v].append(i)
return res
N = int(readline())
root = None
Edge = [[] for _ in range(N)]
Cr = [None]*N
for a in range(N):
b, c = list(map(int, readline().split()))
b -= 1
if b == -1:
root = a
else:
Edge[a].append(b)
Edge[b].append(a)
Cr[a] = c
P, L = parorder(Edge, root)
dp = [0]*N
for l in L[:0:-1]:
p = P[l]
dp[p] += 1+dp[l]
if any(d < c for d, c in zip(dp, Cr)):
print('NO')
else:
print('YES')
A = [None]*N
dp2 = [[] for _ in range(N)]
for l in L[:0:-1]:
p = P[l]
dp2[l] = dp2[l][:Cr[l]] + [l] + dp2[l][Cr[l]:]
dp2[p].extend(dp2[l])
dp2[root] = dp2[root][:Cr[root]] + [root] + dp2[root][Cr[root]:]
Ans = [None]*N
for i in range(N):
Ans[dp2[root][i]] = i+1
print(' '.join(map(str, Ans)))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1286/B"
} | |
d2143 | train | n=int(input())
a=[]
for i in range(n):
a.append(list(map(int,input().split())))
ans = [0]*n
for i in range(n):
for j in range(n):
if j!=i:
ans[i] |= a[i][j]
print(ans[i],end = ' ')
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/245/D"
} | |
d2144 | train | from bisect import *
n, tc, td = [int(i) for i in input().split()]
fc = []
fd = []
mbc = 0
mbd = 0
for _ in range(n):
b, p, ft = input().split()
b, p = int(b), int(p)
f = (p, b)
if ft == 'C':
if p <= tc:
fc.append(f)
mbc = max(mbc, b)
else:
if p <= td:
fd.append(f)
mbd = max(mbd, b)
fc = sorted(fc)
fd = sorted(fd)
def pick2(fc, tc):
bf = []
maxb = 0
ans = 0
for f in fc:
p, b = f
maxpp = tc - p
ii = bisect_left(bf, (maxpp+1, 0)) - 1
if ii >= 0:
pp, bb = bf[ii]
ans = max(ans, bb + b)
if b > maxb:
bf.append(f)
maxb = b
return ans
ans = mbc + mbd if mbc > 0 and mbd > 0 else 0
ans = max(ans, pick2(fc, tc))
ans = max(ans, pick2(fd, td))
print(ans)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/799/C"
} | |
d2145 | train |
def main():
k = int(input())
n = []
a = []
for i in range(k):
line = [int(x) for x in input().split()]
ni = line[0]
ai = []
n.append(ni)
a.append(ai)
for j in range(ni):
ai.append(line[1 + j])
answer, c, p = solve(k, n, a)
if answer:
print("Yes")
for i in range(k):
print(c[i], p[i] + 1)
else:
print("No")
def solve(k, n, a):
asum, sums = calc_sums(k, n, a)
if asum % k != 0:
return False, None, None
tsum = asum / k
num_map = build_num_map(k, n, a)
masks = [None]*(1 << k)
simple = [False]*(1 << k)
for i in range(k):
for j in range(n[i]):
found, mask, path = find_cycle(i, j, i, j, k, n, a, sums, tsum, num_map, 0, dict())
if found:
simple[mask] = True
masks[mask] = path
for i in range(1 << k):
if not simple[i]:
continue
mask = i
zeroes_count = 0
for u in range(k):
if (1 << u) > mask:
break
if (mask & (1 << u)) == 0:
zeroes_count += 1
for mask_mask in range(1 << zeroes_count):
mask_child = 0
c = 0
for u in range(k):
if (1 << u) > mask:
break
if (mask & (1 << u)) == 0:
if (mask_mask & (1 << c)) != 0:
mask_child = mask_child | (1 << u)
c += 1
if masks[mask_child] and not masks[mask_child | mask]:
masks[mask_child | mask] = {**masks[mask_child], **masks[mask]}
if (mask_child | mask) == ((1 << k) - 1):
c = [-1] * k
p = [-1] * k
d = masks[(1 << k) - 1]
for key, val in list(d.items()):
c[key] = val[0]
p[key] = val[1]
return True, c, p
if masks[(1 << k) - 1]:
c = [-1] * k
p = [-1] * k
d = masks[(1 << k) - 1]
for key, val in list(d.items()):
c[key] = val[0]
p[key] = val[1]
return True, c, p
return False, None, None
def build_num_map(k, n, a):
result = dict()
for i in range(k):
for j in range(n[i]):
result[a[i][j]] = (i, j)
return result
def find_cycle(i_origin, j_origin, i, j, k, n, a, sums, tsum, num_map, mask, path):
if (mask & (1 << i)) != 0:
if i == i_origin and j == j_origin:
return True, mask, path
else:
return False, None, None
mask = mask | (1 << i)
a_needed = tsum - (sums[i] - a[i][j])
if a_needed not in num_map:
return False, None, None
i_next, j_next = num_map[a_needed]
path[i_next] = (a[i_next][j_next], i)
return find_cycle(i_origin, j_origin, i_next, j_next, k, n, a, sums, tsum, num_map, mask, path)
def calc_sums(k, n, a):
sums = [0] * k
for i in range(k):
for j in range(n[i]):
sums[i] = sums[i] + a[i][j]
asum = 0
for i in range(k):
asum = asum + sums[i]
return asum, sums
def __starting_point():
main()
__starting_point() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1242/C"
} | |
d2146 | train | s = input()
t = input()
n = len(s)
m = len(t)
t = t + '$' + s
p = [0] * (n + m + 1)
k = 0
for i in range(1, n + m + 1):
while k > 0 and t[k] != t[i]:
k = p[k - 1]
if t[k] == t[i]:
k += 1
p[i] = k
ans = [0] * n
sums = [0] * (n + 1)
curs = 0
was = False
j = 0
MOD = 10 ** 9 + 7
for i in range(n):
if p[i + m + 1] == m:
if not was:
was = True
curs = 1
while j <= i - m:
curs = (curs + sums[j] + 1) % MOD
j += 1
ans[i] = curs
sums[i] = (sums[i - 1] + ans[i]) % MOD
print(sum(ans) % MOD)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/494/B"
} | |
d2147 | train | import sys
readline = sys.stdin.readline
N, D, M = map(int, readline().split())
A = list(map(int, readline().split()))
Am = [a for a in A if a > M]
Ao = [a for a in A if a <= M]
Am.sort(reverse = True)
Ao.sort(reverse = True)
Cam = Am[:]
Cao = Ao[:]
for i in range(1, len(Cam)):
Cam[i] += Cam[i-1]
for i in range(1, len(Cao)):
Cao[i] += Cao[i-1]
k = -(-N//(D+1))
ans = sum(Am[:k])
lcam = len(Cam)
Cam = [0] + Cam
for i in range(len(Cao)):
k = min(lcam, -(-(N-(i+1))//(D+1)))
ans = max(ans, Cao[i] + Cam[k])
print(ans) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1394/A"
} | |
d2148 | train | n,r1,r2,r3,D = map(int,input().split())
state = [0,0] # after odd number of 2 (1st), or not (2nd)
a = list(map(int,input().split()))
# First element
# Choosing P~P + A
state[0] = r1 * a[0] + r3
# Choosing L + P later or all P
state[1] = min(r2 + r1 + D, r1 * (a[0] + 2) + D)
# Second to Second Last element
for i in range(1,n-1):
newState = [-1,-1]
newState[0] = min(state[1] + D + r1 * a[i] + r3, state[0] + r1 * a[i] + r3,
state[1] + r2 + r1 + D, state[1] + r1 * (a[i] + 2) + D)
newState[1] = min(state[0] + r2 + r1 + D, state[0] + r1 * (a[i] + 2) + D)
state = newState
# Last Element
ans = min(state[0] + r1 * a[-1] + r3, state[0] + 2 * D + r2 + r1, state[0] + 2 * D + r1 * (a[-1] + 2),
state[1] + r1 * a[-1] + r3, state[1] + r2 + r1 + D, state[1] + r1 * (a[-1] + 2) + D)
print(ans + D * (n-1)) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1396/C"
} | |
d2149 | train | import sys
def binpow(a, n, p):
res = 1
while n > 0:
if n % 2 == 1:
res = (res * a) % p
a = (a * a) % p
n >>= 1
return res
def main():
result = []
t = int(sys.stdin.readline())
for line in sys.stdin.readlines():
p, q, b = list(map(int, line.split()))
for i in range(6):
b = (b * b) % q
result.extend(list("Finite\n" if (p * b) % q == 0 else list("Infinite\n")))
sys.stdout.write("".join(result))
main()
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/983/A"
} | |
d2150 | train | n, m = map(int, input().split())
a = set(map(int, input().split()))
y = 2 ** n
mk = [0] * (2 * y)
cur = 0
for x in a:
if mk[x]: continue
mk[x] = 1
st = [x]
while st:
u = st.pop()
if u < y:
if not mk[y + u]:
mk[y + u] = 1
st.append(y + u)
else:
for b in range(n):
v = u | 1 << b
if u < v and not mk[v]:
mk[v] = 1
st.append(v)
v = y - 1 - (u - y)
if v in a and not mk[v]:
mk[v] = 1
st.append(v)
cur += 1
print(cur) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/986/C"
} | |
d2151 | train | import sys
input = sys.stdin.readline
MOD = 987654103
n = int(input())
t = input()
place = []
f1 = []
e1 = []
s = []
curr = 0
count1 = 0
for i in range(n):
c = t[i]
if c == '0':
if count1:
e1.append(i - 1)
if count1 & 1:
s.append(1)
curr += 1
e1.append(-1)
f1.append(-1)
count1 = 0
else:
f1.append(-1)
e1.append(-1)
place.append(curr)
curr += 1
s.append(0)
else:
if count1 == 0:
f1.append(i)
count1 += 1
place.append(curr)
if count1:
if count1 & 1:
s.append(1)
else:
s.append(0)
curr += 1
e1.append(n - 1)
e1.append(-1)
f1.append(-1)
place.append(curr)
pref = [0]
val = 0
for i in s:
val *= 3
val += i + 1
val %= MOD
pref.append(val)
q = int(input())
out = []
for _ in range(q):
l1, l2, leng = list(map(int, input().split()))
l1 -= 1
l2 -= 1
starts = (l1, l2)
hashes = []
for start in starts:
end = start + leng - 1
smap = place[start]
emap = place[end]
if t[end] == '1':
emap -= 1
if s[smap] == 1:
smap += 1
prep = False
app = False
if t[start] == '1':
last = e1[place[start]]
last = min(last, end)
count = last - start + 1
if count % 2:
prep = True
if t[end] == '1':
first = f1[place[end]]
first = max(first, start)
count = end - first + 1
if count % 2:
app = True
preHash = 0
length = 0
if smap <= emap:
length = emap - smap + 1
preHash = pref[emap + 1]
preHash -= pref[smap] * pow(3, emap - smap + 1, MOD)
preHash %= MOD
if length == 0 and prep and app:
app = False
#print(preHash, prep, app, length)
if prep:
preHash += pow(3, length, MOD) * 2
length += 1
if app:
preHash *= 3
preHash += 2
#print(preHash)
preHash %= MOD
hashes.append(preHash)
if hashes[0] == hashes[1]:
out.append('Yes')
else:
out.append('No')
print('\n'.join(out))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1320/D"
} | |
d2152 | train |
import sys
#sys.stdin=open("data.txt")
input=sys.stdin.readline
n,s=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
med=a[n//2]
ans=0
if med>s:
for i in range(n//2+1):
if a[i]>s:
ans+=a[i]-s
elif med<s:
for i in range(n//2,n):
if s>a[i]:
ans+=s-a[i]
print(ans)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1037/B"
} | |
d2153 | train | # 素因数分解
def prime_decomposition(n):
i = 2
table = []
while i * i <= n:
while n % i == 0:
n //= i
table.append(i)
i += 1
if n > 1:
table.append(n)
return table
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
# かけらを移動させて共通因数を持つようにする
su = sum(A)
if su == 1:
print(-1)
return
primes = list(set(prime_decomposition(su)))
ans = float("inf")
Idx1 = [i for i, a in enumerate(A) if a]
for p in primes:
an = 0
half = p // 2
for t in zip(*[iter(Idx1)]*p):
idx = t[half]
an += sum(abs(i-idx) for i in t)
ans = min(ans, an)
print(ans)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1254/B1"
} | |
d2154 | train | #!/usr/bin/env python3
from collections import defaultdict
DEBUG = False
def main():
if DEBUG:
test()
n = int(input())
paths = cycles(n)
print(len(paths))
for p in paths:
print('%d %s' % (len(p), ' '.join([str(v) for v in p])))
def cycles(n):
"""Builds a set of cycles for a fully connected graph with n vertices."""
if n % 2 == 0:
return even(n)
else:
return odd(n)
def even(n):
"""Builds a set of cycles that a graph with even vertices."""
assert n % 2 == 0
# Base case for complete graph such that V = {1, 2, 3, 4}.
cycles = [[1, 2, 3], [2, 3, 4], [3, 4, 1], [4, 1, 2]]
for i in range(6, n + 1, 2):
a, b = i, i - 1
# Use edges (a, 1), (a, 0), (b, 1), (b, 0), (a, b) exactly twice each.
cycles += [[a, 1, b], [a, 2, b], [a, 1, b, 2]]
# Similar to odd(...) as we are left with 2n - 2 edges to use
# connected to i - 4 of the vertices V' = {3 ... i - 2}. Notice that
# |V'| is even so we can apply the same strategy as in odd(...).
for k in range(3, i - 1, 2):
c, d = k, k + 1
cycles += [[a, c, b, d]] * 2
return cycles
def odd(n):
"""Builds a set of cycles that a graph with odd vertices."""
assert n % 2 == 1
# Base case for complete graph such that V = {1, 2, 3}.
cycles = [[1, 2, 3]] * 2
for i in range(5, n + 1, 2):
a, b = i, i - 1
# Say the new vertices are {a, b}. Since the graph is fully connected
# adding these 2 vertices results in 2n + 1 more edges. We use a length
# 3 cycle a -> b -> 1 > a twice to use up 3 of these edges.
cycles += [[a, b, 1]] * 2
# At this point we are left with 2n + 1 - 3 = 2n - 2 edges to use
# connected to i - 3 of the vertices V' = {2 ... i - 2}. Notice that
# |V'| is even. To use these edges and cover vertices V' we take pairs
# c, d in V' and create two of each path a -> c -> b -> d -> a.
for k in range(2, i - 1, 2):
c, d = k, k + 1
cycles += [[a, c, b, d]] * 2
return cycles
def test():
"""Checks the cycles(...) solver for a bunch of inputs."""
print('Testing...')
for n in range(3, 300, 21):
check(n, cycles(n))
print('Tests pass!')
def check(n, paths):
"""Checks the solution for errors."""
# Check that all vertices are covered.
vertices = set(sum(paths, list()))
assert vertices == set(range(1, n + 1))
# Check that each edge is used exactly twice.
counts = defaultdict(int)
for p in paths:
assert len(p) == 3 or len(p) == 4
assert len(set(p)) == len(p)
for i in range(len(p)):
key = tuple(sorted([p[i - 1], p[i]]))
counts[key] += 1
for i in range(1, n + 1):
for j in range(i + 1, n + 1):
assert counts[(i, j)] == 2
def __starting_point():
main()
__starting_point() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/819/E"
} | |
d2155 | train | k, q = list(map(int, input().split()))
t = [0] * (k + 1)
t[1] = 1
d = [0]
n = i = 1
while i < 1001:
if 2000 * t[k] > i - 1e-7:
d.append(n)
i += 1
else:
t = [0] + [(j * t[j] + (k - j + 1) * t[j - 1]) / k for j in range(1, k + 1)]
n += 1
for i in range(q): print(d[int(input())])
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/768/D"
} | |
d2156 | train | def main():
n, m = list(map(int, input().split()))
aa = []
for _ in range(n):
row = list(map(int, input().split()))
row.append(0)
aa.append(row)
aa.append([0] * (m + 1))
d1, d2, d3, d4 = ([[0] * (m + 1) for _ in range(n + 1)] for _ in (1, 2, 3, 4))
for i in range(n):
for j in range(m):
d1[i][j] = max(d1[i - 1][j], d1[i][j - 1]) + aa[i][j]
for i in range(n):
for j in range(m - 1, -1, -1):
d2[i][j] = max(d2[i - 1][j], d2[i][j + 1]) + aa[i][j]
for i in range(n - 1, -1, -1):
for j in range(m):
d3[i][j] = max(d3[i + 1][j], d3[i][j - 1]) + aa[i][j]
for i in range(n - 1, -1, -1):
for j in range(m - 1, -1, -1):
d4[i][j] = max(d4[i + 1][j], d4[i][j + 1]) + aa[i][j]
print((max(
max(d1[i][j - 1] + d2[i - 1][j] + d3[i + 1][j] + d4[i][j + 1] for i in range(1, n - 1) for j in range(1, m - 1)),
max(d1[i - 1][j] + d2[i][j + 1] + d3[i][j - 1] + d4[i + 1][j] for i in range(1, n - 1) for j in range(1, m - 1)))))
def __starting_point():
main()
__starting_point() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/429/B"
} | |
d2157 | train | n = int(input())
ans = 'YES\n'
for i in range(n):
x1, y1, x2, y2 = map(int, input().split())
res = (x1 & 1) * 2 + (y1 & 1) + 1
ans += str(res) + '\n'
print(ans) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/763/B"
} | |
d2158 | train | def main():
from heapq import heapify, heapreplace
input()
s = set(map(int, input().split()))
xx = [-x for x in s]
heapify(xx)
while True:
x = -xx[0]
while x != 1:
x //= 2
if x not in s:
s.add(x)
heapreplace(xx, -x)
break
else:
break
print(' '.join(str(-x) for x in xx))
def __starting_point():
main()
__starting_point() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/722/D"
} | |
d2159 | train | def comp(x):
for i in range(2, x):
if x % i == 0:
return True
return False
N = int(input())
if N == 4:
print('YES', '1', '3', '2', '4', sep = '\n')
elif comp(N):
print('NO')
else:
print('YES', '1', sep = '\n')
if N > 1:
for i in range(2, N):
print((i - 1) * pow(i, N - 2, N) % N)
print(N)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/487/C"
} | |
d2160 | train | from collections import defaultdict
def __starting_point():
n, T = [int(_) for _ in input().split()]
data = defaultdict(list)
for i in range(n):
t, q = [int(_) for _ in input().split()]
data[T - t].append(q)
prev_level = []
for level_id in range(1, T + 1):
level = sorted(data[T - level_id] + prev_level, reverse=True)
if T - level_id <= 10:
max_size = 2 ** (T - level_id)
level = level[:max_size]
if len(level) % 2 == 1:
level.append(0)
prev_level = [
level[i] + level[i + 1]
for i in range(0, len(level), 2)
]
print(prev_level[0])
__starting_point() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/542/F"
} | |
d2161 | train | import sys
n,k = map(int, sys.stdin.readline().split())
arr = list(map(int, sys.stdin.readline().split()))
tot = sum(arr)
if tot % k != 0:
print('No')
return
tot //= k
idx,cur = 0,0
ans = []
for i in range(n):
cur += arr[i]
idx += 1
if cur == tot:
ans.append(idx)
idx = 0
cur = 0
elif cur > tot:
print('No')
return
if sum(ans) != n:
print('No')
return
print('Yes')
for an in ans:
print(an,end=' ') | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1070/K"
} | |
d2162 | train | f = lambda: map(int, input().split())
n, m, w = f()
wb = [(0, 0)] + list(zip(f(), f()))
t = list(range(n + 1))
def g(x):
if x == t[x]: return x
t[x] = g(t[x])
return t[x]
for i in range(m):
x, y = f()
x, y = g(x), g(y)
if x != y: t[y] = x
p = [[] for j in range(n + 1)]
for i in range(1, n + 1): p[g(i)].append(i)
d = [1] + [0] * w
for q in p:
if len(q) > 1:
WB = [wb[i] for i in q]
SW = sum(q[0] for q in WB)
SB = sum(q[1] for q in WB)
for D in range(w, -1, -1):
if d[D]:
if D + SW <= w: d[D + SW] = max(d[D + SW], d[D] + SB)
for W, B in WB:
if D + W <= w: d[D + W] = max(d[D + W], d[D] + B)
elif len(q) == 1:
W, B = wb[q[0]]
for D in range(w - W, -1, -1):
if d[D]: d[D + W] = max(d[D + W], d[D] + B)
print(max(d) - 1) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/741/B"
} | |
d2163 | train | maxn=50+10
g=[None]*maxn
dp=[None]*maxn
c=[None]*maxn
size=[0]*maxn
for i in range(0,maxn):
c[i]=[0]*maxn
c[i][0]=1
for j in range(1,i+1):
c[i][j]=c[i-1][j-1]+c[i-1][j]
n=int(input())
for i in range(1,n+1):
g[i]=[]
for i in range(1,n):
u,v=input().split()
u=int(u)
v=int(v)
g[u].append(v)
g[v].append(u)
def mul(a,b,x,y):
tmp=[0]*(x+y+1)
for i in range(0,x+1):
for j in range(0,y+1):
tmp[i+j]+=a[i]*b[j]*c[i+j][i]*c[x+y-i-j][x-i]
return tmp
def dfs(pos,fa):
nonlocal dp
nonlocal size
dp[pos]=[1]
size[pos]=0
for ch in g[pos]:
if ch != fa:
dfs(pos=ch,fa=pos)
dp[pos]=mul(dp[pos],dp[ch],size[pos],size[ch])
size[pos]+=size[ch]
if fa:
size[pos]+=1
tmp=[0]*(size[pos]+1)
for i in range(0,size[pos]+1):
for j in range(0,size[pos]):
if j<i:
tmp[i]+=dp[pos][i-1]
else:
tmp[i]+=dp[pos][j]*0.5
dp[pos]=tmp
for i in range(1,n+1):
dfs(pos=i,fa=0)
tmp=dp[i][0]
for j in range(1,n):
tmp/=j
print(tmp) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1060/F"
} | |
d2164 | train | import sys
readline = sys.stdin.readline
MOD = 10**9+7
S = readline().strip().split('1')
if len(S) == 1:
print(len(S[0]))
else:
S = [len(s)+1 for s in S]
ans = S[0]*S[-1]
S = S[1:-1]
dp = [0]*(max(S)+2)
dp[0] = 1
for ai in S:
res = 0
rz = 0
for i in range(ai+1):
res = (res + dp[i])%MOD
rz = (rz + (ai-i)*dp[i])%MOD
dp[i] = 0
dp[0] = rz
dp[ai] = res
aaa = 0
for d in dp:
aaa = (aaa+d)%MOD
print(aaa*ans%MOD)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1383/E"
} | |
d2165 | train | import sys
input = sys.stdin.readline
def main():
n, m = map(int, input().split())
a = list(map(int, input().split())) + [0]*500000
ans_S = 0
a[n] = a[0] + m
s = [0]*600600
for i in range(n):
s[i] = a[i + 1] - a[i]
s[n] = -1
for i in range(n):
s[2*n - i] = s[i]
for i in range(2*n + 1, 3*n + 1):
s[i] = s[i - n]
l, r = 0, 0
z = [0]*600600
for i in range(1, 3*n + 1):
if i < r:
z[i] = z[i - l]
while i + z[i] <= 3*n and (s[i + z[i]] == s[z[i]]):
z[i] += 1
if i + z[i] > r:
l = i
r = i + z[i]
ans = []
for i in range(n + 1, 2*n + 1):
if z[i] < n:
continue
ans_S += 1
ans.append((a[0] + a[2*n - i + 1]) % m)
ans.sort()
print(ans_S)
print(*ans)
return
def __starting_point():
main()
__starting_point() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1045/B"
} | |
d2166 | train | def init_factorials(N, mod):
f = 1
fac = [1] * N
for i in range(1, N):
f *= i
f %= mod
fac[i] = f
return fac
def init_inv(N, mod, fac):
b = bin(mod-2)[2:][-1::-1]
ret = 1
tmp = fac[N]
if b[0] == '1':
ret = fac[N]
for bi in b[1:]:
tmp *= tmp
tmp %= mod
if bi == '1':
ret *= tmp
ret %= mod
inv = [1] * (N + 1)
inv[N] = ret
for i in range(N-1, 0, -1):
ret *= i + 1
ret %= mod
inv[i] = ret
return inv
def f(r, c, mod, fac, inv):
return (fac[r + c] * inv[r] * inv[c]) % mod
def read_data():
h, w, n = list(map(int, input().split()))
blacks = []
for i in range(n):
r, c = list(map(int, input().split()))
blacks.append((r, c))
return h, w, n, blacks
def solve(h, w, n, blacks):
mod = 10**9 + 7
fac = init_factorials(h + w + 10, mod)
inv = init_inv(h + w + 5, mod, fac)
ans = (fac[h+w-2]*inv[h-1]*inv[w-1]) % mod
eb = [(r + c, r, c) for r, c in blacks]
eb.sort()
blacks = [(r, c) for rc, r, c in eb]
g = [f(r-1, c-1, mod, fac, inv) for r, c in blacks]
hw = h+w
for i, (r, c) in enumerate(blacks):
gi = g[i]
rc = r + c
ans -= gi*fac[hw-rc]*inv[h-r]*inv[w-c]
ans %= mod
for j, (rj, cj) in enumerate(blacks[i+1:], i+1):
if r <= rj and c <= cj:
g[j] -= gi*fac[rj+cj-rc]*inv[rj-r]*inv[cj-c]
g[j] %= mod
return ans
h, w, n, blacks = read_data()
print(solve(h, w, n, blacks))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/559/C"
} | |
d2167 | train | f = lambda: list(map(int, input().split()))[1:]
n = int(input())
s, p, q = [], [], []
for x in [0, 1]:
r = f()
s.append(r)
t = [len(r)] * n
t[0] = 0
p.append(t)
q.append((x, 0))
while q:
x, i = q.pop()
y = 1 - x
for d in s[y]:
j = (i - d) % n
if p[y][j] < 1: continue
p[y][j] = -1
for d in s[x]:
k = (j - d) % n
if p[x][k] < 1: continue
p[x][k] -= 1
if p[x][k] == 0: q.append((x, k))
for x in [0, 1]:
print(*[['Lose', 'Loop', 'Win'][min(q, 1)] for q in p[x][1:]]) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/786/A"
} | |
d2168 | train | def read_data():
n, q = map(int, input().split())
As = list(map(int, input().split()))
LRs = []
for i in range(q):
L, R = list(map(int, input().split()))
LRs.append((L, R))
return n, q, As, LRs
def solve(n, q, As, LRs):
difs = calc_difs(As)
Ls = get_Ls(difs)
Rs = get_Rs_allow_ties(difs)
for L, R in LRs:
print(calc(L-1, R-2, Ls, Rs, difs))
def calc_difs(As):
difs = [abs(a0 - a1) for a0, a1 in zip(As, As[1:])]
return difs
def get_Ls(Vs):
L = []
st = []
for i, v in enumerate(Vs):
while st and Vs[st[-1]] < v:
st.pop()
if st:
L.append(st[-1] + 1)
else:
L.append(0)
st.append(i)
return L
def get_Ls_allow_ties(Vs):
L = []
st = []
for i, v in enumerate(Vs):
while st and Vs[st[-1]] <= v:
st.pop()
if st:
L.append(st[-1] + 1)
else:
L.append(0)
st.append(i)
return L
def get_Rs(Vs):
n = len(Vs)
revVs = Vs[::-1]
revRs = get_Ls(revVs)
revRs.reverse()
return [n - 1 - R for R in revRs]
def get_Rs_allow_ties(Vs):
n = len(Vs)
revVs = Vs[::-1]
revRs = get_Ls_allow_ties(revVs)
revRs.reverse()
return [n - 1 - R for R in revRs]
def calc(L, R, Ls, Rs, difs):
ans = 0
for i in range(L, R + 1):
ans += difs[i] * (i - max(Ls[i], L) + 1) * (min(Rs[i], R) - i + 1)
return ans
n, q, As, LRs = read_data()
solve(n, q, As, LRs) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/601/B"
} | |
d2169 | train | import sys
from array import array # noqa: F401
n = int(input())
matrix = [array('i', list(map(int, input().split()))) for _ in range(n)]
aa = tuple([int(x) - 1 for x in input().split()])
ans = [''] * n
for i in range(n-1, -1, -1):
x = aa[i]
for a in range(n):
for b in range(n):
if matrix[a][b] > matrix[a][x] + matrix[x][b]:
matrix[a][b] = matrix[a][x] + matrix[x][b]
val, overflow = 0, 0
for a in aa[i:]:
for b in aa[i:]:
val += matrix[a][b]
if val > 10**9:
overflow += 1
val -= 10**9
ans[i] = str(10**9 * overflow + val)
print(' '.join(ans))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/295/B"
} | |
d2170 | train | def check(num1, num2, p, k):
v = num1 + num2
v *= num1 * num1 + num2 * num2
v %= p
v += p
v %= p
return v == k % p
def __starting_point():
n, p, k = (int(x) for x in input().split())
idx___number = [int(x) for x in input().split()]
idx___precount = [((pow(x, 4, p) - k * x) % p + p) % p for x in idx___number]
met_precount___vals = {}
ans = 0
for number, precount in zip(idx___number[::-1], idx___precount[::-1]):
if precount not in met_precount___vals:
met_precount___vals[precount] = []
else:
for val in met_precount___vals[precount]:
if check(number, val, p, k):
ans += 1
met_precount___vals[precount].append(number)
print(ans)
__starting_point() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1188/B"
} | |
d2171 | train | import heapq
def sum_sqaure(a, k):
q, r = divmod(a, k)
return q**2 * (k-r) + (q+1)**2 * r
def diff(a, k):
return sum_sqaure(a, k+1) - sum_sqaure(a, k)
n, k = map(int, input().split())
nums = list(map(int, input().split()))
curr = sum(sum_sqaure(a, 1) for a in nums)
Q = [(diff(a, 1), a, 1) for a in nums]
heapq.heapify(Q)
for __ in range(k - n):
d, a, i = heapq.heappop(Q)
curr += d
heapq.heappush(Q, (diff(a, i+1), a, i+1))
print(curr) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1428/E"
} | |
d2172 | train | import sys
def dfs(tree, root, priv_root, cur_lvl, priv_lvl, diff, pick_list):
if not tree:
return
stack = [(root, priv_root, cur_lvl, priv_lvl)]
while stack:
(root, priv_root, cur_lvl, priv_lvl) = stack.pop()
if cur_lvl ^ diff[root]:
cur_lvl ^= 1
pick_list.append(str(root))
stack += [(vertex, root, priv_lvl, cur_lvl)
for vertex in tree[root] if vertex != priv_root]
def main():
n = int(input())
tree = dict()
for _ in range(n - 1):
(u, v) = list(map(int, input().split()))
tree[u] = tree.get(u, set()) | set([v])
tree[v] = tree.get(v, set()) | set([u])
init = [0] + list(map(int, input().split()))
goal = [0] + list(map(int, input().split()))
diff = [i ^ j for (i, j) in zip(init, goal)]
pick_list = list()
dfs(tree, 1, 0, 0, 0, diff, pick_list)
num = len(pick_list)
print(num)
if num:
print('\n'.join(pick_list))
def __starting_point():
return(main())
__starting_point() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/429/A"
} | |
d2173 | train | def prime(n):
m = int(n ** 0.5) + 1
t = [1] * (n + 1)
for i in range(3, m):
if t[i]: t[i * i :: 2 * i] = [0] * ((n - i * i) // (2 * i) + 1)
return [2] + [i for i in range(3, n + 1, 2) if t[i]]
def gcd(a, b):
c = a % b
return gcd(b, c) if c else b
p = prime(31650)
def g(n):
m = int(n ** 0.5)
for j in p:
if n % j == 0: return True
if j > m: return False
def f(n):
a, b = n, n + 1
while g(a): a -= 1
while g(b): b += 1
p, q = (b - 2) * a + 2 * (n - b + 1), 2 * a * b
d = gcd(p, q)
print(str(p // d) + '/' + str(q // d))
for i in range(int(input())): f(int(input()))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/396/B"
} | |
d2174 | train | from itertools import starmap
def main():
n, q = list(map(int, input().split()))
a = list(range(n + 1))
flipped = False
start = 0
end = n
for _ in range(q):
cmd, *args = list(map(int, input().split()))
if cmd == 1:
p = args[0]
if p > end-start-p:
flipped = not flipped
p = end-start-p
if flipped:
a[end-p:end-2*p:-1] = starmap(
lambda a, b: a+n-b,
list(zip(a[end-p:end-2*p:-1], a[end-p:end]))
)
end -= p
else:
start += p
a[start:start+p] = starmap(
lambda a, b: a-b,
list(zip(a[start:start+p], a[start:start-p:-1]))
)
else:
l, r = args
if flipped:
l, r = end-start-r, end-start-l
print(a[start + r] - a[start + l])
def __starting_point():
main()
__starting_point() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/461/C"
} | |
d2175 | train | n, p, q = input(), set(), set()
for i in map(int, input().split()):
q = set(i | j for j in q)
q.add(i)
p.update(q)
print(len(p)) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/243/A"
} | |
d2176 | train | buck = [[0, 0] for i in range(2201)]
m = int(input())
for i in range(m):
a = int(input())
ok = True
br = 0
for j in range(2200, -1, -1):
if a & (1 << j):
if(buck[j][0]):
a ^= buck[j][0]
br ^= buck[j][1]
else:
ok = False
buck[j][0] = a
buck[j][1] = br | (1 << i)
break
if not ok:
print("0")
else:
lst = []
for j in range(2201):
if br & (1 << j):
lst.append(j)
print(len(lst), end = ' ')
for j in lst:
print(j, end = ' ')
print('\n', end='')
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/504/D"
} | |
d2177 | train | import heapq
n = int(input())
buy = [] # negative
sell = []
unknown = []
res = 1
for i in range(n):
cmd, amount = input().strip().split()
amount = int(amount)
if cmd == 'ADD':
if sell and sell[0] < amount:
heapq.heappush(sell, amount)
elif buy and -buy[0] > amount:
heapq.heappush(buy, -amount)
else:
unknown.append(amount)
else:
if (sell and amount > sell[0]) or (buy and amount < -buy[0]):
print(0)
return
if sell and amount == sell[0]:
heapq.heappop(sell)
elif buy and amount == -buy[0]:
heapq.heappop(buy)
else:
res = res * 2 % 1000000007
for x in unknown:
if x < amount:
heapq.heappush(buy, -x)
elif x > amount:
heapq.heappush(sell, x)
unknown = []
res = res * (len(unknown) + 1) % 1000000007
print(res)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1028/D"
} | |
d2178 | train | n = int(input())
s = list(map(int,input().split(' ')))
a = []
for i in range(max(s)):
a.append([])
for i in range(len(s)):
a[s[i]-1].append(i)
a = list([x for x in a if x != []])
if len(a) > 1:
for i in range(1,len(a)):
if len(a[i]) > 1:
s = a[i-1][-1]
if s > a[i][0] and s < a[i][-1]:
for j in range(1,len(a[i])):
if s < a[i][j]:
a[i] = a[i][j:] + a[i][:j]
break
t = []
for i in a:
t += i
c = 0
x = t[0] + 1
i = n-1
while i > 0:
if t[i] < t[i-1]:
k = t[i] - t[i-1] + n
else:
k = t[i] - t[i-1]
c += k
x -= c//n
i -= 1
print(c+x)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/830/B"
} | |
d2179 | train | inp = input().split(' ')
val=[];
totNums = int(inp[0]); totOpt = int(inp[1]);
inp = input().split(' '); #assert(len(inp) == totNums);
for it in inp: val.append(int(it))
dp = [[0.0 for _ in range(0,totNums)] for __ in range(0,totNums)]
for i in range(0,totNums):
for j in range(0,totNums):
if val[i]>val[j]: dp[i][j] = 1.0
while totOpt>0:
totOpt -= 1
inp = input().split(' ')
fr = int(inp[0])-1; to = int(inp[1])-1;
for i in range(0,totNums):
if i!=fr and i!=to:
dp[i][fr] = dp[i][to] = (dp[i][fr] + dp[i][to]) / 2;
dp[fr][i] = dp[to][i] = (dp[fr][i] + dp[to][i]) / 2;
dp[fr][to] = dp[to][fr] = (dp[fr][to] + dp[to][fr]) / 2;
ans = 0.0
for i in range(0,totNums):
for j in range(i+1,totNums):
ans += dp[i][j]
print('%.10f'%ans)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/258/D"
} | |
d2180 | train | q, b, c = list(map(int, input().split()))
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in a:
if b < i < c:
ans += 1
print(ans)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/794/A"
} | |
d2181 | train | def solve():
n1, m, a, d = list(map(int, input().split()))
t = list(map(int, input().split()))
from bisect import insort
from math import floor
insort(t, a * n1)
pred = 0
k = 0
kpred = 0
n = 0
step = d // a + 1
sol = 0
fl = 0
for i in t:
if (i > pred):
if fl == 0:
n = (i - pred + (pred % a)) // a
if n != 0:
k += (n // step) * step - step * (n % step == 0) + 1
if k > n1:
k = n1
fl = 1
# print(k)
if (k * a + d >= i) and (n != 0):
pred = k * a + d
else:
pred = i + d
k = floor(pred // a)
sol += 1
# if n==0:
k = min(floor(pred // a), n1)
sol += n // step + (n % step != 0)
else:
sol += 1
pred = i + d
if i == a * n1:
fl = 1
# print(i,pred,sol,n,step,k, fl)
print(sol)
solve() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/883/A"
} | |
d2182 | train | n = int(input())
a = list(map(int, input().split()))
lp,rp = [0 for i in range(n)],[0 for i in range(n)]
lnr, rnr = [a[i] for i in range(n)],[a[i] for i in range(n)]
mx = a[0]
for i in range(1,n):
if a[i] > mx:
mx = a[i]
lp[i] = lp[i-1]
else:
mx += 1
lp[i] = lp[i-1] + mx - a[i]
lnr[i] = mx
mx = a[-1]
for i in range(n-2,-1,-1):
if a[i] > mx:
mx = a[i]
rp[i] = rp[i+1]
else:
mx += 1
rp[i] = rp[i+1] + mx - a[i]
rnr[i] = mx
ans = min(rp[0], lp[-1])
for i in range(1,n-1):
ca = lp[i-1] + rp[i+1]
if max(lnr[i-1], rnr[i+1]) + 1 > a[i]:
ca += max(lnr[i-1], rnr[i+1]) + 1 - a[i]
ans = min(ans, ca)
print(ans) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/847/H"
} | |
d2183 | train | oleg = input()
igor = input()
oleg = sorted(list(oleg))
igor = sorted(list(igor))
n = len(oleg)
oleg_turns = (n + 1) // 2
igor_turns = n // 2
min_oleg_id = 0
min_igor_id = n - igor_turns
ans = ['?'] * n
max_oleg_id = oleg_turns - 1
max_igor_id = n - 1
curr_turn = 'o'
next_turn = {'o' : 'i', 'i' : 'o'}
l_ans = 0
r_ans = n - 1
while r_ans >= l_ans:
if curr_turn == 'o':
if oleg[min_oleg_id] < igor[max_igor_id]:
ans[l_ans] = oleg[min_oleg_id]
l_ans += 1
min_oleg_id += 1
else:
ans[r_ans] = oleg[max_oleg_id]
r_ans += -1
max_oleg_id += -1
curr_turn = 'i'
else:
if igor[max_igor_id] > oleg[min_oleg_id]:
ans[l_ans] = igor[max_igor_id]
l_ans += 1
max_igor_id += -1
else:
ans[r_ans] = igor[min_igor_id]
r_ans += -1
min_igor_id += 1
curr_turn = 'o'
strans = ''.join(ans)
print(strans)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/794/C"
} | |
d2184 | train | import sys
mod = 10**9 + 7
for _ in range(int(input())):
x = int(input())
s = list(map(int, input()))
ans = len(s)
for i in range(1, x+1):
ans = (i + (ans-i) * s[i-1]) % mod
r = len(s)
for _ in range(s[i-1]-1):
if len(s) < x:
s += s[i:r]
else:
break
print(ans)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1280/A"
} | |
d2185 | train | n, _q = map(int, input().split())
mni = [-1] * 200001
mxi = [-1] * 200001
cnt = [0] * 200001
nd = 0
a = list(map(int, input().split()))
for i, v in enumerate(a):
if mni[v] == -1: mni[v] = i; nd += 1
mxi[v] = i
cnt[v] += 1
r = 0
z = 0
currmax = 0
for i, v in enumerate(a):
if i == mni[v]: z += 1
if i == mxi[v]: z -= 1
currmax = max(currmax, cnt[v])
if z == 0: r += currmax; currmax = 0
print(n - r) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1209/G1"
} | |
d2186 | train | n, m = list(map(int, input().split()))
g = [[] for _ in range(n)]
for i in range(m):
p, q = list(map(int, input().split()))
g[p - 1].append(q - 1)
g[q - 1].append(p - 1)
comp = [-1] * n
def shortest(root):
dist = [-1] * n
q = [0] * n
left, right = 0, 1
q[left] = root
dist[root] = 0
good = True
while left < right:
x = q[left]
left = left + 1
for i in g[x]:
if dist[i] is -1:
dist[i] = 1 + dist[x]
q[right] = i
right = right + 1
elif dist[i] == dist[x]:
good = False
far = 0
for i in dist:
if far < i:
far = i
return good, far, dist
arr = [0] * n
good = True
for i in range(n):
_, opt, dist = shortest(i)
if _ is False: good = False
if comp[i] is -1:
for j in range(n):
if dist[j] is not -1: comp[j] = i
if arr[comp[i]] < opt:
arr[comp[i]] = opt
if good is False: print('-1')
else: print(sum(arr))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/542/E"
} | |
d2187 | train | MOD = 1000000007
n = int(input())
p = [int(x) for x in input().split()]
x = [int(x) for x in input().split()]
children = [[] for x in range(n)]
for i in range(1,n):
children[p[i-1]].append(i)
#print(children)
count = [(0,0) for i in range(n)]
for i in reversed(list(range(n))):
prod = 1
for ch in children[i]:
prod *= count[ch][0]+count[ch][1]
if x[i]:
count[i] = (0,prod % MOD)
else:
tot = 0
for ch in children[i]:
cur = count[ch][1]*prod // (count[ch][0]+count[ch][1])
tot += cur
count[i] = (prod % MOD, tot % MOD)
print(count[0][1])
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/461/B"
} | |
d2188 | train | """
Codeforces Round 257 Div 1 Problem C
Author : chaotic_iak
Language: Python 3.3.4
"""
def read(mode=2):
# 0: String
# 1: List of strings
# 2: List of integers
inputs = input().strip()
if mode == 0:
return inputs
if mode == 1:
return inputs.split()
if mode == 2:
return [int(x) for x in inputs.split()]
def write(s="\n"):
if isinstance(s, list): s = " ".join(map(str,s))
s = str(s)
print(s, end="")
################################################### SOLUTION
# croft algorithm to generate primes
# from pyprimes library, not built-in, just google it
from itertools import compress
import itertools
def croft():
"""Yield prime integers using the Croft Spiral sieve.
This is a variant of wheel factorisation modulo 30.
"""
# Implementation is based on erat3 from here:
# http://stackoverflow.com/q/2211990
# and this website:
# http://www.primesdemystified.com/
# Memory usage increases roughly linearly with the number of primes seen.
# dict ``roots`` stores an entry x:p for every prime p.
for p in (2, 3, 5):
yield p
roots = {9: 3, 25: 5} # Map d**2 -> d.
primeroots = frozenset((1, 7, 11, 13, 17, 19, 23, 29))
selectors = (1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0)
for q in compress(
# Iterate over prime candidates 7, 9, 11, 13, ...
itertools.islice(itertools.count(7), 0, None, 2),
# Mask out those that can't possibly be prime.
itertools.cycle(selectors)
):
# Using dict membership testing instead of pop gives a
# 5-10% speedup over the first three million primes.
if q in roots:
p = roots[q]
del roots[q]
x = q + 2*p
while x in roots or (x % 30) not in primeroots:
x += 2*p
roots[x] = p
else:
roots[q*q] = q
yield q
n, = read()
cr = croft()
primes = []
for i in cr:
if i < n:
primes.append(i)
else:
break
primes.reverse()
used = [0] * (n+1)
res = []
for p in primes:
k = n//p
tmp = []
while k:
if not used[k*p]:
tmp.append(k*p)
used[k*p] = 1
if len(tmp) == 2:
res.append(tmp)
tmp = []
k -= 1
if tmp == [p] and p > 2 and p*2 <= n and len(res) and res[-1][1] == p*2:
res[-1][1] = p
used[p*2] = 0
used[p] = 1
print(len(res))
for i in res:
print(" ".join(map(str, i))) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/449/C"
} | |
d2189 | train | from sys import stdin
def main():
cnt = [0] * 2 ** 18
t = str.maketrans("0123456789", "0101010101")
_, *l = stdin.read().splitlines()
for sign, s in map(str.split, l):
if sign == '?':
print(cnt[int(s, 2)])
else:
cnt[int(s.translate(t), 2)] += 1 if sign == '+' else -1
def __starting_point():
main()
__starting_point() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/713/A"
} | |
d2190 | train | t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int,input().split()))
sumA = sum(a)
TWins = False
for elem in a:
if elem > sumA // 2:
TWins = True
break
if TWins or sumA % 2 != 0:
print("T")
else:
print("HL") | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1396/B"
} | |
d2191 | train | n = int(input())
ans = 0
stk = []
for v in map(int, input().split()):
last = 0
while len(stk) and stk[-1][0] < v and stk[-1][1]:
last = max(last, stk[-1][1])
del stk[-1]
if not len(stk) or stk[-1][0] < v:
stk.append((v, 0))
else:
stk.append((v, last + 1)); ans = max(ans, last + 1)
print(ans)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/319/B"
} | |
d2192 | train | def main():
input()
aa = sorted(map(int, input().split()))
maxa = max(aa)
m = [False] * (maxa + 1)
x = []
b = 0
for a in aa:
if b != a:
m[a] = True
for i in range(b, a):
x.append(b)
b = a
x.append(b)
ans = 0
for i in range(maxa - 1, 1, -1):
if i < ans:
break
if m[i]:
for j in range(1, maxa // i + 1):
ans = max(ans, x[min(i * (j + 1) - 1, maxa)] % i)
print(ans)
def __starting_point():
main()
__starting_point() | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/484/B"
} | |
d2193 | train | n = int(input())
pos_blast = [list(map(int, input().split())) for _ in range(n)]
MAX_N = max(pos_blast, key=lambda x: x[0])[0] + 2
power = [0 for _ in range(MAX_N)]
tower = [False for _ in range(MAX_N)]
can_destroy = [0 for _ in range(MAX_N)]
for pos, blast in pos_blast:
pos += 1
tower[pos] = True
power[pos] = blast
for i in range(1, MAX_N):
if not tower[i]:
can_destroy[i] = can_destroy[i-1]
else:
can_destroy[i] = can_destroy[max(0, i - power[i] - 1)] + 1
print(n - max(can_destroy))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/607/A"
} | |
d2194 | train | def main():
n = int(input())
scores = []
for i in range(n):
a = list(map(int, input().split()))
tot = sum(a)
scores.append((-tot, i))
scores.sort()
for i in range(n):
if scores[i][1] == 0:
print(i + 1)
main()
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1017/A"
} | |
d2195 | train | n = int(input())
pos,tree,ans,sz = list(map(int,input().split())) if n > 1 else [],[],[],[]
for i in range(n):
tree.append([])
ans.append(0.0)
sz.append(0)
for i in range(n-1):
tree[pos[i]-1].append(i+1)
for i in range(n)[::-1]:
sz[i] = 1
for to in tree[i]:
sz[i] += sz[to]
for i in range(n):
for to in tree[i]:
ans[to] = ans[i] + 1 + (sz[i]-1-sz[to]) * 0.5
st = lambda i: str(i+1)
print(' '.join(list(map(st,ans)))) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/696/B"
} | |
d2196 | train | from collections import Counter
n = int(input())
a = list(map(int, input().split()))
c = Counter(a)
res = 0
cur = 0
for i in sorted(c.keys()):
d = min(c[i], cur)
cur -= d
res += d
cur += c[i]
print(res) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1007/A"
} | |
d2197 | train | n, m = list(map(int, input().split()))
s = input()
p = c = 0
for i in range(1, n):
if s[i] == s[i - 1]:
c += n * (m - 1)
p = i
elif s[i] != s[i - 2]:
p = i - 1
c += i - p
ans = n * n * (m - 1) - c
print(ans)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/578/D"
} | |
d2198 | train | a = input()
b = a[::-1]
print(a + b) | PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/932/A"
} | |
d2199 | train | n = int(input())
s = set()
for a in range(n):
name = input()
name = name.replace('u', 'oo')
while (name.count('kh') > 0):
name = name.replace('kh', 'h')
s.add(name)
print(len(s))
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/883/F"
} | |
d2200 | train | import sys
input = sys.stdin.readline
n, k = list(map(int, input().split()))
begin = [-1] * n
end = [-1] * n
hurt = [-1] * n
adj = [[] for i in range(n)]
for _ in range(n-1):
u ,v = list(map(int, input().split()))
adj[u-1].append(v-1)
adj[v-1].append(u-1)
hurt[0] = 1
begin[0] = 0
stack = [0]
curr = 1
while stack:
nex = stack[-1]
if adj[nex]:
v = adj[nex].pop()
if begin[v] == -1:
begin[v] = curr
curr += 1
stack.append(v)
hurt[v] = len(stack)
else:
end[nex] = curr
stack.pop()
desc = [end[i] - begin[i]-hurt[i] for i in range(n)]
desc.sort(reverse = True)
out = 0
for i in range(n - k):
out += desc[i]
print(out)
| PYTHON | {
"starter_code": "",
"url": "https://codeforces.com/problemset/problem/1336/A"
} |
Subsets and Splits