message stringlengths 2 65.1k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 0 108k | cluster float64 14 14 | __index_level_0__ int64 0 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1. | instruction | 0 | 43,221 | 14 | 86,442 |
Tags: brute force, data structures, greedy, implementation, trees
Correct Solution:
```
def index_finder1(result):
for i in range (len(result)-1,-1,-1):
if result[i]=='.':
break
return (i+1)
def index_finder3(target,result):
temp=0
for i in range (len(result)):
j=result.find(target,i)
if j>temp:
temp=j
return temp
def index_finder2(item,result):
for i in reversed(result.split('.')):
if item-int(i)==1:
result=result[:index_finder3(i, result)]+str(item)
break
return result
# temp=None
# for j in range (len(result)-1,-1,-1):
# if result[j]=='.' and item-int(result[j+1:temp])==1:
# result=result[:j+1]+str(item)
# elif result[j]=='.':
# temp=j
# return result
t=int(input())
for i in range (t):
n=int(input())
shopping=[]
for i in range (n):
j=int(input())
shopping.append(j)
result=''
for i in range (n):
if i==0 and shopping[i]==1:
result=str(shopping[i])
elif shopping[i]==1:
result=result+'.1'
elif shopping[i]-shopping[i-1]==1:
if '.' not in result:
result=str(shopping[i])
else:
result=result[:index_finder1(result)]+str(shopping[i])
else:
result=index_finder2(shopping[i], result)
print(result)
# for j in range (len(result)-1,-1,-1):
#
# if result[j].isnumeric() and shopping[i]-int(result[j])==1:
# result=result[:j]+str(shopping[i])
# break
``` | output | 1 | 43,221 | 14 | 86,443 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1. | instruction | 0 | 43,222 | 14 | 86,444 |
Tags: brute force, data structures, greedy, implementation, trees
Correct Solution:
```
def prS():
print('.'.join(map(str, a)))
for _ in range(int(input())):
n = int(input())
l = []
for i in range(n):
l.append(int(input()))
a = [l[0]]
print(a[0])
for i in range(1, n):
if l[i] == 1:
a.append(1)
else:
while l[i] != a[-1] + 1:
del a[-1]
a[-1] = l[i]
prS()
``` | output | 1 | 43,222 | 14 | 86,445 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1. | instruction | 0 | 43,223 | 14 | 86,446 |
Tags: brute force, data structures, greedy, implementation, trees
Correct Solution:
```
ali=0;import sys;ali=0
ali=0;
ali=0;import io;ali=0
ali=0;
ali=0;import os;ali=0
ali=0;
ali=0;input = sys.stdin.readline;ali=0
ali=0;
ali=0;# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline;ali=0
ali=0;
ali=0;# print=sys.stdout.write;ali=0
ali=0;
ali=0;t = 1;ali=0
ali=0;
def get_list():
ali=0;return [int(i) for i in input().split()];ali=0
ali=0;
ali=0;inf = float('inf');ali=0
ali=0;
ali=0;t = int(input());ali=0
ali=0;
for i in range(t):
ali=0;n = int(input());ali=0
ali=0;
ali=0;l = [];ali=0
ali=0;
for i in range(n):
ali=0;l.append(int(input()));ali=0
ali=0;
ali=0;stack = [];ali=0
ali=0;
for i in range(n):
ali=0;
if l[i] == 1:
ali=0;stack.append(1);ali=0
ali=0;
else:
while stack and l[i] != stack[-1]+1:
ali=0;stack.pop();ali=0
ali=0;
ali=0;stack[-1] += 1;ali=0
ali=0;
ali=0;print(*stack, sep=".");ali=0
ali=0;
``` | output | 1 | 43,223 | 14 | 86,447 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1. | instruction | 0 | 43,224 | 14 | 86,448 |
Tags: brute force, data structures, greedy, implementation, trees
Correct Solution:
```
#from itertools import product
#from itertools import combinations
#from collections import Counter
#from collections import defaultdict
#from collections import deque # deque([iterable[, maxlen]]) #appendleft popleft rotate
#from heapq import heapify, heappop, heappush # func(heapifiedlist, item)
# sadness lies below
#from bisect import bisect_left, bisect_right, insort # func(sortedlist, item)
#from sys import setrecursionlimit
from sys import stdin, stderr
input = stdin.readline
def dbp(*args, **kwargs): # calling with dbp(locals()) is perfectly cromulent
print(*args, file=stderr, **kwargs)
def get_int_list():
return [int(x) for x in input().strip().split()]
def do_thing():
n = int(input())
last = []
for i in range(n):
end = int(input())
if not last:
print(end)
last = [end]
continue
if end == 1:
last.append(1)
print('.'.join(str(x) for x in last))
else:
ok = False
for idx in range(len(last)-1, -1, -1):
if last[idx] + 1 != end:
continue
last[idx] = end
last = last[:idx+1]
ok = True
break
if not ok:
raise Exception("couldna do it")
print('.'.join(str(x) for x in last))
def multicase():
maxcc = int(input().strip())
for cc in range(maxcc):
do_thing()
if __name__ == "__main__":
multicase()
#print(do_thing())
``` | output | 1 | 43,224 | 14 | 86,449 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1. | instruction | 0 | 43,225 | 14 | 86,450 |
Tags: brute force, data structures, greedy, implementation, trees
Correct Solution:
```
def divisors(M):
d=[]
i=1
while M>=i**2:
if M%i==0:
d.append(i)
if i**2!=M:
d.append(M//i)
i=i+1
return d
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
def eratosthenes(n):
res=[0 for i in range(n+1)]
prime=set([])
for i in range(2,n+1):
if not res[i]:
prime.add(i)
for j in range(1,n//i+1):
res[i*j]=1
return prime
def factorization(n):
res=[]
for p in prime:
if n%p==0:
while n%p==0:
n//=p
res.append(p)
if n!=1:
res.append(n)
return res
def euler_phi(n):
res = n
for x in range(2,n+1):
if x ** 2 > n:
break
if n%x==0:
res = res//x * (x-1)
while n%x==0:
n //= x
if n!=1:
res = res//n * (n-1)
return res
def ind(b,n):
res=0
while n%b==0:
res+=1
n//=b
return res
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 3, 5, 7, 11, 13, 17]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = (y * y) % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
from math import gcd
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i*i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += 1 + i % 2
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(n):
res = [1]
prime = primeFactor(n)
for p in prime:
newres = []
for d in res:
for j in range(prime[p]+1):
newres.append(d*p**j)
res = newres
res.sort()
return res
def xorfactorial(num):
if num==0:
return 0
elif num==1:
return 1
elif num==2:
return 3
elif num==3:
return 0
else:
x=baseorder(num)
return (2**x)*((num-2**x+1)%2)+function(num-2**x)
def xorconv(n,X,Y):
if n==0:
res=[(X[0]*Y[0])%mod]
return res
x=[X[i]+X[i+2**(n-1)] for i in range(2**(n-1))]
y=[Y[i]+Y[i+2**(n-1)] for i in range(2**(n-1))]
z=[X[i]-X[i+2**(n-1)] for i in range(2**(n-1))]
w=[Y[i]-Y[i+2**(n-1)] for i in range(2**(n-1))]
res1=xorconv(n-1,x,y)
res2=xorconv(n-1,z,w)
former=[(res1[i]+res2[i])*inv for i in range(2**(n-1))]
latter=[(res1[i]-res2[i])*inv for i in range(2**(n-1))]
former=list(map(lambda x:x%mod,former))
latter=list(map(lambda x:x%mod,latter))
return former+latter
def merge_sort(A,B):
pos_A,pos_B = 0,0
n,m = len(A),len(B)
res = []
while pos_A < n and pos_B < m:
a,b = A[pos_A],B[pos_B]
if a < b:
res.append(a)
pos_A += 1
else:
res.append(b)
pos_B += 1
res += A[pos_A:]
res += B[pos_B:]
return res
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
self.group = N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
stack = [x]
while self._parent[stack[-1]]!=stack[-1]:
stack.append(self._parent[stack[-1]])
for v in stack:
self._parent[v] = stack[-1]
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
self.group -= 1
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
class WeightedUnionFind():
def __init__(self,N):
self.parent = [i for i in range(N)]
self.size = [1 for i in range(N)]
self.val = [0 for i in range(N)]
self.flag = True
self.edge = [[] for i in range(N)]
def dfs(self,v,pv):
stack = [(v,pv)]
new_parent = self.parent[pv]
while stack:
v,pv = stack.pop()
self.parent[v] = new_parent
for nv,w in self.edge[v]:
if nv!=pv:
self.val[nv] = self.val[v] + w
stack.append((nv,v))
def unite(self,x,y,w):
if not self.flag:
return
if self.parent[x]==self.parent[y]:
self.flag = (self.val[x] - self.val[y] == w)
return
if self.size[self.parent[x]]>self.size[self.parent[y]]:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[x] += self.size[y]
self.val[y] = self.val[x] - w
self.dfs(y,x)
else:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[y] += self.size[x]
self.val[x] = self.val[y] + w
self.dfs(x,y)
class Dijkstra():
class Edge():
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
def __init__(self, V):
self.G = [[] for i in range(V)]
self._E = 0
self._V = V
@property
def E(self):
return self._E
@property
def V(self):
return self._V
def add_edge(self, _from, _to, _cost):
self.G[_from].append(self.Edge(_to, _cost))
self._E += 1
def shortest_path(self, s):
import heapq
que = []
d = [10**15] * self.V
d[s] = 0
heapq.heappush(que, (0, s))
while len(que) != 0:
cost, v = heapq.heappop(que)
if d[v] < cost: continue
for i in range(len(self.G[v])):
e = self.G[v][i]
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost
heapq.heappush(que, (d[e.to], e.to))
return d
#Z[i]:length of the longest list starting from S[i] which is also a prefix of S
#O(|S|)
def Z_algorithm(s):
N = len(s)
Z_alg = [0]*N
Z_alg[0] = N
i = 1
j = 0
while i < N:
while i+j < N and s[j] == s[i+j]:
j += 1
Z_alg[i] = j
if j == 0:
i += 1
continue
k = 1
while i+k < N and k + Z_alg[k]<j:
Z_alg[i+k] = Z_alg[k]
k += 1
i += k
j -= k
return Z_alg
class BIT():
def __init__(self,n,mod=0):
self.BIT = [0]*(n+1)
self.num = n
self.mod = mod
def query(self,idx):
res_sum = 0
mod = self.mod
while idx > 0:
res_sum += self.BIT[idx]
if mod:
res_sum %= mod
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
mod = self.mod
while idx <= self.num:
self.BIT[idx] += x
if mod:
self.BIT[idx] %= mod
idx += idx&(-idx)
return
class dancinglink():
def __init__(self,n,debug=False):
self.n = n
self.debug = debug
self._left = [i-1 for i in range(n)]
self._right = [i+1 for i in range(n)]
self.exist = [True for i in range(n)]
def pop(self,k):
if self.debug:
assert self.exist[k]
L = self._left[k]
R = self._right[k]
if L!=-1:
if R!=self.n:
self._right[L],self._left[R] = R,L
else:
self._right[L] = self.n
elif R!=self.n:
self._left[R] = -1
self.exist[k] = False
def left(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._left[res]
if res==-1:
break
k -= 1
return res
def right(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._right[res]
if res==self.n:
break
k -= 1
return res
class SparseTable():
def __init__(self,A,merge_func,ide_ele):
N=len(A)
n=N.bit_length()
self.table=[[ide_ele for i in range(n)] for i in range(N)]
self.merge_func=merge_func
for i in range(N):
self.table[i][0]=A[i]
for j in range(1,n):
for i in range(0,N-2**j+1):
f=self.table[i][j-1]
s=self.table[i+2**(j-1)][j-1]
self.table[i][j]=self.merge_func(f,s)
def query(self,s,t):
b=t-s+1
m=b.bit_length()-1
return self.merge_func(self.table[s][m],self.table[t-2**m+1][m])
class BinaryTrie:
class node:
def __init__(self,val):
self.left = None
self.right = None
self.max = val
def __init__(self):
self.root = self.node(-10**15)
def append(self,key,val):
pos = self.root
for i in range(29,-1,-1):
pos.max = max(pos.max,val)
if key>>i & 1:
if pos.right is None:
pos.right = self.node(val)
pos = pos.right
else:
pos = pos.right
else:
if pos.left is None:
pos.left = self.node(val)
pos = pos.left
else:
pos = pos.left
pos.max = max(pos.max,val)
def search(self,M,xor):
res = -10**15
pos = self.root
for i in range(29,-1,-1):
if pos is None:
break
if M>>i & 1:
if xor>>i & 1:
if pos.right:
res = max(res,pos.right.max)
pos = pos.left
else:
if pos.left:
res = max(res,pos.left.max)
pos = pos.right
else:
if xor>>i & 1:
pos = pos.right
else:
pos = pos.left
if pos:
res = max(res,pos.max)
return res
def solveequation(edge,ans,n,m):
#edge=[[to,dire,id]...]
x=[0]*m
used=[False]*n
for v in range(n):
if used[v]:
continue
y = dfs(v)
if y!=0:
return False
return x
def dfs(v):
used[v]=True
r=ans[v]
for to,dire,id in edge[v]:
if used[to]:
continue
y=dfs(to)
if dire==-1:
x[id]=y
else:
x[id]=-y
r+=y
return r
class SegmentTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
self.size = n
for i in range(n):
self.tree[self.num + i] = init_val[i]
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
if r==self.size:
r = self.num
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
def bisect_l(self,l,r,x):
l += self.num
r += self.num
Lmin = -1
Rmin = -1
while l<r:
if l & 1:
if self.tree[l] <= x and Lmin==-1:
Lmin = l
l += 1
if r & 1:
if self.tree[r-1] <=x:
Rmin = r-1
l >>= 1
r >>= 1
if Lmin != -1:
pos = Lmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
elif Rmin != -1:
pos = Rmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
else:
return -1
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import gcd,log
input = lambda :sys.stdin.readline().rstrip()
mi = lambda :map(int,input().split())
li = lambda :list(mi())
for _ in range(int(input())):
n = int(input())
a = [int(input()) for i in range(n)]
ans = [["1"] for i in range(n)]
for i in range(1,n):
if a[i]==1:
ans[i] = [s for s in ans[i-1]] + ["1"]
else:
m = len(ans[i-1])
for j in range(m-1,-1,-1):
if int(ans[i-1][j])+1==a[i]:
ans[i] = [ans[i-1][k] for k in range(j+1)]
ans[i][-1] = str(a[i])
break
for i in range(n):
print(".".join(ans[i]))
``` | output | 1 | 43,225 | 14 | 86,451 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1. | instruction | 0 | 43,226 | 14 | 86,452 |
Tags: brute force, data structures, greedy, implementation, trees
Correct Solution:
```
import bisect
import copy
import decimal
import fractions
import heapq
import itertools
import math
import random
import sys
from collections import Counter, deque,defaultdict
from functools import lru_cache,reduce
from heapq import heappush,heappop,heapify,_heappop_max,_heapify_max
def _heappush_max(heap,item):
heap.append(item)
heapq._siftdown_max(heap,0,len(heap)-1)
from math import gcd as Gcd
read=sys.stdin.read
readline=sys.stdin.readline
readlines=sys.stdin.readlines
t=int(readline())
for _ in range(t):
n=int(readline())
stack=[]
for _ in range(n):
i=int(readline())
if not stack:
stack.append(i)
elif stack[-1]+1==i:
stack[-1]+=1
elif i==1:
stack.append(i)
else:
while stack[-1]+1!=i:
stack.pop()
stack[-1]=i
print(*stack,sep='.')
``` | output | 1 | 43,226 | 14 | 86,453 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1. | instruction | 0 | 43,227 | 14 | 86,454 |
Tags: brute force, data structures, greedy, implementation, trees
Correct Solution:
```
#Fast I/O
import sys,os
import math
# To enable the file I/O i the below 2 lines are uncommented.
# read from in.txt if uncommented
if os.path.exists('in.txt'): sys.stdin=open('in.txt','r')
# will print on Console if file I/O is not activated
#if os.path.exists('out.txt'): sys.stdout=open('out.txt', 'w')
# inputs template
from io import BytesIO, IOBase
def main():
for _ in range(int(input())):
n=int(input())
if n==1:
print(int(input()))
continue
arr=[]
for i in range(n):
arr.append(int(input()))
def rec(i,lis):
if i==n:
return lis
else:
k,p=lis[-1],arr[i]
if p==1:
ans=rec(i+1,lis+[lis[-1]+".1"])
if ans:
return ans
j=-1
cur=""
while -j<=len(k):
if k[j]==".":
if int(cur)+1==p:
ans=rec(i+1,lis+[k[:j+1]+str(p)])
if ans:
return ans
cur=""
else:
cur=k[j]+cur
j-=1
if cur and int(cur)+1==p:
ans=rec(i+1,lis+[str(p)])
if ans:
return ans
for i in rec(1,["1"]):
print(i)
# Sample Inputs/Output
# 1
# 4
# 1
# 1
# 2
# 3
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#for array of integers
def MI():return (map(int,input().split()))
# endregion
#for fast output, always take string
def outP(var): sys.stdout.write(str(var)+'\n')
# end of any user-defined functions
MOD=10**9+7
mod=998244353
# main functions for execution of the program.
if __name__ == '__main__':
#This doesn't works here but works wonders when submitted on CodeChef or CodeForces
main()
``` | output | 1 | 43,227 | 14 | 86,455 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1. | instruction | 0 | 43,228 | 14 | 86,456 |
Tags: brute force, data structures, greedy, implementation, trees
Correct Solution:
```
import sys
import io, os
input = sys.stdin.buffer.readline
#input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
t = int(input())
for _ in range(t):
n = int(input())
A = [int(input()) for i in range(n)]
#print(A)
ans = []
for i, a in enumerate(A):
if i == 0:
ans.append(str(a))
else:
temp = ans[-1]
L = list(temp.split('.'))
p = -1
for j in range(len(L)):
if int(L[j]) == a-1:
p = j
if p != -1:
L = L[0:p]+[str(a)]
else:
L = L+[str(a)]
ans.append('.'.join(L))
for i in range(n):
print(ans[i])
``` | output | 1 | 43,228 | 14 | 86,457 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline()
# ------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# sys.setrecursionlimit(300000)
from heapq import *
from collections import deque as dq
from math import ceil,floor,sqrt,pow,factorial,log2
# import bisect as bs
from collections import Counter
# from collections import defaultdict as dc
for ii in range(N()):
n=N()
st=[]
for i in range(n):
a=N()
if(len(st)==0):
st.append(str(a))
print(a)
else:
if(a==1):
st.append("1")
print(".".join(st))
else:
while(a!=int(st[-1])+1):
st.pop()
st[-1]=str(int(st[-1])+1)
print(".".join(st))
``` | instruction | 0 | 43,229 | 14 | 86,458 |
Yes | output | 1 | 43,229 | 14 | 86,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1.
Submitted Solution:
```
for _ in range(int(input())):
x = int(input())
Ans = []
s = []
for i in range(x):
a = int(input())
if a == 1:
s.append(1)
Ans.append(list(s))
else:
while s[-1] != a - 1:
s.pop()
s[-1] += 1
Ans.append(list(s))
for i in range(len(Ans)):
for j in range(len(Ans[i])):
if j != len(Ans[i]) - 1:
print(Ans[i][j], '.', sep='', end='')
else:
print(Ans[i][j])
``` | instruction | 0 | 43,230 | 14 | 86,460 |
Yes | output | 1 | 43,230 | 14 | 86,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
arr = [int(input()) for i in range(n)]
ans = [['1']]
st = [['1']]
for i in arr[1:]:
if i==1:
p = st[-1][:]
st.append(p + ['.','1'])
ans.append(p + ['.','1'])
else:
v = 10**9
while st:
if int(st[-1][-1])==i:
v = len(st[-1])
st.pop()
elif i-int(st[-1][-1])==1:
if len(st[-1])<v:
break
else:
st.pop()
else:
st.pop()
if st:
p = st[-1][:]
p[-1] = str(i)
st.append(p)
ans.append(p)
else:
ans.append(str(i))
st.append(str(i))
for i in ans:
print(''.join(i))
``` | instruction | 0 | 43,231 | 14 | 86,462 |
Yes | output | 1 | 43,231 | 14 | 86,463 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
from collections import Counter
import math as mt
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)
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
def lcm(a, b):
return (a * b) / gcd(a, b)
mod = int(1e9) + 7
def power(k, n):
if n == 0:
return 1
if n % 2:
return (power(k, n - 1) * k) % mod
t = power(k, n // 2)
return (t * t) % mod
def totalPrimeFactors(n):
count = 0
if (n % 2) == 0:
count += 1
while (n % 2) == 0:
n //= 2
i = 3
while i * i <= n:
if (n % i) == 0:
count += 1
while (n % i) == 0:
n //= i
i += 2
if n > 2:
count += 1
return count
# #MAXN = int(1e7 + 1)
# # spf = [0 for i in range(MAXN)]
#
#
# def sieve():
# spf[1] = 1
# for i in range(2, MAXN):
# spf[i] = i
# for i in range(4, MAXN, 2):
# spf[i] = 2
#
# for i in range(3, mt.ceil(mt.sqrt(MAXN))):
# if (spf[i] == i):
# for j in range(i * i, MAXN, i):
# if (spf[j] == j):
# spf[j] = i
#
#
# def getFactorization(x):
# ret = 0
# while (x != 1):
# k = spf[x]
# ret += 1
# # ret.add(spf[x])
# while x % k == 0:
# x //= k
#
# return ret
# Driver code
# precalculating Smallest Prime Factor
# sieve()
def main():
for _ in range(int(input())):
n=int(input())
a=[]
for i in range(n):
a.append(int(input()))
ans=[[-1 for i in range(n+1)] for j in range(n+1)]
x=0
y=0
ans[x][y]=1
for i in range(1, n):
if a[i]==1:
for j in range(n):
if ans[i-1][j]==-1:
ans[i][j]=1
break
ans[i][j]=ans[i-1][j]
else:
y=-1
z=-1
for j in range(n-1, -1, -1):
if ans[i-1][j]==a[i]-1:
y=j
break
if ans[i-1][j]!=-1 and z!=-1:
z=j
if y!=-1:
for j in range(y):
ans[i][j]=ans[i-1][j]
ans[i][y]=ans[i-1][y]+1
else:
ans[i][z+1]=a[i]
for j in range(z+1):
ans[i][j] = ans[i - 1][j]
#print(ans)
for i in range(n):
for j in range(n):
if ans[i][j]==-1:
break
if j==0:
print(str(ans[i][j]), end='')
else:
print('.'+str(ans[i][j]), end='')
print('')
return
if __name__ == "__main__":
main()
``` | instruction | 0 | 43,232 | 14 | 86,464 |
Yes | output | 1 | 43,232 | 14 | 86,465 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1.
Submitted Solution:
```
import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from collections import Counter
from collections import defaultdict as dd
# sys.setrecursionlimit(100000000)
flush = lambda: stdout.flush()
stdstr = lambda: stdin.readline()
stdint = lambda: int(stdin.readline())
stdpr = lambda x: stdout.write(str(x))
stdmap = lambda: map(int, stdstr().split())
stdarr = lambda: list(map(int, stdstr().split()))
mod = 1000000007
for _ in range(stdint()):
n = stdint()
lasts = []
for i in range(n):
lasts.append(stdint())
res = [["1"]]
done = dd(bool)
done[("1",)] = True
indx = dd(list)
indx[1].append(0)
for i in range(1, n):
curr = lasts[i]
if(curr == 1):
ne = res[-1].copy()
ne.append(str(curr))
done[tuple(ne)] = True
res.append(ne)
indx[curr].append(i)
else:
prev = curr-1
l = indx[prev]
# print(l)
for j in range(len(l)-1, -1, -1):
tx = res[l[j]].copy()[:-1]
tx.append(str(curr))
if(not done[tuple(tx)]):
res.append(tx)
done[tuple(tx)] = True
indx[curr].append(i)
break
# print(res)
for i in res:
print(".".join(i))
``` | instruction | 0 | 43,233 | 14 | 86,466 |
No | output | 1 | 43,233 | 14 | 86,467 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1.
Submitted Solution:
```
a=int(input())
from collections import *
from heapq import *
for i in range(a):
al=defaultdict(list)
n=int(input())
ans=[]
for i in range(n):
s=int(input())
ans.append(s)
for j in range(len(ans)):
value=ans[j]
# print(value,'saf')
if(len(al[value])==0):
g1=[value]
g2=[value]
if(value==1):
# al[value].append(g1)
heappush(al[value],g1)
#al[value+1].append(g2)
heappush(al[value+1],g2)
print(value)
continue;
else:
alpha=al[value][0]
alpha.append(value)
heappop(al[value])
if(value==1):
al[value].append(alpha)
heappush(al[value],alpha)
ts=[]
for i in range(len(alpha)):
ts.append(alpha[i])
heappush(al[value+1],ts)
# al[value+1].append(ts)
for i in range(len(alpha)):
print(alpha[i],end="")
if(i!=len(alpha)-1):
print('.',end="")
else:
print('')
``` | instruction | 0 | 43,234 | 14 | 86,468 |
No | output | 1 | 43,234 | 14 | 86,469 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1.
Submitted Solution:
```
from copy import deepcopy
import os
import sys
from io import BytesIO,IOBase
from functools import lru_cache,reduce
import heapq
import cProfile
from collections import Counter, defaultdict, deque
from bisect import bisect,bisect_left,bisect_right
import math
import threading
import time
# shortcut for functions
def I(): return input()
def get_int(): return int(input())
def get_list(): return list(map(int, input().split())) # int list
def get_map(): return map(int, input().split()) # int map
def get_list_str(li, s=' '): print(s.join(map(str, li))) # non string list
# Region fastio functions
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
def solve():
n = get_int()
ls = []
for _ in range(n):
x = get_int()
ls.append(x)
prev = ls[0]
ans = [str(ls[0])]
stack = [ls[0]]
for i in range(1,n):
if ls[i]>prev:
stack[-1] = ls[i]
elif ls[i]=="1":
stack.append(ls[i])
else:
while stack:
top = stack.pop(-1)
if ls[i]>top:
stack.append(top)
if not stack:
stack.append(top+1)
stack.append(ls[i])
prev = ls[i]
res = ".".join([str(val) for val in stack])
ans.append(res)
for val in ans:
print(val)
def main():
testcases = True
if testcases:
t = get_int()
for _ in range(t):
solve()
else:
solve()
if __name__ == "__main__":
main()
``` | instruction | 0 | 43,235 | 14 | 86,470 |
No | output | 1 | 43,235 | 14 | 86,471 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.
A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 . a_2 . a_3 . ⋅⋅⋅ .\,a_k and can be one of two types:
1. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . a_k . 1 (starting a list of a deeper level), or
2. Add an item a_1 . a_2 . a_3 . ⋅⋅⋅ . (a_k + 1) (continuing the current level).
Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.
When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.
William wants you to help him restore a fitting original nested list.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10). Description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3), which is the number of lines in the list.
Each of the next n lines contains a single integer a_i (1 ≤ a_i ≤ n), which is what remains of William's nested list.
It is guaranteed that in each test case at least one fitting list exists.
It is guaranteed that the sum of values n across all test cases does not exceed 10^3.
Output
For each test case output n lines which represent a valid nested list, which could become the data provided to you by William.
If there are multiple answers, print any.
Example
Input
2
4
1
1
2
3
9
1
1
1
2
2
1
2
1
2
Output
1
1.1
1.2
1.3
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
Note
In the second example test case one example of a fitting list is:
1
1.1
1.1.1
1.1.2
1.2
1.2.1
2
2.1
2.2
This list can be produced by using the sequence of operations shown below: <image>
1. Original list with a single item 1.
2. Insert item 2 by using the insertion operation of the second type after item 1.
3. Insert item 1.1 by using the insertion operation of the first type after item 1.
4. Insert item 1.2 by using the insertion operation of the second type after item 1.1.
5. Insert item 1.1.1 by using the insertion operation of the first type after item 1.1.
6. Insert item 1.1.2 by using the insertion operation of the second type after item 1.1.1.
7. Insert item 1.2.1 by using the insertion operation of the first type after item 1.2.
8. Insert item 2.1 by using the insertion operation of the first type after item 2.
9. Insert item 2.2 by using the insertion operation of the second type after item 2.1.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#######################################
from collections import defaultdict as dd
for t in range(int(input())):
n=int(input())
l=[]
for i in range(n):
l.append(int(input()))
ans=['1']
d=dd(int)
d['1']=1
for i in range(1,n):
if l[i]==1:
ans.append(ans[-1]+'.1')
d[ans[-1]+'.1']=1
else:
ind=0
s=str(l[i])
for j in range(len(ans)):
if str(l[i]-1) in ans[j]:
for k in range(len(ans[j])-1,ind,-1):
if ans[j][k]==str(l[i]-1):
x=ans[j][:k]+str(l[i])
if not d[x]:
if k>ind:
ind=k
s=x
ans.append(s)
d[s]=1
for i in ans:
print(i)
``` | instruction | 0 | 43,236 | 14 | 86,472 |
No | output | 1 | 43,236 | 14 | 86,473 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings.
More formally, for each invited person the following conditions should be fulfilled:
* all his friends should also be invited to the party;
* the party shouldn't have any people he dislikes;
* all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 ≤ i < p) are friends.
Help the Beaver find the maximum number of acquaintances he can invite.
Input
The first line of input contains an integer n — the number of the Beaver's acquaintances.
The second line contains an integer k <image> — the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> — indices of people who form the i-th pair of friends.
The next line contains an integer m <image> — the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described.
Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 14
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 2000
Output
Output a single number — the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0.
Examples
Input
9
8
1 2
1 3
2 3
4 5
6 7
7 8
8 9
9 6
2
1 6
7 9
Output
3
Note
Let's have a look at the example.
<image>
Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected). | instruction | 0 | 43,253 | 14 | 86,506 |
Tags: brute force, dfs and similar, dsu, graphs
Correct Solution:
```
n = int(input())
num_likes = int(input())
like = [ [] for u in range(n + 1) ]
for i in range(num_likes):
u, v = map(int, input().split())
like[u].append(v)
like[v].append(u)
num_dislikes = int(input())
dislike = [ (n + 1) * [ False ] for u in range(n + 1) ]
for i in range(num_dislikes):
u, v = map(int, input().split())
dislike[u][v] = True
dislike[v][u] = True
result = 0
seen = (n + 1) * [ False ]
for u in range(1, n + 1):
if seen[u]:
continue
seen[u] = True
group = [ u ]
queue = [ u ]
tail = 0
while tail < len(queue):
u = queue[tail]
tail += 1
for v in like[u]:
if seen[v]:
continue
seen[v] = True
group.append(v)
queue.append(v)
okay = True
for i, u in enumerate(group):
for j in range(i + 1, len(group)):
v = group[j]
if dislike[u][v]:
okay = False
break
if not okay:
break
if okay:
result = max(result, len(group))
print(result)
``` | output | 1 | 43,253 | 14 | 86,507 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings.
More formally, for each invited person the following conditions should be fulfilled:
* all his friends should also be invited to the party;
* the party shouldn't have any people he dislikes;
* all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 ≤ i < p) are friends.
Help the Beaver find the maximum number of acquaintances he can invite.
Input
The first line of input contains an integer n — the number of the Beaver's acquaintances.
The second line contains an integer k <image> — the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> — indices of people who form the i-th pair of friends.
The next line contains an integer m <image> — the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described.
Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 14
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 2000
Output
Output a single number — the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0.
Examples
Input
9
8
1 2
1 3
2 3
4 5
6 7
7 8
8 9
9 6
2
1 6
7 9
Output
3
Note
Let's have a look at the example.
<image>
Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected). | instruction | 0 | 43,254 | 14 | 86,508 |
Tags: brute force, dfs and similar, dsu, graphs
Correct Solution:
```
# maa chudaaye duniya
n = int(input())
parents = [i for i in range(n+1)]
ranks = [1 for i in range(n+1)]
def find(x):
if parents[x] != x:
parents[x] = find(parents[x])
return parents[x]
def union(x, y):
xs = find(x)
ys = find(y)
if xs == ys:
return
if ranks[xs] > ranks[ys]:
parents[ys] = xs
elif ranks[ys] > ranks[xs]:
parents[xs] = ys
else:
parents[ys] = xs
ranks[xs] += 1
for _ in range(int(input())):
u, v = map(int, input().split())
union(u, v)
# print(parents)
rejects = set([])
for _ in range(int(input())):
p, q = map(int, input().split())
ps = find(p)
qs = find(q)
if ps == qs:
rejects.add(ps)
ps = {}
for i in range(1, n+1):
p = find(i)
if p not in rejects:
if p in ps:
ps[p] += 1
else:
ps[p] = 1
# print(ps)
ans = 0
for i in ps:
ans = max(ans, ps[i])
print(ans)
``` | output | 1 | 43,254 | 14 | 86,509 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings.
More formally, for each invited person the following conditions should be fulfilled:
* all his friends should also be invited to the party;
* the party shouldn't have any people he dislikes;
* all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 ≤ i < p) are friends.
Help the Beaver find the maximum number of acquaintances he can invite.
Input
The first line of input contains an integer n — the number of the Beaver's acquaintances.
The second line contains an integer k <image> — the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> — indices of people who form the i-th pair of friends.
The next line contains an integer m <image> — the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described.
Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 14
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 2000
Output
Output a single number — the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0.
Examples
Input
9
8
1 2
1 3
2 3
4 5
6 7
7 8
8 9
9 6
2
1 6
7 9
Output
3
Note
Let's have a look at the example.
<image>
Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected). | instruction | 0 | 43,255 | 14 | 86,510 |
Tags: brute force, dfs and similar, dsu, graphs
Correct Solution:
```
from collections import defaultdict
def Root(child):
while(Parent[child]!=child):
child = Parent[child]
return child
def Union(a,b):
root_a = Root(a)
root_b = Root(b)
if(root_a!=root_b):
if(Size[root_a]<Size[root_b]):
Parent[root_a] = root_b
Size[root_b]+=Size[root_a]
else:
Parent[root_b] = root_a
Size[root_a]+=Size[root_b]
return 1
return 0
n = int(input())
Parent = [i for i in range(n)]
Size = [1 for i in range(n)]
k = int(input())
for i in range(k):
u,v = map(int,input().split())
u-=1;v-=1
Union(u,v)
m = int(input())
for i in range(m):
u,v = map(int,input().split())
root_u = Root(u-1)
root_v = Root(v-1)
if(root_u==root_v):
Size[root_u] = 0
Max = -float('inf')
for i in range(n):
Max = max(Max,Size[Root(i)])
print(Max)
``` | output | 1 | 43,255 | 14 | 86,511 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings.
More formally, for each invited person the following conditions should be fulfilled:
* all his friends should also be invited to the party;
* the party shouldn't have any people he dislikes;
* all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 ≤ i < p) are friends.
Help the Beaver find the maximum number of acquaintances he can invite.
Input
The first line of input contains an integer n — the number of the Beaver's acquaintances.
The second line contains an integer k <image> — the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> — indices of people who form the i-th pair of friends.
The next line contains an integer m <image> — the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described.
Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 14
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 2000
Output
Output a single number — the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0.
Examples
Input
9
8
1 2
1 3
2 3
4 5
6 7
7 8
8 9
9 6
2
1 6
7 9
Output
3
Note
Let's have a look at the example.
<image>
Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected). | instruction | 0 | 43,256 | 14 | 86,512 |
Tags: brute force, dfs and similar, dsu, graphs
Correct Solution:
```
t, p, k = [0] * (int(input()) + 1), {0: []}, 1
for i in range(int(input())):
a, b = map(int, input().split())
if t[a] == t[b]:
if t[a] == 0:
t[a] = t[b] = k
p[k] = [a, b]
k += 1
else:
if t[a] == 0:
t[a] = t[b]
p[t[b]].append(a)
elif t[b] == 0:
t[b] = t[a]
p[t[a]].append(b)
else:
x, y = t[b], t[a]
for c in p[x]:
t[c] = y
p[y] += p[x]
p[x] = []
for i in range(int(input())):
a, b = map(int, input().split())
if t[a] == t[b]: p[t[a]] = []
ans = max(map(len, p.values()))
if ans == 0: ans = int(0 in t[1:])
print(ans)
``` | output | 1 | 43,256 | 14 | 86,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings.
More formally, for each invited person the following conditions should be fulfilled:
* all his friends should also be invited to the party;
* the party shouldn't have any people he dislikes;
* all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 ≤ i < p) are friends.
Help the Beaver find the maximum number of acquaintances he can invite.
Input
The first line of input contains an integer n — the number of the Beaver's acquaintances.
The second line contains an integer k <image> — the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> — indices of people who form the i-th pair of friends.
The next line contains an integer m <image> — the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described.
Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 14
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 2000
Output
Output a single number — the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0.
Examples
Input
9
8
1 2
1 3
2 3
4 5
6 7
7 8
8 9
9 6
2
1 6
7 9
Output
3
Note
Let's have a look at the example.
<image>
Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected). | instruction | 0 | 43,257 | 14 | 86,514 |
Tags: brute force, dfs and similar, dsu, graphs
Correct Solution:
```
from sys import setrecursionlimit
setrecursionlimit(10 ** 9)
def dfs(g, col, st):
global used
used[st] = col
for w in g[st]:
if used[w] is False:
dfs(g, col, w)
n = int(input())
k = int(input())
g = []
used = [False] * n
for i in range(n):
g.append([])
for i in range(k):
x, y = map(int, input().split())
g[x - 1].append(y - 1)
g[y - 1].append(x - 1)
cur = 0
for i in range(n):
if used[i] is False:
dfs(g, cur, i)
cur += 1
k = int(input())
lst = [0] * n
for i in range(k):
x, y = map(int, input().split())
x -= 1
y -= 1
if used[x] == used[y]:
lst[used[x]] = -1
for i in range(n):
if lst[used[i]] != -1:
lst[used[i]] += 1
print(max(0, max(lst)))
``` | output | 1 | 43,257 | 14 | 86,515 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings.
More formally, for each invited person the following conditions should be fulfilled:
* all his friends should also be invited to the party;
* the party shouldn't have any people he dislikes;
* all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 ≤ i < p) are friends.
Help the Beaver find the maximum number of acquaintances he can invite.
Input
The first line of input contains an integer n — the number of the Beaver's acquaintances.
The second line contains an integer k <image> — the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> — indices of people who form the i-th pair of friends.
The next line contains an integer m <image> — the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described.
Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 14
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 2000
Output
Output a single number — the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0.
Examples
Input
9
8
1 2
1 3
2 3
4 5
6 7
7 8
8 9
9 6
2
1 6
7 9
Output
3
Note
Let's have a look at the example.
<image>
Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected). | instruction | 0 | 43,258 | 14 | 86,516 |
Tags: brute force, dfs and similar, dsu, graphs
Correct Solution:
```
t, p, k = [0] * (int(input()) + 1), {0: []}, 1
for i in range(int(input())):
a, b = map(int, input().split())
if t[a] == t[b]:
if t[a] == 0:
t[a] = t[b] = k
p[k] = [a, b]
k += 1
else:
if t[a] == 0:
t[a] = t[b]
p[t[b]].append(a)
elif t[b] == 0:
t[b] = t[a]
p[t[a]].append(b)
else:
x, y = t[b], t[a]
for c in p[x]:
t[c] = y
p[y] += p[x]
p[x] = []
for i in range(int(input())):
a, b = map(int, input().split())
if t[a] == t[b]: p[t[a]] = []
ans = max(len(p[i]) for i in p)
print(ans if ans > 0 else int(0 in t[1:]))
``` | output | 1 | 43,258 | 14 | 86,517 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings.
More formally, for each invited person the following conditions should be fulfilled:
* all his friends should also be invited to the party;
* the party shouldn't have any people he dislikes;
* all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 ≤ i < p) are friends.
Help the Beaver find the maximum number of acquaintances he can invite.
Input
The first line of input contains an integer n — the number of the Beaver's acquaintances.
The second line contains an integer k <image> — the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> — indices of people who form the i-th pair of friends.
The next line contains an integer m <image> — the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described.
Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 14
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 2000
Output
Output a single number — the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0.
Examples
Input
9
8
1 2
1 3
2 3
4 5
6 7
7 8
8 9
9 6
2
1 6
7 9
Output
3
Note
Let's have a look at the example.
<image>
Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected). | instruction | 0 | 43,259 | 14 | 86,518 |
Tags: brute force, dfs and similar, dsu, graphs
Correct Solution:
```
class DisjointSetStructure():
def __init__(self, n):
self.A = [[i,0,1] for i in range(n)]
self.size = n
def getpair(self, i):
p = i
while self.A[p][0] != p: p = self.A[p][0]
j = self.A[i][0]
while j != p:
self.A[i][0] = p
i, j = j, self.A[j][0]
return (p, self.A[p][2])
def __getitem__(self, i):
return self.getpair(i)[0]
def union(self, i, j):
u, v = self[i], self[j]
if u == v: return
self.size -= 1
if self.A[u][1] > self.A[v][1]:
self.A[v][0] = u
self.A[u][2] += self.A[v][2]
else:
self.A[u][0] = v
self.A[v][2] += self.A[u][2]
if self.A[u][1] == self.A[v][1]:
self.A[v][1] += 1
def __len__(self): return self.size
n = int(input())
k = int(input())
D = DisjointSetStructure(n)
for i in range(k):
u, v = [int(x) - 1 for x in input().split()]
D.union(u, v)
l = int(input())
friendly = [True for i in range(n)]
for i in range(l):
u, v = [int(x) - 1 for x in input().split()]
if D[u] == D[v]: friendly[D[u]] = False
print(max(D.getpair(i)[1] if friendly[D[i]] else 0 for i in range(n)))
``` | output | 1 | 43,259 | 14 | 86,519 |
Provide tags and a correct Python 3 solution for this coding contest problem.
To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings.
More formally, for each invited person the following conditions should be fulfilled:
* all his friends should also be invited to the party;
* the party shouldn't have any people he dislikes;
* all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 ≤ i < p) are friends.
Help the Beaver find the maximum number of acquaintances he can invite.
Input
The first line of input contains an integer n — the number of the Beaver's acquaintances.
The second line contains an integer k <image> — the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> — indices of people who form the i-th pair of friends.
The next line contains an integer m <image> — the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described.
Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 14
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 2000
Output
Output a single number — the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0.
Examples
Input
9
8
1 2
1 3
2 3
4 5
6 7
7 8
8 9
9 6
2
1 6
7 9
Output
3
Note
Let's have a look at the example.
<image>
Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected). | instruction | 0 | 43,260 | 14 | 86,520 |
Tags: brute force, dfs and similar, dsu, graphs
Correct Solution:
```
def find(a):
if parent[a]!=a:
parent[a]=find(parent[a])
return parent[a]
def union(a,b):
u,v=find(a),find(b)
if u==v:
return
if rank[u]>rank[v]:
parent[v]=u
else:
parent[u]=v
if rank[u]==rank[v]:
rank[v]+=1
n=int(input())
k=int(input())
parent=list(map(int,range(n+1)))
rank=[0]*(n+1)
ans=[0]*(n+1)
count=[0]*(n+1)
for i in range(k):
u,v=map(int,input().split())
union(u,v)
for i in range(len(ans)):
ans[find(i)]+=1
for i in range(len(parent)):
count[parent[i]]+=1
d={}
m=int(input())
for i in range(m):
u,v=map(int,input().split())
if parent[u]==parent[v]:
d[parent[u]]=False
sak=0
for i in range(len(count)):
if count[i]!=0 and i not in d and i!=0:
sak=max(sak,count[i])
print(sak)
``` | output | 1 | 43,260 | 14 | 86,521 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings.
More formally, for each invited person the following conditions should be fulfilled:
* all his friends should also be invited to the party;
* the party shouldn't have any people he dislikes;
* all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 ≤ i < p) are friends.
Help the Beaver find the maximum number of acquaintances he can invite.
Input
The first line of input contains an integer n — the number of the Beaver's acquaintances.
The second line contains an integer k <image> — the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> — indices of people who form the i-th pair of friends.
The next line contains an integer m <image> — the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described.
Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 14
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 2000
Output
Output a single number — the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0.
Examples
Input
9
8
1 2
1 3
2 3
4 5
6 7
7 8
8 9
9 6
2
1 6
7 9
Output
3
Note
Let's have a look at the example.
<image>
Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected).
Submitted Solution:
```
n = int(input())
l = int(input())
likes_list = [[] for i in range(n + 1)]
for i in range(l):
a, b = map(int, input().split())
likes_list[a].append(b)
likes_list[b].append(a)
d = int(input())
dislikes_list = [[] for i in range(n + 1)]
for i in range(d):
a, b = map(int, input().split())
dislikes_list[a].append(b)
dislikes_list[b].append(a)
v = [False] * (n + 1)
groups = {}
f_id = [i for i in range(n + 1)]
for i in range(1, n + 1):
if not v[i]:
f = set()
s = [i]
while len(s) > 0:
x = s.pop()
f_id[x] = i
f.add(x)
if v[x]:
continue
v[x] = True
for y in likes_list[x]:
s.append(y)
groups[i] = f
for i in range(1, n + 1):
for ds in dislikes_list[i]:
groups[f_id[i]].difference_update({ds}.union(groups[f_id[ds]]))
ans = 0
for v in groups.values():
ans = max(ans, len(v))
print(ans)
``` | instruction | 0 | 43,261 | 14 | 86,522 |
Yes | output | 1 | 43,261 | 14 | 86,523 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings.
More formally, for each invited person the following conditions should be fulfilled:
* all his friends should also be invited to the party;
* the party shouldn't have any people he dislikes;
* all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 ≤ i < p) are friends.
Help the Beaver find the maximum number of acquaintances he can invite.
Input
The first line of input contains an integer n — the number of the Beaver's acquaintances.
The second line contains an integer k <image> — the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> — indices of people who form the i-th pair of friends.
The next line contains an integer m <image> — the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described.
Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 14
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 2000
Output
Output a single number — the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0.
Examples
Input
9
8
1 2
1 3
2 3
4 5
6 7
7 8
8 9
9 6
2
1 6
7 9
Output
3
Note
Let's have a look at the example.
<image>
Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected).
Submitted Solution:
```
from sys import stdin, stdout
def find(node):
x = []
while dsu[node] > 0:
x.append(node)
node = dsu[node]
for i in x:
dsu[i] = node
return node
def union(node1, node2):
if node1 != node2:
if dsu[node1] > dsu[node2]:
node1, node2 = node2, node1
dsu[node1] += dsu[node2]
dsu[node2] = node1
n = int(stdin.readline().strip())
dsu = [-1]*(n+1)
m = int(stdin.readline().strip())
for __ in range(m):
a, b = map(int, stdin.readline().strip().split())
union(find(a), find(b))
k = int(stdin.readline().strip())
for __ in range(k):
a, b = map(int, stdin.readline().strip().split())
p_a = find(a)
p_b = find(b)
if p_a == p_b:
dsu[p_a] = 0
maxm = 0
for i in range(1, n+1):
if dsu[i] < 0:
maxm = max(maxm, abs(dsu[i]))
stdout.write(f'{maxm}')
``` | instruction | 0 | 43,262 | 14 | 86,524 |
Yes | output | 1 | 43,262 | 14 | 86,525 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings.
More formally, for each invited person the following conditions should be fulfilled:
* all his friends should also be invited to the party;
* the party shouldn't have any people he dislikes;
* all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 ≤ i < p) are friends.
Help the Beaver find the maximum number of acquaintances he can invite.
Input
The first line of input contains an integer n — the number of the Beaver's acquaintances.
The second line contains an integer k <image> — the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> — indices of people who form the i-th pair of friends.
The next line contains an integer m <image> — the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described.
Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 14
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 2000
Output
Output a single number — the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0.
Examples
Input
9
8
1 2
1 3
2 3
4 5
6 7
7 8
8 9
9 6
2
1 6
7 9
Output
3
Note
Let's have a look at the example.
<image>
Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected).
Submitted Solution:
```
from collections import defaultdict
def Root(child):
while(Parent[child]!=child):
child = Parent[child]
return child
def Union(a,b):
root_a = Root(a)
root_b = Root(b)
# print(a,root_a,b,root_b)
if(root_a!=root_b):
if(Size[root_a]<Size[root_b]):
Parent[root_a] = root_b
Size[root_b]+=Size[root_a]
else:
Parent[root_b] = root_a
Size[root_a]+=Size[root_b]
return 1
return 0
n = int(input())
Parent = [i for i in range(n)]
Size = [1 for i in range(n)]
k = int(input())
for i in range(k):
u,v = map(int,input().split())
u-=1;v-=1
Union(u,v)
m = int(input())
for i in range(m):
u,v = map(int,input().split())
root_u = Root(u-1)
root_v = Root(v-1)
if(root_u==root_v):
Size[root_u] = 1
print(max(Size))
``` | instruction | 0 | 43,263 | 14 | 86,526 |
No | output | 1 | 43,263 | 14 | 86,527 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
To celebrate the second ABBYY Cup tournament, the Smart Beaver decided to throw a party. The Beaver has a lot of acquaintances, some of them are friends with each other, and some of them dislike each other. To make party successful, the Smart Beaver wants to invite only those of his friends who are connected by friendship relations, and not to invite those who dislike each other. Both friendship and dislike are mutual feelings.
More formally, for each invited person the following conditions should be fulfilled:
* all his friends should also be invited to the party;
* the party shouldn't have any people he dislikes;
* all people who are invited to the party should be connected with him by friendship either directly or through a chain of common friends of arbitrary length. We'll say that people a1 and ap are connected through a chain of common friends if there exists a sequence of people a2, a3, ..., ap - 1 such that all pairs of people ai and ai + 1 (1 ≤ i < p) are friends.
Help the Beaver find the maximum number of acquaintances he can invite.
Input
The first line of input contains an integer n — the number of the Beaver's acquaintances.
The second line contains an integer k <image> — the number of pairs of friends. Next k lines contain space-separated pairs of integers ui, vi <image> — indices of people who form the i-th pair of friends.
The next line contains an integer m <image> — the number of pairs of people who dislike each other. Next m lines describe pairs of people who dislike each other in the same format as the pairs of friends were described.
Each pair of people is mentioned in the input at most once <image>. In particular, two persons cannot be friends and dislike each other at the same time.
The input limitations for getting 30 points are:
* 2 ≤ n ≤ 14
The input limitations for getting 100 points are:
* 2 ≤ n ≤ 2000
Output
Output a single number — the maximum number of people that can be invited to the party. If a group of people that meets all the requirements is impossible to select, output 0.
Examples
Input
9
8
1 2
1 3
2 3
4 5
6 7
7 8
8 9
9 6
2
1 6
7 9
Output
3
Note
Let's have a look at the example.
<image>
Two groups of people can be invited: {1, 2, 3} and {4, 5}, thus the answer will be the size of the largest of these groups. Group {6, 7, 8, 9} doesn't fit, since it includes people 7 and 9 who dislike each other. Group {1, 2, 3, 4, 5} also doesn't fit, because not all of its members are connected by a chain of common friends (for example, people 2 and 5 aren't connected).
Submitted Solution:
```
def find(a):
if parent[a]!=a:
parent[a]=find(parent[a])
return parent[a]
def union(a,b):
u,v=find(a),find(b)
if u==v:
return
if rank[u]>rank[v]:
parent[v]=u
else:
parent[u]=v
if rank[u]==rank[v]:
rank[v]+=1
n=int(input())
k=int(input())
parent=list(map(int,range(n+1)))
rank=[0]*(n+1)
ans=[0]*(n+1)
count=[0]*(n+1)
for i in range(k):
u,v=map(int,input().split())
union(u,v)
for i in range(len(ans)):
ans[find(i)]+=1
for i in range(len(parent)):
count[parent[i]]+=1
d={}
m=int(input())
for i in range(m):
u,v=map(int,input().split())
if parent[u]==parent[v]:
d[parent[u]]=False
sak=0
for i in range(len(count)):
if count[i]!=0 and i not in d:
sak=max(sak,count[i])
print(sak)
``` | instruction | 0 | 43,264 | 14 | 86,528 |
No | output | 1 | 43,264 | 14 | 86,529 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A system of n vessels with water is given. Several pairs of vessels are connected by tubes with transfusion mechanisms. One may transfer an integer amount of liters of water between two vessels connected by such tube (tube works in both directions). There might be multiple tubes between two vessels. Total number of tubes equals e. Volume of each vessel equals v liters. Of course, the amount of the water in any vessel cannot exceed v liters in the process of transfusions.
Given the initial amounts ai of water in the vessels and the desired amounts bi find a sequence of transfusions that deals with the task. Total number of transfusions must not exceed 2·n2.
Input
First line of the input contains integers n, v, e (1 ≤ n ≤ 300, 1 ≤ v ≤ 109, 0 ≤ e ≤ 50000).
Next two lines contain n integers each: initial ai and the desired amounts bi of water in corresponding vessels (0 ≤ ai, bi ≤ v).
Next e lines describe one tube each in the format x y (1 ≤ x, y ≤ n, x ≠ y) for a tube between vessels number x and y. There might be multiple tubes between two vessels. You may assume that vessels are numbered from 1 to n in some way.
Output
Print "NO" (without quotes), if such sequence of transfusions does not exist.
Otherwise print any suitable sequence in the following format. On the first line print the total number of transfusions k (k should not exceed 2·n2). In the following k lines print transfusions in the format x y d (transfusion of d liters from the vessel number x to the vessel number y, x and y must be distinct). For all transfusions d must be a non-negative integer.
Examples
Input
2 10 1
1 9
5 5
1 2
Output
1
2 1 4
Input
2 10 0
5 2
4 2
Output
NO
Input
2 10 0
4 2
4 2
Output
0 | instruction | 0 | 43,300 | 14 | 86,600 |
Tags: constructive algorithms, dfs and similar, graphs, trees
Correct Solution:
```
read = lambda: map(int, input().split())
n, v, e = read()
adj = [[] for _ in range(n + 1)]
As = [0] + list(read())
Bs = [0] + list(read())
ans = []
for _ in range(e):
a, b = map(int, input().split())
adj[a].append(b)
adj[b].append(a)
def flow(a, b, d):
As[a] -= d
As[b] += d
ans.append((a, b, d));
def augment(path, e, d):
if e:
dd = min(d, As[path[e - 1]], v - As[path[e]])
flow(path[e - 1], path[e], dd)
augment(path, e - 1, d)
if d > dd:
flow(path[e - 1], path[e], d - dd);
def adjust(s):
pre = [0] * (n + 1)
pre[s] = -1
stk = [s]
e = 0
while len(stk):
p = stk[-1]
del stk[-1]
if As[p] < Bs[p]:
e = p
break
for to in adj[p]:
if not pre[to]:
pre[to] = p
stk.append(to)
if not e:
raise Exception
path = []
while e > 0:
path.insert(0, e)
e = pre[e]
augment(path, len(path) - 1, min(Bs[path[-1]] - As[path[-1]], As[s] - Bs[s]))
try:
while True:
check = False
for i in range(1, n + 1):
if As[i] > Bs[i]:
adjust(i)
check = True
if not check:
break
for i in range(1, n + 1):
if As[i] != Bs[i]:
raise Exception
print(len(ans))
for tp in ans:
print(*tp)
except Exception:
print("NO")
#JSR
``` | output | 1 | 43,300 | 14 | 86,601 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A system of n vessels with water is given. Several pairs of vessels are connected by tubes with transfusion mechanisms. One may transfer an integer amount of liters of water between two vessels connected by such tube (tube works in both directions). There might be multiple tubes between two vessels. Total number of tubes equals e. Volume of each vessel equals v liters. Of course, the amount of the water in any vessel cannot exceed v liters in the process of transfusions.
Given the initial amounts ai of water in the vessels and the desired amounts bi find a sequence of transfusions that deals with the task. Total number of transfusions must not exceed 2·n2.
Input
First line of the input contains integers n, v, e (1 ≤ n ≤ 300, 1 ≤ v ≤ 109, 0 ≤ e ≤ 50000).
Next two lines contain n integers each: initial ai and the desired amounts bi of water in corresponding vessels (0 ≤ ai, bi ≤ v).
Next e lines describe one tube each in the format x y (1 ≤ x, y ≤ n, x ≠ y) for a tube between vessels number x and y. There might be multiple tubes between two vessels. You may assume that vessels are numbered from 1 to n in some way.
Output
Print "NO" (without quotes), if such sequence of transfusions does not exist.
Otherwise print any suitable sequence in the following format. On the first line print the total number of transfusions k (k should not exceed 2·n2). In the following k lines print transfusions in the format x y d (transfusion of d liters from the vessel number x to the vessel number y, x and y must be distinct). For all transfusions d must be a non-negative integer.
Examples
Input
2 10 1
1 9
5 5
1 2
Output
1
2 1 4
Input
2 10 0
5 2
4 2
Output
NO
Input
2 10 0
4 2
4 2
Output
0 | instruction | 0 | 43,301 | 14 | 86,602 |
Tags: constructive algorithms, dfs and similar, graphs, trees
Correct Solution:
```
read = lambda: map(int, input().split())
n, v, e = read()
adj = [[] for _ in range(n + 1)]
As = [0] + list(read())
Bs = [0] + list(read())
ans = []
for _ in range(e):
a, b = map(int, input().split())
adj[a].append(b)
adj[b].append(a)
def flow(a, b, d):
As[a] -= d
As[b] += d
ans.append((a, b, d));
def augment(path, e, d):
if e:
dd = min(d, As[path[e - 1]], v - As[path[e]])
flow(path[e - 1], path[e], dd)
augment(path, e - 1, d)
if d > dd:
flow(path[e - 1], path[e], d - dd);
def adjust(s):
pre = [0] * (n + 1)
pre[s] = -1
stk = [s]
e = 0
while len(stk):
p = stk[-1]
del stk[-1]
if As[p] < Bs[p]:
e = p
break
for to in adj[p]:
if not pre[to]:
pre[to] = p
stk.append(to)
if not e:
raise Exception
path = []
while e > 0:
path.insert(0, e)
e = pre[e]
augment(path, len(path) - 1, min(Bs[path[-1]] - As[path[-1]], As[s] - Bs[s]))
try:
while True:
check = False
for i in range(1, n + 1):
if As[i] > Bs[i]:
adjust(i)
check = True
if not check:
break
for i in range(1, n + 1):
if As[i] != Bs[i]:
raise Exception
print(len(ans))
for tp in ans:
print(*tp)
except Exception:
print("NO")
``` | output | 1 | 43,301 | 14 | 86,603 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A system of n vessels with water is given. Several pairs of vessels are connected by tubes with transfusion mechanisms. One may transfer an integer amount of liters of water between two vessels connected by such tube (tube works in both directions). There might be multiple tubes between two vessels. Total number of tubes equals e. Volume of each vessel equals v liters. Of course, the amount of the water in any vessel cannot exceed v liters in the process of transfusions.
Given the initial amounts ai of water in the vessels and the desired amounts bi find a sequence of transfusions that deals with the task. Total number of transfusions must not exceed 2·n2.
Input
First line of the input contains integers n, v, e (1 ≤ n ≤ 300, 1 ≤ v ≤ 109, 0 ≤ e ≤ 50000).
Next two lines contain n integers each: initial ai and the desired amounts bi of water in corresponding vessels (0 ≤ ai, bi ≤ v).
Next e lines describe one tube each in the format x y (1 ≤ x, y ≤ n, x ≠ y) for a tube between vessels number x and y. There might be multiple tubes between two vessels. You may assume that vessels are numbered from 1 to n in some way.
Output
Print "NO" (without quotes), if such sequence of transfusions does not exist.
Otherwise print any suitable sequence in the following format. On the first line print the total number of transfusions k (k should not exceed 2·n2). In the following k lines print transfusions in the format x y d (transfusion of d liters from the vessel number x to the vessel number y, x and y must be distinct). For all transfusions d must be a non-negative integer.
Examples
Input
2 10 1
1 9
5 5
1 2
Output
1
2 1 4
Input
2 10 0
5 2
4 2
Output
NO
Input
2 10 0
4 2
4 2
Output
0 | instruction | 0 | 43,302 | 14 | 86,604 |
Tags: constructive algorithms, dfs and similar, graphs, trees
Correct Solution:
```
read = lambda: map(int, input().split())
n, v, e = read()
adj = [[] for _ in range(n + 1)]
As = [0] + list(read())
Bs = [0] + list(read())
ans = []
for _ in range(e):
a, b = map(int, input().split())
adj[a].append(b)
adj[b].append(a)
def flow(a, b, d):
As[a] -= d
As[b] += d
ans.append((a, b, d));
def augment(path, e, d):
if e:
dd = min(d, As[path[e - 1]], v - As[path[e]])
flow(path[e - 1], path[e], dd)
augment(path, e - 1, d)
if d > dd:
flow(path[e - 1], path[e], d - dd);
def adjust(s):
pre = [0] * (n + 1)
pre[s] = -1
stk = [s]
e = 0
while len(stk):
p = stk[-1]
del stk[-1]
if As[p] < Bs[p]:
e = p
break
for to in adj[p]:
if not pre[to]:
pre[to] = p
stk.append(to)
if not e:
raise Exception
path = []
while e > 0:
path.insert(0, e)
e = pre[e]
augment(path, len(path) - 1, min(Bs[path[-1]] - As[path[-1]], As[s] - Bs[s]))
try:
while True:
check = False
for i in range(1, n + 1):
if As[i] > Bs[i]:
adjust(i)
check = True
if not check:
break
#purvikaurraina
for i in range(1, n + 1):
if As[i] != Bs[i]:
raise Exception
print(len(ans))
for tp in ans:
print(*tp)
except Exception:
print("NO")
``` | output | 1 | 43,302 | 14 | 86,605 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Many years have passed, and n friends met at a party again. Technologies have leaped forward since the last meeting, cameras with timer appeared and now it is not obligatory for one of the friends to stand with a camera, and, thus, being absent on the photo.
Simply speaking, the process of photographing can be described as follows. Each friend occupies a rectangle of pixels on the photo: the i-th of them in a standing state occupies a wi pixels wide and a hi pixels high rectangle. But also, each person can lie down for the photo, and then he will occupy a hi pixels wide and a wi pixels high rectangle.
The total photo will have size W × H, where W is the total width of all the people rectangles, and H is the maximum of the heights. The friends want to determine what minimum area the group photo can they obtain if no more than n / 2 of them can lie on the ground (it would be strange if more than n / 2 gentlemen lie on the ground together, isn't it?..)
Help them to achieve this goal.
Input
The first line contains integer n (1 ≤ n ≤ 1000) — the number of friends.
The next n lines have two integers wi, hi (1 ≤ wi, hi ≤ 1000) each, representing the size of the rectangle, corresponding to the i-th friend.
Output
Print a single integer equal to the minimum possible area of the photo containing all friends if no more than n / 2 of them can lie on the ground.
Examples
Input
3
10 1
20 2
30 3
Output
180
Input
3
3 1
2 2
4 3
Output
21
Input
1
5 10
Output
50 | instruction | 0 | 43,378 | 14 | 86,756 |
Tags: brute force, greedy, sortings
Correct Solution:
```
from operator import neg
n = int(input())
a = [tuple(map(int, input().split())) for i in range(n)]
def check(max_h):
k = n // 2
b = []
for w, h in a:
if h > max_h:
if k <= 0 or w > max_h:
return 1 << 60
b.append((h, w))
k -= 1
else:
b.append((w, h))
b.sort(key=lambda t: t[1] - t[0])
r = 0
for w, h in b:
if k > 0 and w <= max_h and h < w:
r += h
k -= 1
else:
r += w
return r * max_h
print(min(check(h) for h in range(1, 1001)))
``` | output | 1 | 43,378 | 14 | 86,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Many years have passed, and n friends met at a party again. Technologies have leaped forward since the last meeting, cameras with timer appeared and now it is not obligatory for one of the friends to stand with a camera, and, thus, being absent on the photo.
Simply speaking, the process of photographing can be described as follows. Each friend occupies a rectangle of pixels on the photo: the i-th of them in a standing state occupies a wi pixels wide and a hi pixels high rectangle. But also, each person can lie down for the photo, and then he will occupy a hi pixels wide and a wi pixels high rectangle.
The total photo will have size W × H, where W is the total width of all the people rectangles, and H is the maximum of the heights. The friends want to determine what minimum area the group photo can they obtain if no more than n / 2 of them can lie on the ground (it would be strange if more than n / 2 gentlemen lie on the ground together, isn't it?..)
Help them to achieve this goal.
Input
The first line contains integer n (1 ≤ n ≤ 1000) — the number of friends.
The next n lines have two integers wi, hi (1 ≤ wi, hi ≤ 1000) each, representing the size of the rectangle, corresponding to the i-th friend.
Output
Print a single integer equal to the minimum possible area of the photo containing all friends if no more than n / 2 of them can lie on the ground.
Examples
Input
3
10 1
20 2
30 3
Output
180
Input
3
3 1
2 2
4 3
Output
21
Input
1
5 10
Output
50
Submitted Solution:
```
no_of_friends = int(input())
heights = []
widths = []
for i in range(0, no_of_friends):
height, width = list(map(int, input().split()))
heights.append(height)
widths.append(width)
heights.sort()
widths.sort()
areas = []
for i in range(0, no_of_friends):
max_height = heights[i]
# print(max_height)
if i < (no_of_friends - 1) and max(widths[i+1:]) > max_height:
# print("entered here")
continue
width_sum = widths[i]
# print(width_sum)
width_sum += sum(heights[i+1:])
counter = 0
for j in range(0, i):
if widths[j] > heights[j] and widths[j] < max_height and counter < no_of_friends/2:
width_sum += heights[j]
else:
width_sum += widths[j]
# print(width_sum)
areas.append(max_height * width_sum)
print(min(areas))
``` | instruction | 0 | 43,379 | 14 | 86,758 |
No | output | 1 | 43,379 | 14 | 86,759 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After his birthday party, Timofey went to his favorite tree alley in a park. He wants to feed there his favorite birds — crows.
It's widely known that each tree is occupied by a single crow family. The trees in the alley form a row and are numbered from 1 to n. Some families are friends to each other. For some reasons, two families can be friends only if they live not too far from each other, more precisely, there is no more than k - 1 trees between any pair of friend families. Formally, the family on the u-th tree and the family on the v-th tree can be friends only if |u - v| ≤ k holds.
One of the friendship features is that if some family learns that Timofey is feeding crows somewhere, it notifies about this all friend families. Thus, after Timofey starts to feed crows under some tree, all the families that are friends to the family living on this tree, as well as their friends and so on, fly to the feeding place. Of course, the family living on the tree also comes to the feeding place.
Today Timofey came to the alley and noticed that all the families that live on trees with numbers strictly less than l or strictly greater than r have flown away. Thus, it is not possible to pass the information about feeding through them. Moreover, there is no need to feed them. Help Timofey to learn what is the minimum number of trees under which he has to feed crows so that all the families that have remained will get the information about feeding. You are given several situations, described by integers l and r, you need to calculate the answer for all of them.
Input
The first line contains integers n and k (1 ≤ n ≤ 105, 1 ≤ k ≤ 5), where n is the number of trees, and k is the maximum possible distance between friend families.
The next line contains single integer m (0 ≤ m ≤ n·k) — the number of pair of friend families.
Each of the next m lines contains two integers u and v (1 ≤ u, v ≤ 105), that means that the families on trees u and v are friends. It is guaranteed that u ≠ v and |u - v| ≤ k. All the given pairs are distinct.
The next line contains single integer q (1 ≤ q ≤ 105) — the number of situations you need to calculate the answer in.
Each of the next q lines contains two integers l and r (1 ≤ l ≤ r ≤ 105), that means that in this situation families that have flown away lived on such trees x, so that either x < l or x > r.
Output
Print q lines. Line i should contain single integer — the answer in the i-th situation.
Example
Input
5 3
3
1 3
2 3
4 5
5
1 1
1 2
2 3
1 3
1 5
Output
1
2
1
1
2
Note
In the first example the following family pairs are friends: (1, 3), (2, 3) and (4, 5).
* In the first situation only the first family has remained, so the answer is 1.
* In the second situation the first two families have remained, and they aren't friends, so the answer is 2.
* In the third situation the families 2 and 3 are friends, so it is enough to feed any of them, the answer is 1.
* In the fourth situation we can feed the first family, then the third family will get the information from the first family, and the second family will get the information from the third. The answer is 1.
* In the fifth situation we can feed the first and the fifth families, so the answer is 2.
Submitted Solution:
```
print(1,2,1,1,2)
``` | instruction | 0 | 43,472 | 14 | 86,944 |
No | output | 1 | 43,472 | 14 | 86,945 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has come to the math exam and wants to solve as many problems as possible. He prepared and carefully studied the rules by which the exam passes.
The exam consists of n problems that can be solved in T minutes. Thus, the exam begins at time 0 and ends at time T. Petya can leave the exam at any integer time from 0 to T, inclusive.
All problems are divided into two types:
* easy problems — Petya takes exactly a minutes to solve any easy problem;
* hard problems — Petya takes exactly b minutes (b > a) to solve any hard problem.
Thus, if Petya starts solving an easy problem at time x, then it will be solved at time x+a. Similarly, if at a time x Petya starts to solve a hard problem, then it will be solved at time x+b.
For every problem, Petya knows if it is easy or hard. Also, for each problem is determined time t_i (0 ≤ t_i ≤ T) at which it will become mandatory (required). If Petya leaves the exam at time s and there is such a problem i that t_i ≤ s and he didn't solve it, then he will receive 0 points for the whole exam. Otherwise (i.e if he has solved all such problems for which t_i ≤ s) he will receive a number of points equal to the number of solved problems. Note that leaving at time s Petya can have both "mandatory" and "non-mandatory" problems solved.
For example, if n=2, T=5, a=2, b=3, the first problem is hard and t_1=3 and the second problem is easy and t_2=2. Then:
* if he leaves at time s=0, then he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=1, he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=2, then he can get a 1 point by solving the problem with the number 2 (it must be solved in the range from 0 to 2);
* if he leaves at time s=3, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=4, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=5, then he can get 2 points by solving all problems.
Thus, the answer to this test is 2.
Help Petya to determine the maximal number of points that he can receive, before leaving the exam.
Input
The first line contains the integer m (1 ≤ m ≤ 10^4) — the number of test cases in the test.
The next lines contain a description of m test cases.
The first line of each test case contains four integers n, T, a, b (2 ≤ n ≤ 2⋅10^5, 1 ≤ T ≤ 10^9, 1 ≤ a < b ≤ 10^9) — the number of problems, minutes given for the exam and the time to solve an easy and hard problem, respectively.
The second line of each test case contains n numbers 0 or 1, separated by single space: the i-th number means the type of the i-th problem. A value of 0 means that the problem is easy, and a value of 1 that the problem is hard.
The third line of each test case contains n integers t_i (0 ≤ t_i ≤ T), where the i-th number means the time at which the i-th problem will become mandatory.
It is guaranteed that the sum of n for all test cases does not exceed 2⋅10^5.
Output
Print the answers to m test cases. For each set, print a single integer — maximal number of points that he can receive, before leaving the exam.
Example
Input
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Output
3
2
1
0
1
4
0
1
2
1 | instruction | 0 | 43,962 | 14 | 87,924 |
Tags: greedy, sortings, two pointers
Correct Solution:
```
import sys
input = sys.stdin.readline
t=int(input())
for testcases in range(t):
n,T,a,b=map(int,input().split())
A=list(map(int,input().split()))
L=list(map(int,input().split()))
LCAN=[T]
EASY=[]
HARD=[]
for i in range(n):
if A[i]==0:
EASY.append(L[i])
else:
HARD.append(L[i])
if L[i]>1:
LCAN.append(L[i]-1)
LCAN=sorted(set(LCAN))
EASY.sort()
HARD.sort()
#print(LCAN,a,b)
#print(EASY)
#print(HARD)
#print()
eind=0
hind=0
LENE=len(EASY)
LENH=len(HARD)
needtime=0
ANS=0
for time in LCAN:
while eind<LENE and EASY[eind]<=time:
needtime+=a
eind+=1
while hind<LENH and HARD[hind]<=time:
needtime+=b
hind+=1
if time<needtime:
continue
else:
rest=time-needtime
score=eind+hind
if (LENE-eind)*a>=rest:
score+=rest//a
else:
score=LENE+hind
rest-=(LENE-eind)*a
score+=min(LENH-hind,rest//b)
ANS=max(ANS,score)
print(ANS)
``` | output | 1 | 43,962 | 14 | 87,925 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has come to the math exam and wants to solve as many problems as possible. He prepared and carefully studied the rules by which the exam passes.
The exam consists of n problems that can be solved in T minutes. Thus, the exam begins at time 0 and ends at time T. Petya can leave the exam at any integer time from 0 to T, inclusive.
All problems are divided into two types:
* easy problems — Petya takes exactly a minutes to solve any easy problem;
* hard problems — Petya takes exactly b minutes (b > a) to solve any hard problem.
Thus, if Petya starts solving an easy problem at time x, then it will be solved at time x+a. Similarly, if at a time x Petya starts to solve a hard problem, then it will be solved at time x+b.
For every problem, Petya knows if it is easy or hard. Also, for each problem is determined time t_i (0 ≤ t_i ≤ T) at which it will become mandatory (required). If Petya leaves the exam at time s and there is such a problem i that t_i ≤ s and he didn't solve it, then he will receive 0 points for the whole exam. Otherwise (i.e if he has solved all such problems for which t_i ≤ s) he will receive a number of points equal to the number of solved problems. Note that leaving at time s Petya can have both "mandatory" and "non-mandatory" problems solved.
For example, if n=2, T=5, a=2, b=3, the first problem is hard and t_1=3 and the second problem is easy and t_2=2. Then:
* if he leaves at time s=0, then he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=1, he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=2, then he can get a 1 point by solving the problem with the number 2 (it must be solved in the range from 0 to 2);
* if he leaves at time s=3, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=4, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=5, then he can get 2 points by solving all problems.
Thus, the answer to this test is 2.
Help Petya to determine the maximal number of points that he can receive, before leaving the exam.
Input
The first line contains the integer m (1 ≤ m ≤ 10^4) — the number of test cases in the test.
The next lines contain a description of m test cases.
The first line of each test case contains four integers n, T, a, b (2 ≤ n ≤ 2⋅10^5, 1 ≤ T ≤ 10^9, 1 ≤ a < b ≤ 10^9) — the number of problems, minutes given for the exam and the time to solve an easy and hard problem, respectively.
The second line of each test case contains n numbers 0 or 1, separated by single space: the i-th number means the type of the i-th problem. A value of 0 means that the problem is easy, and a value of 1 that the problem is hard.
The third line of each test case contains n integers t_i (0 ≤ t_i ≤ T), where the i-th number means the time at which the i-th problem will become mandatory.
It is guaranteed that the sum of n for all test cases does not exceed 2⋅10^5.
Output
Print the answers to m test cases. For each set, print a single integer — maximal number of points that he can receive, before leaving the exam.
Example
Input
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Output
3
2
1
0
1
4
0
1
2
1 | instruction | 0 | 43,963 | 14 | 87,926 |
Tags: greedy, sortings, two pointers
Correct Solution:
```
import os
from io import BytesIO
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
for _ in range(int(input())):
n, T, a, b = map(int, input().split())
hard = [bool(i) for i in map(int, input().split())]
time = [(int(i), ind) for ind, i in enumerate(input().split())]
time.sort()
i = 0
cnteasy = hard.count(False)
cnthard = n - cnteasy
if (time[0][0] - 1) // a <= cnteasy:
ans = (time[0][0] - 1) // a
else:
ans = cnteasy + min((time[0][0] - 1 - cnteasy * a) // b, cnthard)
ans = max(ans, 0)
eas = 0
har = 0
while i < n:
if hard[time[i][1]]:
har += 1
else:
eas += 1
while i < n - 1 and time[i + 1][0] == time[i][0]:
i += 1
if hard[time[i][1]]:
har += 1
else:
eas += 1
if i < n - 1:
free_time = min(time[i + 1][0] - 1, T)
else:
free_time = T
# print(i, har, eas, free_time)
if free_time < har * b + eas * a:
i += 1
continue
else:
curans = har + eas
free_time -= har * b + eas * a
if free_time // a <= cnteasy - eas:
curans += free_time // a
else:
free_time -= (cnteasy - eas) * a
curans += cnteasy - eas + \
min(free_time // b, cnthard - har)
ans = max(curans, ans)
# print(i, ans, curans)
i += 1
print(ans)
``` | output | 1 | 43,963 | 14 | 87,927 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has come to the math exam and wants to solve as many problems as possible. He prepared and carefully studied the rules by which the exam passes.
The exam consists of n problems that can be solved in T minutes. Thus, the exam begins at time 0 and ends at time T. Petya can leave the exam at any integer time from 0 to T, inclusive.
All problems are divided into two types:
* easy problems — Petya takes exactly a minutes to solve any easy problem;
* hard problems — Petya takes exactly b minutes (b > a) to solve any hard problem.
Thus, if Petya starts solving an easy problem at time x, then it will be solved at time x+a. Similarly, if at a time x Petya starts to solve a hard problem, then it will be solved at time x+b.
For every problem, Petya knows if it is easy or hard. Also, for each problem is determined time t_i (0 ≤ t_i ≤ T) at which it will become mandatory (required). If Petya leaves the exam at time s and there is such a problem i that t_i ≤ s and he didn't solve it, then he will receive 0 points for the whole exam. Otherwise (i.e if he has solved all such problems for which t_i ≤ s) he will receive a number of points equal to the number of solved problems. Note that leaving at time s Petya can have both "mandatory" and "non-mandatory" problems solved.
For example, if n=2, T=5, a=2, b=3, the first problem is hard and t_1=3 and the second problem is easy and t_2=2. Then:
* if he leaves at time s=0, then he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=1, he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=2, then he can get a 1 point by solving the problem with the number 2 (it must be solved in the range from 0 to 2);
* if he leaves at time s=3, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=4, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=5, then he can get 2 points by solving all problems.
Thus, the answer to this test is 2.
Help Petya to determine the maximal number of points that he can receive, before leaving the exam.
Input
The first line contains the integer m (1 ≤ m ≤ 10^4) — the number of test cases in the test.
The next lines contain a description of m test cases.
The first line of each test case contains four integers n, T, a, b (2 ≤ n ≤ 2⋅10^5, 1 ≤ T ≤ 10^9, 1 ≤ a < b ≤ 10^9) — the number of problems, minutes given for the exam and the time to solve an easy and hard problem, respectively.
The second line of each test case contains n numbers 0 or 1, separated by single space: the i-th number means the type of the i-th problem. A value of 0 means that the problem is easy, and a value of 1 that the problem is hard.
The third line of each test case contains n integers t_i (0 ≤ t_i ≤ T), where the i-th number means the time at which the i-th problem will become mandatory.
It is guaranteed that the sum of n for all test cases does not exceed 2⋅10^5.
Output
Print the answers to m test cases. For each set, print a single integer — maximal number of points that he can receive, before leaving the exam.
Example
Input
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Output
3
2
1
0
1
4
0
1
2
1 | instruction | 0 | 43,964 | 14 | 87,928 |
Tags: greedy, sortings, two pointers
Correct Solution:
```
m = int(input())
for _ in range(m):
n, T, a, b = map(int, input().split())
diff = list(map(int, input().split()))
t = list(map(int, input().split()))
problem = []
for i in range(n):
problem.append((diff[i], t[i]))
problem.sort(key=lambda x: x[1])
possible = [0] * (n+1)
easy_count = [0] * (n+1)
hard_count = [0] * (n+1)
easy = 0
hard = 0
pre_easy = 0
pre_hard = 0
for i in range(n):
time = problem[i][1]
difficulty = problem[i][0]
stop = time - 1
if i > 0 and (problem[i-1][1] != time):
easy += pre_easy
pre_easy = 0
hard += pre_hard
pre_hard = 0
if easy * a + hard * b <= stop:
possible[i] = 1
if difficulty == 0:
pre_easy += 1
else:
pre_hard += 1
easy_count[i] = easy
hard_count[i] = hard
stop = T
easy += pre_easy
hard += pre_hard
easy_count[n] = easy
hard_count[n] = hard
if easy * a + hard * b <= stop:
possible[n] = 1
ans = 0
for i in range(n):
count = 0
if not possible[i]:
continue
time = problem[i][1] - 1
spend = easy_count[i] * a + hard_count[i] * b
count += easy_count[i] + hard_count[i]
d = time - spend
if (easy_count[n] - easy_count[i]) * a > d:
count += d//a
else:
d -= (easy_count[n] - easy_count[i]) * a
count += (easy_count[n] - easy_count[i])
if (hard_count[n] - hard_count[i]) * b > d:
count += d // b
else:
count += hard_count[n] - hard_count[i]
ans = max(ans, count)
if possible[n]:
count = 0
i = n
time = T
spend = easy_count[i] * a + hard_count[i] * b
count += easy_count[i] + hard_count[i]
d = time - spend
if (easy_count[n] - easy_count[i]) * a > d:
count += d//a
else:
d -= (easy_count[n] - easy_count[i]) * a
count += (easy_count[n] - easy_count[i])
if (hard_count[n] - hard_count[i]) * b > d:
count += d // b
else:
count += hard_count[n] - hard_count[i]
ans = max(ans, count)
print(ans)
``` | output | 1 | 43,964 | 14 | 87,929 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has come to the math exam and wants to solve as many problems as possible. He prepared and carefully studied the rules by which the exam passes.
The exam consists of n problems that can be solved in T minutes. Thus, the exam begins at time 0 and ends at time T. Petya can leave the exam at any integer time from 0 to T, inclusive.
All problems are divided into two types:
* easy problems — Petya takes exactly a minutes to solve any easy problem;
* hard problems — Petya takes exactly b minutes (b > a) to solve any hard problem.
Thus, if Petya starts solving an easy problem at time x, then it will be solved at time x+a. Similarly, if at a time x Petya starts to solve a hard problem, then it will be solved at time x+b.
For every problem, Petya knows if it is easy or hard. Also, for each problem is determined time t_i (0 ≤ t_i ≤ T) at which it will become mandatory (required). If Petya leaves the exam at time s and there is such a problem i that t_i ≤ s and he didn't solve it, then he will receive 0 points for the whole exam. Otherwise (i.e if he has solved all such problems for which t_i ≤ s) he will receive a number of points equal to the number of solved problems. Note that leaving at time s Petya can have both "mandatory" and "non-mandatory" problems solved.
For example, if n=2, T=5, a=2, b=3, the first problem is hard and t_1=3 and the second problem is easy and t_2=2. Then:
* if he leaves at time s=0, then he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=1, he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=2, then he can get a 1 point by solving the problem with the number 2 (it must be solved in the range from 0 to 2);
* if he leaves at time s=3, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=4, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=5, then he can get 2 points by solving all problems.
Thus, the answer to this test is 2.
Help Petya to determine the maximal number of points that he can receive, before leaving the exam.
Input
The first line contains the integer m (1 ≤ m ≤ 10^4) — the number of test cases in the test.
The next lines contain a description of m test cases.
The first line of each test case contains four integers n, T, a, b (2 ≤ n ≤ 2⋅10^5, 1 ≤ T ≤ 10^9, 1 ≤ a < b ≤ 10^9) — the number of problems, minutes given for the exam and the time to solve an easy and hard problem, respectively.
The second line of each test case contains n numbers 0 or 1, separated by single space: the i-th number means the type of the i-th problem. A value of 0 means that the problem is easy, and a value of 1 that the problem is hard.
The third line of each test case contains n integers t_i (0 ≤ t_i ≤ T), where the i-th number means the time at which the i-th problem will become mandatory.
It is guaranteed that the sum of n for all test cases does not exceed 2⋅10^5.
Output
Print the answers to m test cases. For each set, print a single integer — maximal number of points that he can receive, before leaving the exam.
Example
Input
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Output
3
2
1
0
1
4
0
1
2
1 | instruction | 0 | 43,965 | 14 | 87,930 |
Tags: greedy, sortings, two pointers
Correct Solution:
```
from bisect import bisect_left as bl
from bisect import bisect_right as br
# import heapq
# import math
from collections import *
# from functools import reduce,cmp_to_key
import sys
input = sys.stdin.readline
# M = mod = 10**9 + 7
# def factors(n):return sorted(list(set(reduce(list.__add__,([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))))
# def inv_mod(n):return pow(n, mod - 2, mod)
def li():return [int(i) for i in input().rstrip('\n').split(' ')]
def st():return input().rstrip('\n')
def val():return int(input().rstrip('\n'))
def li2():return [i for i in input().rstrip('\n').split(' ')]
def li3():return [int(i) for i in input().rstrip('\n')]
for _ in range(val()):
n, T, A, B = li()
level = li()
time = li()
ques = [[i,j] for i,j in zip(level,time)]
tota,totb=0,0
for i in ques:
if i[0]:totb += 1
else:tota += 1
ques.sort(key = lambda x:x[1])
mandatory = {}
prev = [0,0]
for i in range(n):
prev[ques[i][0]] += 1
mandatory[ques[i][1]] = tuple(prev)
mandatory[T] = tuple(prev)
if 0 not in mandatory:mandatory[0] = tuple([0,0])
timemandatory = sorted(list(mandatory))
for i in range(1,len(timemandatory)):
if timemandatory[i] - 1 not in mandatory:
mandatory[timemandatory[i] - 1] = mandatory[timemandatory[i-1]]
timemandatory = sorted(list(mandatory))
ans = 0
for i in timemandatory:
if i>=0:
rema = tota - mandatory[i][0]
remb = totb - mandatory[i][1]
remtime = i - (mandatory[i][0]*A + mandatory[i][1]*B)
curr = sum(mandatory[i])
if remtime >= 0:
more = min(remtime//A,rema)
remtime -= A*min(remtime//A,rema)
more += min(remtime//B,remb)
ans = max(ans,more + curr)
print(ans)
``` | output | 1 | 43,965 | 14 | 87,931 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has come to the math exam and wants to solve as many problems as possible. He prepared and carefully studied the rules by which the exam passes.
The exam consists of n problems that can be solved in T minutes. Thus, the exam begins at time 0 and ends at time T. Petya can leave the exam at any integer time from 0 to T, inclusive.
All problems are divided into two types:
* easy problems — Petya takes exactly a minutes to solve any easy problem;
* hard problems — Petya takes exactly b minutes (b > a) to solve any hard problem.
Thus, if Petya starts solving an easy problem at time x, then it will be solved at time x+a. Similarly, if at a time x Petya starts to solve a hard problem, then it will be solved at time x+b.
For every problem, Petya knows if it is easy or hard. Also, for each problem is determined time t_i (0 ≤ t_i ≤ T) at which it will become mandatory (required). If Petya leaves the exam at time s and there is such a problem i that t_i ≤ s and he didn't solve it, then he will receive 0 points for the whole exam. Otherwise (i.e if he has solved all such problems for which t_i ≤ s) he will receive a number of points equal to the number of solved problems. Note that leaving at time s Petya can have both "mandatory" and "non-mandatory" problems solved.
For example, if n=2, T=5, a=2, b=3, the first problem is hard and t_1=3 and the second problem is easy and t_2=2. Then:
* if he leaves at time s=0, then he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=1, he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=2, then he can get a 1 point by solving the problem with the number 2 (it must be solved in the range from 0 to 2);
* if he leaves at time s=3, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=4, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=5, then he can get 2 points by solving all problems.
Thus, the answer to this test is 2.
Help Petya to determine the maximal number of points that he can receive, before leaving the exam.
Input
The first line contains the integer m (1 ≤ m ≤ 10^4) — the number of test cases in the test.
The next lines contain a description of m test cases.
The first line of each test case contains four integers n, T, a, b (2 ≤ n ≤ 2⋅10^5, 1 ≤ T ≤ 10^9, 1 ≤ a < b ≤ 10^9) — the number of problems, minutes given for the exam and the time to solve an easy and hard problem, respectively.
The second line of each test case contains n numbers 0 or 1, separated by single space: the i-th number means the type of the i-th problem. A value of 0 means that the problem is easy, and a value of 1 that the problem is hard.
The third line of each test case contains n integers t_i (0 ≤ t_i ≤ T), where the i-th number means the time at which the i-th problem will become mandatory.
It is guaranteed that the sum of n for all test cases does not exceed 2⋅10^5.
Output
Print the answers to m test cases. For each set, print a single integer — maximal number of points that he can receive, before leaving the exam.
Example
Input
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Output
3
2
1
0
1
4
0
1
2
1 | instruction | 0 | 43,966 | 14 | 87,932 |
Tags: greedy, sortings, two pointers
Correct Solution:
```
import os,io
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
t=int(input())
for _ in range(t):
n,t,a,b=map(int,input().split())
qtype=list(map(int,input().split()))
time=list(map(int,input().split()))
times=[]
maxa=0
for i in range(n):
times.append([time[i],qtype[i]])
if qtype[i]==0:
maxa+=1
acount=0
bcount=0
ans=0
times=sorted(times, key=lambda student: student[0])
for i in range(n):
currenttime=times[i][0]-1
if currenttime<0:
if times[i][1]==0:
acount+=1
else:
bcount+=1
continue
if acount*a+bcount*b>currenttime:
if times[i][1]==0:
acount+=1
else:
bcount+=1
continue
currenttime-=acount*a+bcount*b
tmp=acount+bcount
if currenttime>a*(maxa-acount):
tmp+=maxa-acount
currenttime-=a*(maxa-acount)
tmp+=currenttime//b
else:
tmp+=currenttime//a
ans=max(tmp,ans)
if times[i][1]==0:
acount+=1
else:
bcount+=1
if maxa*a+(n-maxa)*b<=t:
ans=n
print(ans)
``` | output | 1 | 43,966 | 14 | 87,933 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has come to the math exam and wants to solve as many problems as possible. He prepared and carefully studied the rules by which the exam passes.
The exam consists of n problems that can be solved in T minutes. Thus, the exam begins at time 0 and ends at time T. Petya can leave the exam at any integer time from 0 to T, inclusive.
All problems are divided into two types:
* easy problems — Petya takes exactly a minutes to solve any easy problem;
* hard problems — Petya takes exactly b minutes (b > a) to solve any hard problem.
Thus, if Petya starts solving an easy problem at time x, then it will be solved at time x+a. Similarly, if at a time x Petya starts to solve a hard problem, then it will be solved at time x+b.
For every problem, Petya knows if it is easy or hard. Also, for each problem is determined time t_i (0 ≤ t_i ≤ T) at which it will become mandatory (required). If Petya leaves the exam at time s and there is such a problem i that t_i ≤ s and he didn't solve it, then he will receive 0 points for the whole exam. Otherwise (i.e if he has solved all such problems for which t_i ≤ s) he will receive a number of points equal to the number of solved problems. Note that leaving at time s Petya can have both "mandatory" and "non-mandatory" problems solved.
For example, if n=2, T=5, a=2, b=3, the first problem is hard and t_1=3 and the second problem is easy and t_2=2. Then:
* if he leaves at time s=0, then he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=1, he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=2, then he can get a 1 point by solving the problem with the number 2 (it must be solved in the range from 0 to 2);
* if he leaves at time s=3, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=4, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=5, then he can get 2 points by solving all problems.
Thus, the answer to this test is 2.
Help Petya to determine the maximal number of points that he can receive, before leaving the exam.
Input
The first line contains the integer m (1 ≤ m ≤ 10^4) — the number of test cases in the test.
The next lines contain a description of m test cases.
The first line of each test case contains four integers n, T, a, b (2 ≤ n ≤ 2⋅10^5, 1 ≤ T ≤ 10^9, 1 ≤ a < b ≤ 10^9) — the number of problems, minutes given for the exam and the time to solve an easy and hard problem, respectively.
The second line of each test case contains n numbers 0 or 1, separated by single space: the i-th number means the type of the i-th problem. A value of 0 means that the problem is easy, and a value of 1 that the problem is hard.
The third line of each test case contains n integers t_i (0 ≤ t_i ≤ T), where the i-th number means the time at which the i-th problem will become mandatory.
It is guaranteed that the sum of n for all test cases does not exceed 2⋅10^5.
Output
Print the answers to m test cases. For each set, print a single integer — maximal number of points that he can receive, before leaving the exam.
Example
Input
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Output
3
2
1
0
1
4
0
1
2
1 | instruction | 0 | 43,967 | 14 | 87,934 |
Tags: greedy, sortings, two pointers
Correct Solution:
```
if __name__ == '__main__':
num_tests = int(input())
for test in range(num_tests):
inp = input().rstrip().split(" ")
n = int(inp[0])
T = int(inp[1])
a = int(inp[2])
b = int(inp[3])
inp = input().rstrip().split(" ")
difficulty = [int(inp[i]) for i in range(len(inp))]
inp = input().rstrip().split(" ")
mandatory_at = [int(inp[i]) for i in range(len(inp))]
joint = list(zip(mandatory_at, difficulty))
joint.sort(key=lambda tup: tup[1])
joint.sort(key=lambda tup: tup[0])
num_hard = sum(difficulty)
num_easy = n - num_hard
scores = []
mandatory_score = 0
mandatory_time = 0
for time, difficulty in joint:
left_time = time-1 - mandatory_time
if left_time >= 0:
score = mandatory_score
if int(left_time/a) <= num_easy:
score += int(left_time/a)
else:
score += num_easy
left_time -= num_easy*a
score += min(int(left_time/b), num_hard)
scores.append(score)
else:
scores.append(0)
mandatory_time += difficulty*(b-a) + a
mandatory_score += 1
num_easy = num_easy - (1 - difficulty)
num_hard = num_hard - (difficulty)
# Border case
left_time = T - mandatory_time
if left_time >= 0:
score = mandatory_score
if int(left_time/a) <= num_easy:
score += int(left_time/a)
else:
score += num_easy
left_time -= num_easy*a
score += min(int(left_time/b), num_hard)
scores.append(score)
else:
scores.append(0)
print(max(scores))
``` | output | 1 | 43,967 | 14 | 87,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has come to the math exam and wants to solve as many problems as possible. He prepared and carefully studied the rules by which the exam passes.
The exam consists of n problems that can be solved in T minutes. Thus, the exam begins at time 0 and ends at time T. Petya can leave the exam at any integer time from 0 to T, inclusive.
All problems are divided into two types:
* easy problems — Petya takes exactly a minutes to solve any easy problem;
* hard problems — Petya takes exactly b minutes (b > a) to solve any hard problem.
Thus, if Petya starts solving an easy problem at time x, then it will be solved at time x+a. Similarly, if at a time x Petya starts to solve a hard problem, then it will be solved at time x+b.
For every problem, Petya knows if it is easy or hard. Also, for each problem is determined time t_i (0 ≤ t_i ≤ T) at which it will become mandatory (required). If Petya leaves the exam at time s and there is such a problem i that t_i ≤ s and he didn't solve it, then he will receive 0 points for the whole exam. Otherwise (i.e if he has solved all such problems for which t_i ≤ s) he will receive a number of points equal to the number of solved problems. Note that leaving at time s Petya can have both "mandatory" and "non-mandatory" problems solved.
For example, if n=2, T=5, a=2, b=3, the first problem is hard and t_1=3 and the second problem is easy and t_2=2. Then:
* if he leaves at time s=0, then he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=1, he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=2, then he can get a 1 point by solving the problem with the number 2 (it must be solved in the range from 0 to 2);
* if he leaves at time s=3, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=4, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=5, then he can get 2 points by solving all problems.
Thus, the answer to this test is 2.
Help Petya to determine the maximal number of points that he can receive, before leaving the exam.
Input
The first line contains the integer m (1 ≤ m ≤ 10^4) — the number of test cases in the test.
The next lines contain a description of m test cases.
The first line of each test case contains four integers n, T, a, b (2 ≤ n ≤ 2⋅10^5, 1 ≤ T ≤ 10^9, 1 ≤ a < b ≤ 10^9) — the number of problems, minutes given for the exam and the time to solve an easy and hard problem, respectively.
The second line of each test case contains n numbers 0 or 1, separated by single space: the i-th number means the type of the i-th problem. A value of 0 means that the problem is easy, and a value of 1 that the problem is hard.
The third line of each test case contains n integers t_i (0 ≤ t_i ≤ T), where the i-th number means the time at which the i-th problem will become mandatory.
It is guaranteed that the sum of n for all test cases does not exceed 2⋅10^5.
Output
Print the answers to m test cases. For each set, print a single integer — maximal number of points that he can receive, before leaving the exam.
Example
Input
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Output
3
2
1
0
1
4
0
1
2
1 | instruction | 0 | 43,968 | 14 | 87,936 |
Tags: greedy, sortings, two pointers
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
from math import factorial
from collections import Counter, defaultdict
from heapq import heapify, heappop, heappush
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
# ------------------------------
def main():
for _ in range(N()):
n, t, a, b = RL()
eh = RLL()
rq = RLL()
q = list(zip(eh, rq))
q.sort(key=lambda a: a[1])
q.append([2, t+1])
S = eh.count(0)
H = n-S
res = 0
ss = hh = 0
for i in range(n+1):
dg, tm = q[i]
pret = ss*a+hh*b
# print(pret, q[i], ss, hh)
if pret<=tm-1:
ds, dt = S-ss, H-hh
now = ss+hh
dif = tm-1-pret
if dif>0:
now+=min(ds, (dif//a))
dif-=min(ds, (dif//a))*a
if dif>0:
now+=min(dt, (dif//b))
# print(now, i)
res = max(res, now)
if dg==0:
ss+=1
else:
hh+=1
print(res)
if __name__ == "__main__":
main()
``` | output | 1 | 43,968 | 14 | 87,937 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petya has come to the math exam and wants to solve as many problems as possible. He prepared and carefully studied the rules by which the exam passes.
The exam consists of n problems that can be solved in T minutes. Thus, the exam begins at time 0 and ends at time T. Petya can leave the exam at any integer time from 0 to T, inclusive.
All problems are divided into two types:
* easy problems — Petya takes exactly a minutes to solve any easy problem;
* hard problems — Petya takes exactly b minutes (b > a) to solve any hard problem.
Thus, if Petya starts solving an easy problem at time x, then it will be solved at time x+a. Similarly, if at a time x Petya starts to solve a hard problem, then it will be solved at time x+b.
For every problem, Petya knows if it is easy or hard. Also, for each problem is determined time t_i (0 ≤ t_i ≤ T) at which it will become mandatory (required). If Petya leaves the exam at time s and there is such a problem i that t_i ≤ s and he didn't solve it, then he will receive 0 points for the whole exam. Otherwise (i.e if he has solved all such problems for which t_i ≤ s) he will receive a number of points equal to the number of solved problems. Note that leaving at time s Petya can have both "mandatory" and "non-mandatory" problems solved.
For example, if n=2, T=5, a=2, b=3, the first problem is hard and t_1=3 and the second problem is easy and t_2=2. Then:
* if he leaves at time s=0, then he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=1, he will receive 0 points since he will not have time to solve any problems;
* if he leaves at time s=2, then he can get a 1 point by solving the problem with the number 2 (it must be solved in the range from 0 to 2);
* if he leaves at time s=3, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=4, then he will receive 0 points since at this moment both problems will be mandatory, but he will not be able to solve both of them;
* if he leaves at time s=5, then he can get 2 points by solving all problems.
Thus, the answer to this test is 2.
Help Petya to determine the maximal number of points that he can receive, before leaving the exam.
Input
The first line contains the integer m (1 ≤ m ≤ 10^4) — the number of test cases in the test.
The next lines contain a description of m test cases.
The first line of each test case contains four integers n, T, a, b (2 ≤ n ≤ 2⋅10^5, 1 ≤ T ≤ 10^9, 1 ≤ a < b ≤ 10^9) — the number of problems, minutes given for the exam and the time to solve an easy and hard problem, respectively.
The second line of each test case contains n numbers 0 or 1, separated by single space: the i-th number means the type of the i-th problem. A value of 0 means that the problem is easy, and a value of 1 that the problem is hard.
The third line of each test case contains n integers t_i (0 ≤ t_i ≤ T), where the i-th number means the time at which the i-th problem will become mandatory.
It is guaranteed that the sum of n for all test cases does not exceed 2⋅10^5.
Output
Print the answers to m test cases. For each set, print a single integer — maximal number of points that he can receive, before leaving the exam.
Example
Input
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Output
3
2
1
0
1
4
0
1
2
1 | instruction | 0 | 43,969 | 14 | 87,938 |
Tags: greedy, sortings, two pointers
Correct Solution:
```
import sys
t = int(input())
ans = [0]*t
for pi in range(t):
n, T, a, b = map(int, sys.stdin.readline().split())
a1 = list(map(int, sys.stdin.readline().split()))
a2 = list(map(int, sys.stdin.readline().split()))
easy_count = a1.count(0)
hard_count = n - easy_count
tasks = sorted((t, x) for x, t in zip(a1, a2))
solved = 0
req_easy, req_hard = 0, 0
for i, (t, is_hard) in enumerate(tasks, start=1):
rem = t-1 - req_easy*a - req_hard*b
if rem >= 0:
c = min(easy_count-req_easy, rem//a)
c += min(hard_count-req_hard, (rem-c*a) // b)
solved = max(solved, c+req_easy+req_hard)
if is_hard == 1:
req_hard += 1
else:
req_easy += 1
if easy_count*a + hard_count*b <= T:
solved = n
ans[pi] = solved
print(*ans, sep='\n')
``` | output | 1 | 43,969 | 14 | 87,939 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 43,994 | 14 | 87,988 |
Tags: math, number theory, sortings
Correct Solution:
```
def solve():
n=int(input())
l=[int(l) for l in input().split()]
for i in range(n):
l[i]=((i+l[i])%n+n)%n
if(len(set(l))==n):
print("YES")
else:
print("NO")
for _ in range(int(input())):
solve()
``` | output | 1 | 43,994 | 14 | 87,989 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 43,995 | 14 | 87,990 |
Tags: math, number theory, sortings
Correct Solution:
```
t=int(input())
for i in range(t):
n=int(input())
a=[int(i) for i in input().split()]
seta=set()
for j in range(n):
seta.add((j+a[j])%n)
#print(seta,ok)
if len(seta)==n:
print("YES")
else:
print("NO")
``` | output | 1 | 43,995 | 14 | 87,991 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 43,996 | 14 | 87,992 |
Tags: math, number theory, sortings
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
rems=[False]*n
possible=True
for i in range(n):
rem=(i+a[i])%n
if(rems[rem]):
possible=False
break
rems[rem]=True
if(possible):
print("YES")
else:
print("NO")
``` | output | 1 | 43,996 | 14 | 87,993 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 43,997 | 14 | 87,994 |
Tags: math, number theory, sortings
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = list( map(int,input().split()))
isVisited = False
d = {}
if n == 1:
print('YES')
continue
for k in range(n):
m = (k + a[k])%n
if m not in d:
d[m] = True
else:
isVisited = True
break
if isVisited:
print('NO')
else:
print('YES')
``` | output | 1 | 43,997 | 14 | 87,995 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 43,998 | 14 | 87,996 |
Tags: math, number theory, sortings
Correct Solution:
```
for _ in range (int(input())) :
n =int(input())
l =[int(x) for x in input().split()]
for i in range (n) :
l[i] = (i+l[i])%n
if len(set(l)) == n :
print("YES")
else :
print("NO")
``` | output | 1 | 43,998 | 14 | 87,997 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 43,999 | 14 | 87,998 |
Tags: math, number theory, sortings
Correct Solution:
```
## necessary imports
import sys
input = sys.stdin.readline
from math import log2, log, ceil
# swap_array function
def swaparr(arr, a,b):
temp = arr[a];
arr[a] = arr[b];
arr[b] = temp
## gcd function
def gcd(a,b):
if a == 0:
return b
return gcd(b%a, a)
## nCr function efficient using Binomial Cofficient
def nCr(n, k):
if(k > n - k):
k = n - k
res = 1
for i in range(k):
res = res * (n - i)
res = res / (i + 1)
return res
## upper bound function code -- such that e in a[:i] e < x;
def upper_bound(a, x, lo=0):
hi = len(a)
while lo < hi:
mid = (lo+hi)//2
if a[mid] < x:
lo = mid+1
else:
hi = mid
return lo
## prime factorization
def primefs(n):
## if n == 1 ## calculating primes
primes = {}
while(n%2 == 0):
primes[2] = primes.get(2, 0) + 1
n = n//2
for i in range(3, int(n**0.5)+2, 2):
while(n%i == 0):
primes[i] = primes.get(i, 0) + 1
n = n//i
if n > 2:
primes[n] = primes.get(n, 0) + 1
## prime factoriazation of n is stored in dictionary
## primes and can be accesed. O(sqrt n)
return primes
## MODULAR EXPONENTIATION FUNCTION
def power(x, y, p):
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
## DISJOINT SET UNINON FUNCTIONS
def swap(a,b):
temp = a
a = b
b = temp
return a,b
# find function
def find(x, link):
while(x != link[x]):
x = link[x]
return x
# the union function which makes union(x,y)
# of two nodes x and y
def union(x, y, link, size):
x = find(x, link)
y = find(y, link)
if size[x] < size[y]:
x,y = swap(x,y)
if x != y:
size[x] += size[y]
link[y] = x
## returns an array of boolean if primes or not USING SIEVE OF ERATOSTHANES
def sieve(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
#### PRIME FACTORIZATION IN O(log n) using Sieve ####
MAXN = int(1e6 + 5)
def spf_sieve():
spf[1] = 1;
for i in range(2, MAXN):
spf[i] = i;
for i in range(4, MAXN, 2):
spf[i] = 2;
for i in range(3, ceil(MAXN ** 0.5), 2):
if spf[i] == i:
for j in range(i*i, MAXN, i):
if spf[j] == j:
spf[j] = i;
## function for storing smallest prime factors (spf) in the array
################## un-comment below 2 lines when using factorization #################
# spf = [0 for i in range(MAXN)]
# spf_sieve()
def factoriazation(x):
ret = {};
while x != 1:
ret[spf[x]] = ret.get(spf[x], 0) + 1;
x = x//spf[x]
return ret
## this function is useful for multiple queries only, o/w use
## primefs function above. complexity O(log n)
## taking integer array input
def int_array():
return list(map(int, input().strip().split()))
## taking string array input
def str_array():
return input().strip().split();
#defining a couple constants
MOD = int(1e9)+7;
CMOD = 998244353;
INF = float('inf'); NINF = -float('inf');
################### ---------------- TEMPLATE ENDS HERE ---------------- ###################
for _ in range(int(input())):
n = int(input()); a = int_array();
mset = set(); f= 1;
for i in range(n):
x = (i + a[i])%n;
if x in mset:
f = 0; break;
else:
mset.add(x);
if f:
print('YES')
else:
print('NO');
``` | output | 1 | 43,999 | 14 | 87,999 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 44,000 | 14 | 88,000 |
Tags: math, number theory, sortings
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
a=[int(i) for i in input().split()]
d=[]
for i in range(n):
p=(i+a[i])%n
d.append(p)
d.sort()
f=[]
for i in range(n):
f.append(i)
if(f!=d):
print("NO")
else:
print("YES")
``` | output | 1 | 44,000 | 14 | 88,001 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hilbert's Hotel is a very unusual hotel since the number of rooms is infinite! In fact, there is exactly one room for every integer, including zero and negative integers. Even stranger, the hotel is currently at full capacity, meaning there is exactly one guest in every room. The hotel's manager, David Hilbert himself, decides he wants to shuffle the guests around because he thinks this will create a vacancy (a room without a guest).
For any integer k and positive integer n, let kmod n denote the remainder when k is divided by n. More formally, r=kmod n is the smallest non-negative integer such that k-r is divisible by n. It always holds that 0≤ kmod n≤ n-1. For example, 100mod 12=4 and (-1337)mod 3=1.
Then the shuffling works as follows. There is an array of n integers a_0,a_1,…,a_{n-1}. Then for each integer k, the guest in room k is moved to room number k+a_{kmod n}.
After this shuffling process, determine if there is still exactly one guest assigned to each room. That is, there are no vacancies or rooms with multiple guests.
Input
Each test consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 10^4) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2⋅ 10^5) — the length of the array.
The second line of each test case contains n integers a_0,a_1,…,a_{n-1} (-10^9≤ a_i≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.
Output
For each test case, output a single line containing "YES" if there is exactly one guest assigned to each room after the shuffling process, or "NO" otherwise. You can print each letter in any case (upper or lower).
Example
Input
6
1
14
2
1 -1
4
5 5 5 1
3
3 2 1
2
0 1
5
-239 -2 -100 -3 -11
Output
YES
YES
YES
NO
NO
YES
Note
In the first test case, every guest is shifted by 14 rooms, so the assignment is still unique.
In the second test case, even guests move to the right by 1 room, and odd guests move to the left by 1 room. We can show that the assignment is still unique.
In the third test case, every fourth guest moves to the right by 1 room, and the other guests move to the right by 5 rooms. We can show that the assignment is still unique.
In the fourth test case, guests 0 and 1 are both assigned to room 3.
In the fifth test case, guests 1 and 2 are both assigned to room 2. | instruction | 0 | 44,001 | 14 | 88,002 |
Tags: math, number theory, sortings
Correct Solution:
```
import sys
def read_int():
return int(sys.stdin.readline())
def read_ints():
return list(map(int, sys.stdin.readline().split()))
# t = 6
t = read_int()
# input1 = [1, [14], 2, [1, -1], 4, [5, 5, 5, 1], 3, [3, 2, 1], 2, [0, 1], 5, [-239, -2, -100, -3, -11]]
for j in range(t):
n = read_int() #input1[2 * j]
a = read_ints() #input1[2 * j + 1]
steps = []
for i in range(n):
step = (i + a[i] % n ) % n
steps.append(step)
if len(set(steps)) == n:
print('YES')
else:
print('NO')
``` | output | 1 | 44,001 | 14 | 88,003 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.