text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has drawn a tree (an undirected connected acyclic graph) and then has given each vertex an index. All indices are distinct numbers from 1 to n. For every edge e of this tree, Monocarp has written two numbers: the maximum indices of the vertices of the two components formed if the edge e (and only this edge) is erased from the tree.
Monocarp has given you a list of n - 1 pairs of numbers. He wants you to provide an example of a tree that will produce the said list if this tree exists. If such tree does not exist, say so.
Input
The first line contains one integer n (2 ≤ n ≤ 1 000) — the number of vertices in the tree.
Each of the next n-1 lines contains two integers a_i and b_i each (1 ≤ a_i < b_i ≤ n) — the maximal indices of vertices in the components formed if the i-th edge is removed.
Output
If there is no such tree that can produce the given list of pairs, print "NO" (without quotes).
Otherwise print "YES" (without quotes) in the first line and the edges of the tree in the next n - 1 lines. Each of the last n - 1 lines should contain two integers x_i and y_i (1 ≤ x_i, y_i ≤ n) — vertices connected by an edge.
Note: The numeration of edges doesn't matter for this task. Your solution will be considered correct if your tree produces the same pairs as given in the input file (possibly reordered). That means that you can print the edges of the tree you reconstructed in any order.
Examples
Input
4
3 4
1 4
3 4
Output
YES
1 3
3 2
2 4
Input
3
1 3
1 3
Output
NO
Input
3
1 2
2 3
Output
NO
Note
Possible tree from the first example. Dotted lines show edges you need to remove to get appropriate pairs.
<image>
Tags: constructive algorithms, data structures, graphs, greedy
Correct Solution:
```
n = int(input())
indices = []
for i in range(n-1):
x, y = map(int, input().split())
indices.append((x, y))
try:
not_seen = set(list(range(1, n)))
seen = {}
for x, y in indices:
assert(x == n or y == n)
seen.setdefault(min(x, y), 0)
seen[min(x, y)] += 1
if min(x, y) in not_seen:
not_seen.remove(min(x, y))
not_seen = sorted(list(not_seen), reverse=True)
seen_list = list(seen.keys())
seen_list.sort(reverse=True)
edges = []
while seen_list:
cur_elem = seen_list.pop(0)
prev = n
while seen[cur_elem] != 1:
assert(not_seen[0] < cur_elem)
next_elem = not_seen.pop(0)
edges.append((prev, next_elem))
prev = next_elem
seen[cur_elem] -= 1
edges.append((prev, cur_elem))
print("YES")
for x, y in edges:
print(x, y)
except AssertionError:
print("NO")
```
| 94,400 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has drawn a tree (an undirected connected acyclic graph) and then has given each vertex an index. All indices are distinct numbers from 1 to n. For every edge e of this tree, Monocarp has written two numbers: the maximum indices of the vertices of the two components formed if the edge e (and only this edge) is erased from the tree.
Monocarp has given you a list of n - 1 pairs of numbers. He wants you to provide an example of a tree that will produce the said list if this tree exists. If such tree does not exist, say so.
Input
The first line contains one integer n (2 ≤ n ≤ 1 000) — the number of vertices in the tree.
Each of the next n-1 lines contains two integers a_i and b_i each (1 ≤ a_i < b_i ≤ n) — the maximal indices of vertices in the components formed if the i-th edge is removed.
Output
If there is no such tree that can produce the given list of pairs, print "NO" (without quotes).
Otherwise print "YES" (without quotes) in the first line and the edges of the tree in the next n - 1 lines. Each of the last n - 1 lines should contain two integers x_i and y_i (1 ≤ x_i, y_i ≤ n) — vertices connected by an edge.
Note: The numeration of edges doesn't matter for this task. Your solution will be considered correct if your tree produces the same pairs as given in the input file (possibly reordered). That means that you can print the edges of the tree you reconstructed in any order.
Examples
Input
4
3 4
1 4
3 4
Output
YES
1 3
3 2
2 4
Input
3
1 3
1 3
Output
NO
Input
3
1 2
2 3
Output
NO
Note
Possible tree from the first example. Dotted lines show edges you need to remove to get appropriate pairs.
<image>
Tags: constructive algorithms, data structures, graphs, greedy
Correct Solution:
```
n = int(input())
V = []
for _ in range(n-1):
a,b = map(int, input().split())
V.append(a)
if b <n:
print('NO')
quit()
V.sort()
for i in range(n-1):
if V[i]<=i:
print("NO")
quit()
used = [False]*(n+1)
tree = []
for i in range(n-1):
v = V[i]
if not used[v]:
tree.append(v)
used[v]=True
else:
for j in range(1,n+1):
if not used[j]:
tree.append(j)
used[j] = True
break
tree.append(n)
print("YES")
for i in range(n-1):
print(tree[i],tree[i+1])
```
| 94,401 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has drawn a tree (an undirected connected acyclic graph) and then has given each vertex an index. All indices are distinct numbers from 1 to n. For every edge e of this tree, Monocarp has written two numbers: the maximum indices of the vertices of the two components formed if the edge e (and only this edge) is erased from the tree.
Monocarp has given you a list of n - 1 pairs of numbers. He wants you to provide an example of a tree that will produce the said list if this tree exists. If such tree does not exist, say so.
Input
The first line contains one integer n (2 ≤ n ≤ 1 000) — the number of vertices in the tree.
Each of the next n-1 lines contains two integers a_i and b_i each (1 ≤ a_i < b_i ≤ n) — the maximal indices of vertices in the components formed if the i-th edge is removed.
Output
If there is no such tree that can produce the given list of pairs, print "NO" (without quotes).
Otherwise print "YES" (without quotes) in the first line and the edges of the tree in the next n - 1 lines. Each of the last n - 1 lines should contain two integers x_i and y_i (1 ≤ x_i, y_i ≤ n) — vertices connected by an edge.
Note: The numeration of edges doesn't matter for this task. Your solution will be considered correct if your tree produces the same pairs as given in the input file (possibly reordered). That means that you can print the edges of the tree you reconstructed in any order.
Examples
Input
4
3 4
1 4
3 4
Output
YES
1 3
3 2
2 4
Input
3
1 3
1 3
Output
NO
Input
3
1 2
2 3
Output
NO
Note
Possible tree from the first example. Dotted lines show edges you need to remove to get appropriate pairs.
<image>
Tags: constructive algorithms, data structures, graphs, greedy
Correct Solution:
```
from sys import stdin
def bad():
print('NO')
exit()
all_in = stdin.readlines()
n = int(all_in[0])
pair = list(map(lambda x: tuple(map(int, x.split())), all_in[1:]))
f = True
for i in range(n - 1):
if pair[i][0] == n - 1:
f = False
if pair[i][1] != n:
bad()
if f:
bad()
pair.sort(key=lambda x: x[0])
p = list(map(lambda x: x[0], pair))
ans = [0 for i in range(n)]
st = set(range(1, n))
ans[0] = p[0]
st.remove(p[0])
a, b = 0, p[0]
for i in range(1, n - 1):
a, b = b, p[i]
if b != a:
ans[i] = b
st.remove(b)
ans[-1] = n
max_ = 0
for i in range(n):
el = ans[i]
max_ = max(max_, el)
if not el:
m = min(st)
if m > max_:
bad()
ans[i] = m
st.remove(m)
print('YES')
print('\n'.join(map(lambda i: f'{ans[i - 1]} {ans[i]}', range(1, n))))
```
| 94,402 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has drawn a tree (an undirected connected acyclic graph) and then has given each vertex an index. All indices are distinct numbers from 1 to n. For every edge e of this tree, Monocarp has written two numbers: the maximum indices of the vertices of the two components formed if the edge e (and only this edge) is erased from the tree.
Monocarp has given you a list of n - 1 pairs of numbers. He wants you to provide an example of a tree that will produce the said list if this tree exists. If such tree does not exist, say so.
Input
The first line contains one integer n (2 ≤ n ≤ 1 000) — the number of vertices in the tree.
Each of the next n-1 lines contains two integers a_i and b_i each (1 ≤ a_i < b_i ≤ n) — the maximal indices of vertices in the components formed if the i-th edge is removed.
Output
If there is no such tree that can produce the given list of pairs, print "NO" (without quotes).
Otherwise print "YES" (without quotes) in the first line and the edges of the tree in the next n - 1 lines. Each of the last n - 1 lines should contain two integers x_i and y_i (1 ≤ x_i, y_i ≤ n) — vertices connected by an edge.
Note: The numeration of edges doesn't matter for this task. Your solution will be considered correct if your tree produces the same pairs as given in the input file (possibly reordered). That means that you can print the edges of the tree you reconstructed in any order.
Examples
Input
4
3 4
1 4
3 4
Output
YES
1 3
3 2
2 4
Input
3
1 3
1 3
Output
NO
Input
3
1 2
2 3
Output
NO
Note
Possible tree from the first example. Dotted lines show edges you need to remove to get appropriate pairs.
<image>
Tags: constructive algorithms, data structures, graphs, greedy
Correct Solution:
```
from copy import deepcopy
import itertools
from bisect import bisect_left
from bisect import bisect_right
import math
from collections import deque
from collections import Counter
def read():
return int(input())
def readmap():
return map(int, input().split())
def readlist():
return list(map(int, input().split()))
n = read()
V = []
for _ in range(n-1):
a, b = readmap()
V.append(a)
if b < n:
print("NO")
quit()
V.sort()
for i in range(n-1):
if V[i] <= i:
print("NO")
quit()
used = [False] * (n+1)
tree = []
for i in range(n-1):
v = V[i]
if not used[v]:
tree.append(v)
used[v] = True
else:
for j in range(1, n+1):
if not used[j]:
tree.append(j)
used[j] = True
break
tree.append(n)
print("YES")
for i in range(n-1):
print(tree[i], tree[i+1])
```
| 94,403 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp has drawn a tree (an undirected connected acyclic graph) and then has given each vertex an index. All indices are distinct numbers from 1 to n. For every edge e of this tree, Monocarp has written two numbers: the maximum indices of the vertices of the two components formed if the edge e (and only this edge) is erased from the tree.
Monocarp has given you a list of n - 1 pairs of numbers. He wants you to provide an example of a tree that will produce the said list if this tree exists. If such tree does not exist, say so.
Input
The first line contains one integer n (2 ≤ n ≤ 1 000) — the number of vertices in the tree.
Each of the next n-1 lines contains two integers a_i and b_i each (1 ≤ a_i < b_i ≤ n) — the maximal indices of vertices in the components formed if the i-th edge is removed.
Output
If there is no such tree that can produce the given list of pairs, print "NO" (without quotes).
Otherwise print "YES" (without quotes) in the first line and the edges of the tree in the next n - 1 lines. Each of the last n - 1 lines should contain two integers x_i and y_i (1 ≤ x_i, y_i ≤ n) — vertices connected by an edge.
Note: The numeration of edges doesn't matter for this task. Your solution will be considered correct if your tree produces the same pairs as given in the input file (possibly reordered). That means that you can print the edges of the tree you reconstructed in any order.
Examples
Input
4
3 4
1 4
3 4
Output
YES
1 3
3 2
2 4
Input
3
1 3
1 3
Output
NO
Input
3
1 2
2 3
Output
NO
Note
Possible tree from the first example. Dotted lines show edges you need to remove to get appropriate pairs.
<image>
Tags: constructive algorithms, data structures, graphs, greedy
Correct Solution:
```
from bisect import bisect
from collections import defaultdict
# l = list(map(int,input().split()))
# map(int,input().split()))
from math import gcd,sqrt,ceil
from collections import Counter
import sys
sys.setrecursionlimit(10**9)
ans = []
n = int(input())
ba = [i for i in range(1,n+1)]
yo = set(i for i in range(1,n+1))
la = []
hash = defaultdict(int)
for i in range(n-1):
a,b = map(int,input().split())
la.append([max(a,b),min(a,b)])
if a!=n and b!=n:
print('NO')
exit()
if a == b:
print('NO')
exit()
hash[min(a,b)]+=1
seti = set()
for i in range(1,n):
z = hash[i]
j = i-2
if z == 0:
continue
if z == 1:
ans.append([i,n])
yo.remove(i)
continue
z-=1
if z>j:
print('NO')
exit()
if j<0:
print('NO')
exit()
now = i
ha = []
count = 0
while j>=0:
if count == z:
break
if ba[j] in yo:
ans.append([now,ba[j]])
yo.remove(now)
now = ba[j]
j-=1
count+=1
else:
j-=1
if count!=z:
print('NO')
exit()
yo.remove(ans[-1][1])
ans.append([ans[-1][1],n])
print('YES')
for a,b in ans:
print(a,b)
```
| 94,404 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has drawn a tree (an undirected connected acyclic graph) and then has given each vertex an index. All indices are distinct numbers from 1 to n. For every edge e of this tree, Monocarp has written two numbers: the maximum indices of the vertices of the two components formed if the edge e (and only this edge) is erased from the tree.
Monocarp has given you a list of n - 1 pairs of numbers. He wants you to provide an example of a tree that will produce the said list if this tree exists. If such tree does not exist, say so.
Input
The first line contains one integer n (2 ≤ n ≤ 1 000) — the number of vertices in the tree.
Each of the next n-1 lines contains two integers a_i and b_i each (1 ≤ a_i < b_i ≤ n) — the maximal indices of vertices in the components formed if the i-th edge is removed.
Output
If there is no such tree that can produce the given list of pairs, print "NO" (without quotes).
Otherwise print "YES" (without quotes) in the first line and the edges of the tree in the next n - 1 lines. Each of the last n - 1 lines should contain two integers x_i and y_i (1 ≤ x_i, y_i ≤ n) — vertices connected by an edge.
Note: The numeration of edges doesn't matter for this task. Your solution will be considered correct if your tree produces the same pairs as given in the input file (possibly reordered). That means that you can print the edges of the tree you reconstructed in any order.
Examples
Input
4
3 4
1 4
3 4
Output
YES
1 3
3 2
2 4
Input
3
1 3
1 3
Output
NO
Input
3
1 2
2 3
Output
NO
Note
Possible tree from the first example. Dotted lines show edges you need to remove to get appropriate pairs.
<image>
Submitted Solution:
```
from sys import stdin, stdout
# 4
# 1 4
# 3 4
# 3 4
def three_reconstruction(n, ab_a):
res = []
cnt = [0] * (n + 1)
for ab in ab_a:
a, b = ab
if (a != n and b != n) or a == b:
return [False]
cnt[min(a, b)] += 1
cur = 0
for i in range(1, n+1):
cur += cnt[i]
if cur > i:
return [False]
hs = set()
for i in range(1, n + 1):
hs.add(i)
# print(hs)
last = -1
for i in range(1, n+1):
if cnt[i] > 0:
hs.remove(i)
if last != -1:
res.append([last, i])
last = i
cnt[i] -= 1
while cnt[i] > 0:
v = min(hs)
res.append([last, v])
last = v
cnt[i] -= 1
hs.remove(v)
res.append([last, n])
return [True, res]
n = int(stdin.readline())
ab_a = []
for _ in range(n-1):
ab_a.append(list(map(int, stdin.readline().split())))
res = three_reconstruction(n, ab_a)
if res[0]:
stdout.write('YES\n')
for p in res[1]:
stdout.write(str(p[0]) + ' ' + str(p[1]) + '\n')
else:
stdout.write('NO\n')
```
Yes
| 94,405 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has drawn a tree (an undirected connected acyclic graph) and then has given each vertex an index. All indices are distinct numbers from 1 to n. For every edge e of this tree, Monocarp has written two numbers: the maximum indices of the vertices of the two components formed if the edge e (and only this edge) is erased from the tree.
Monocarp has given you a list of n - 1 pairs of numbers. He wants you to provide an example of a tree that will produce the said list if this tree exists. If such tree does not exist, say so.
Input
The first line contains one integer n (2 ≤ n ≤ 1 000) — the number of vertices in the tree.
Each of the next n-1 lines contains two integers a_i and b_i each (1 ≤ a_i < b_i ≤ n) — the maximal indices of vertices in the components formed if the i-th edge is removed.
Output
If there is no such tree that can produce the given list of pairs, print "NO" (without quotes).
Otherwise print "YES" (without quotes) in the first line and the edges of the tree in the next n - 1 lines. Each of the last n - 1 lines should contain two integers x_i and y_i (1 ≤ x_i, y_i ≤ n) — vertices connected by an edge.
Note: The numeration of edges doesn't matter for this task. Your solution will be considered correct if your tree produces the same pairs as given in the input file (possibly reordered). That means that you can print the edges of the tree you reconstructed in any order.
Examples
Input
4
3 4
1 4
3 4
Output
YES
1 3
3 2
2 4
Input
3
1 3
1 3
Output
NO
Input
3
1 2
2 3
Output
NO
Note
Possible tree from the first example. Dotted lines show edges you need to remove to get appropriate pairs.
<image>
Submitted Solution:
```
n = int(input())
a = []
fr = [0]*10000
for i in range(n-1):
x,y = map(int,input().split())
if x == y or (x < n and y < n):
print("NO")
exit(0)
if x == n:
a.append(y)
else:
a.append(x)
b = []
for i in range(1,n+1):
if i not in a:
b.append(i)
for i in a:
if fr[i] == 0:
fr[i] = n
continue
tep = 0
record = 0
for j in range(len(b)):
if b[j] and b[j]<i:
if b[j]>tep:
tep = b[j]
record = j
b[record] = 0
if tep == 0:
print("NO")
exit(0)
fr[tep] = fr[i]
fr[i] = tep
print("YES")
for i in range(1,n):
print(i,fr[i])
```
Yes
| 94,406 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has drawn a tree (an undirected connected acyclic graph) and then has given each vertex an index. All indices are distinct numbers from 1 to n. For every edge e of this tree, Monocarp has written two numbers: the maximum indices of the vertices of the two components formed if the edge e (and only this edge) is erased from the tree.
Monocarp has given you a list of n - 1 pairs of numbers. He wants you to provide an example of a tree that will produce the said list if this tree exists. If such tree does not exist, say so.
Input
The first line contains one integer n (2 ≤ n ≤ 1 000) — the number of vertices in the tree.
Each of the next n-1 lines contains two integers a_i and b_i each (1 ≤ a_i < b_i ≤ n) — the maximal indices of vertices in the components formed if the i-th edge is removed.
Output
If there is no such tree that can produce the given list of pairs, print "NO" (without quotes).
Otherwise print "YES" (without quotes) in the first line and the edges of the tree in the next n - 1 lines. Each of the last n - 1 lines should contain two integers x_i and y_i (1 ≤ x_i, y_i ≤ n) — vertices connected by an edge.
Note: The numeration of edges doesn't matter for this task. Your solution will be considered correct if your tree produces the same pairs as given in the input file (possibly reordered). That means that you can print the edges of the tree you reconstructed in any order.
Examples
Input
4
3 4
1 4
3 4
Output
YES
1 3
3 2
2 4
Input
3
1 3
1 3
Output
NO
Input
3
1 2
2 3
Output
NO
Note
Possible tree from the first example. Dotted lines show edges you need to remove to get appropriate pairs.
<image>
Submitted Solution:
```
import sys
n = int(input())
mentioned = [0] * (n - 1)
for _ in range(n-1):
a, b = map(int, input().split())
if b != n:
print("NO")
sys.exit()
else:
mentioned[a-1] += 1
if mentioned[a-1] > a:
print("NO")
sys.exit()
if mentioned[-1] == 0:
print("NO")
sys.exit()
cnt = 0
for i in range(n - 2, -1, -1):
cnt += mentioned[i] - 1
if cnt < 0:
print("NO")
sys.exit()
print("YES")
end = [i for i in range(n - 1) if mentioned[i] > 0]
mid = [i for i in range(n - 1) if mentioned[i] == 0]
#for i in range(1, len(end)):
# branch = [end[i] + 1]
# branch += list(range(end[i-1] + 2, end[i] + 1))
# branch.append(n)
# for j in range(len(branch) - 1):
# print(branch[j], branch[j + 1])
branch_sum = [mentioned[end[0]] - 1]
for i in range(1, len(end)):
branch_sum.append(branch_sum[-1] + mentioned[end[i]] - 1)
branch = [[] for _ in range(len(end))]
branch[0] = mid[:branch_sum[0]]
for i in range(1, len(end)):
branch[i] = mid[branch_sum[i-1]:branch_sum[i]]
#print(end)
#print(branch)
for i in range(len(end)):
ans = [end[i] + 1]
ans += [j + 1 for j in branch[i]]
ans.append(n)
for j in range(len(ans) - 1):
print(ans[j], ans[j + 1])
```
Yes
| 94,407 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has drawn a tree (an undirected connected acyclic graph) and then has given each vertex an index. All indices are distinct numbers from 1 to n. For every edge e of this tree, Monocarp has written two numbers: the maximum indices of the vertices of the two components formed if the edge e (and only this edge) is erased from the tree.
Monocarp has given you a list of n - 1 pairs of numbers. He wants you to provide an example of a tree that will produce the said list if this tree exists. If such tree does not exist, say so.
Input
The first line contains one integer n (2 ≤ n ≤ 1 000) — the number of vertices in the tree.
Each of the next n-1 lines contains two integers a_i and b_i each (1 ≤ a_i < b_i ≤ n) — the maximal indices of vertices in the components formed if the i-th edge is removed.
Output
If there is no such tree that can produce the given list of pairs, print "NO" (without quotes).
Otherwise print "YES" (without quotes) in the first line and the edges of the tree in the next n - 1 lines. Each of the last n - 1 lines should contain two integers x_i and y_i (1 ≤ x_i, y_i ≤ n) — vertices connected by an edge.
Note: The numeration of edges doesn't matter for this task. Your solution will be considered correct if your tree produces the same pairs as given in the input file (possibly reordered). That means that you can print the edges of the tree you reconstructed in any order.
Examples
Input
4
3 4
1 4
3 4
Output
YES
1 3
3 2
2 4
Input
3
1 3
1 3
Output
NO
Input
3
1 2
2 3
Output
NO
Note
Possible tree from the first example. Dotted lines show edges you need to remove to get appropriate pairs.
<image>
Submitted Solution:
```
n=int(input())
count1=0
count2=0
arr=[]
arr1=[]
arr2=[]
for i in range(n-1):
x,y=map(int,input().split())
arr.append((x,y))
arr1.append(x)
if(y==n):
count1+=1
if(x==1):
count2+=1
if(count1<n-1 or count2>1):
print('NO')
else:
arr.sort()
i=1
arry=[]
arry.append((arr[0][0],arr[1][0]))
val1=arr[1][0]
val2=arr[0][0]
arrx=[0]*(n+1)
arrx[arr[0][0]]=1
flag=0
while(i<n-1):
if(val1-val2!=arr1.count(val1)):
flag=1
break
while(val1>val2):
val3=val1-1
while(arrx[val3]==1 and val3>0):
val3-=1
if(val3>0):
arry.append((val1,val3))
arrx[val1]=1
val1=val3
i+=1
#print(arry)
else:
break
if(i<n-2):
arry.append((val1,arr[i+1][0]))
arrx[val1]=1
val2=val1
val1=arr[i+1][0]
i+=1
#print(i,arry,val1,val2)
if(flag==1):
print('NO')
else:
arry.append((val1,n))
print('YES')
for i in range(n-1):
print(arry[i][0],arry[i][1])
```
No
| 94,408 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has drawn a tree (an undirected connected acyclic graph) and then has given each vertex an index. All indices are distinct numbers from 1 to n. For every edge e of this tree, Monocarp has written two numbers: the maximum indices of the vertices of the two components formed if the edge e (and only this edge) is erased from the tree.
Monocarp has given you a list of n - 1 pairs of numbers. He wants you to provide an example of a tree that will produce the said list if this tree exists. If such tree does not exist, say so.
Input
The first line contains one integer n (2 ≤ n ≤ 1 000) — the number of vertices in the tree.
Each of the next n-1 lines contains two integers a_i and b_i each (1 ≤ a_i < b_i ≤ n) — the maximal indices of vertices in the components formed if the i-th edge is removed.
Output
If there is no such tree that can produce the given list of pairs, print "NO" (without quotes).
Otherwise print "YES" (without quotes) in the first line and the edges of the tree in the next n - 1 lines. Each of the last n - 1 lines should contain two integers x_i and y_i (1 ≤ x_i, y_i ≤ n) — vertices connected by an edge.
Note: The numeration of edges doesn't matter for this task. Your solution will be considered correct if your tree produces the same pairs as given in the input file (possibly reordered). That means that you can print the edges of the tree you reconstructed in any order.
Examples
Input
4
3 4
1 4
3 4
Output
YES
1 3
3 2
2 4
Input
3
1 3
1 3
Output
NO
Input
3
1 2
2 3
Output
NO
Note
Possible tree from the first example. Dotted lines show edges you need to remove to get appropriate pairs.
<image>
Submitted Solution:
```
n=int(input())
count1=0
count2=0
arr=[]
arr1=[]
arr2=[]
for i in range(n-1):
x,y=map(int,input().split())
arr.append((x,y))
arr1.append(x)
if(y==n):
count1+=1
if(x==1):
count2+=1
if(count1<n-1 or count2>1):
print('NO')
else:
arr.sort()
i=1
arry=[]
arry.append((arr[0][0],arr[1][0]))
val1=arr[1][0]
val2=arr[0][0]
arrx=[0]*(n+1)
arrx[arr[0][0]]=1
flag=0
while(i<n-1):
if(i>arr1.count(val1)+i):
flag=1
break
while(val1>val2):
val3=val1-1
while(arrx[val3]==1 and val3>0):
val3-=1
if(val3>0):
arry.append((val1,val3))
arrx[val1]=1
val1=val3
i+=1
#print(arry)
else:
break
if(i<n-2):
arry.append((val1,arr[i+1][0]))
arrx[val1]=1
val2=val1
val1=arr[i+1][0]
i+=1
#print(i,arry,val1,val2)
if(flag==1):
print('NO')
else:
arry.append((val1,n))
print('YES')
for i in range(n-1):
print(arry[i][0],arry[i][1])
```
No
| 94,409 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has drawn a tree (an undirected connected acyclic graph) and then has given each vertex an index. All indices are distinct numbers from 1 to n. For every edge e of this tree, Monocarp has written two numbers: the maximum indices of the vertices of the two components formed if the edge e (and only this edge) is erased from the tree.
Monocarp has given you a list of n - 1 pairs of numbers. He wants you to provide an example of a tree that will produce the said list if this tree exists. If such tree does not exist, say so.
Input
The first line contains one integer n (2 ≤ n ≤ 1 000) — the number of vertices in the tree.
Each of the next n-1 lines contains two integers a_i and b_i each (1 ≤ a_i < b_i ≤ n) — the maximal indices of vertices in the components formed if the i-th edge is removed.
Output
If there is no such tree that can produce the given list of pairs, print "NO" (without quotes).
Otherwise print "YES" (without quotes) in the first line and the edges of the tree in the next n - 1 lines. Each of the last n - 1 lines should contain two integers x_i and y_i (1 ≤ x_i, y_i ≤ n) — vertices connected by an edge.
Note: The numeration of edges doesn't matter for this task. Your solution will be considered correct if your tree produces the same pairs as given in the input file (possibly reordered). That means that you can print the edges of the tree you reconstructed in any order.
Examples
Input
4
3 4
1 4
3 4
Output
YES
1 3
3 2
2 4
Input
3
1 3
1 3
Output
NO
Input
3
1 2
2 3
Output
NO
Note
Possible tree from the first example. Dotted lines show edges you need to remove to get appropriate pairs.
<image>
Submitted Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
#import threading
from collections import defaultdict
#threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
#sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=300006, func=lambda a, b: min(a , b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b:a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] <=key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
class TrieNode:
def __init__(self):
self.children = [None] * 26
self.isEndOfWord = False
class Trie:
def __init__(self):
self.root = self.getNode()
def getNode(self):
return TrieNode()
def _charToIndex(self, ch):
return ord(ch) - ord('a')
def insert(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
pCrawl.children[index] = self.getNode()
pCrawl = pCrawl.children[index]
pCrawl.isEndOfWord = True
def search(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
return False
pCrawl = pCrawl.children[index]
return pCrawl != None and pCrawl.isEndOfWord
#-----------------------------------------trie---------------------------------
class Node:
def __init__(self, data):
self.data = data
self.count=0
self.left = None # left node for 0
self.right = None # right node for 1
class BinaryTrie:
def __init__(self):
self.root = Node(0)
def insert(self, pre_xor):
self.temp = self.root
for i in range(31, -1, -1):
val = pre_xor & (1 << i)
if val:
if not self.temp.right:
self.temp.right = Node(0)
self.temp = self.temp.right
self.temp.count+=1
if not val:
if not self.temp.left:
self.temp.left = Node(0)
self.temp = self.temp.left
self.temp.count += 1
self.temp.data = pre_xor
def query(self, xor):
self.temp = self.root
for i in range(31, -1, -1):
val = xor & (1 << i)
if not val:
if self.temp.left and self.temp.left.count>0:
self.temp = self.temp.left
elif self.temp.right:
self.temp = self.temp.right
else:
if self.temp.right and self.temp.right.count>0:
self.temp = self.temp.right
elif self.temp.left:
self.temp = self.temp.left
self.temp.count-=1
return xor ^ self.temp.data
#-------------------------bin trie-------------------------------------------
n=int(input())
ans=[]
f=0
d=defaultdict(int)
for i in range(n-1):
a,b=map(int,input().split())
if b!=n:
f=1
d[a]+=1
t=n-1
if f==1:
print("NO")
sys.exit(0)
for i in sorted(d,reverse=True):
last=i
t=min(t,i-1)
while t in d:
t -= 1
for j in range(d[i]-1):
if t<=0:
print("NO")
sys.exit(0)
ans.append((last,t))
last=t
ans.append((n,last))
print("YES")
for i in range(n-1):
print(*ans[i])
```
No
| 94,410 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp has drawn a tree (an undirected connected acyclic graph) and then has given each vertex an index. All indices are distinct numbers from 1 to n. For every edge e of this tree, Monocarp has written two numbers: the maximum indices of the vertices of the two components formed if the edge e (and only this edge) is erased from the tree.
Monocarp has given you a list of n - 1 pairs of numbers. He wants you to provide an example of a tree that will produce the said list if this tree exists. If such tree does not exist, say so.
Input
The first line contains one integer n (2 ≤ n ≤ 1 000) — the number of vertices in the tree.
Each of the next n-1 lines contains two integers a_i and b_i each (1 ≤ a_i < b_i ≤ n) — the maximal indices of vertices in the components formed if the i-th edge is removed.
Output
If there is no such tree that can produce the given list of pairs, print "NO" (without quotes).
Otherwise print "YES" (without quotes) in the first line and the edges of the tree in the next n - 1 lines. Each of the last n - 1 lines should contain two integers x_i and y_i (1 ≤ x_i, y_i ≤ n) — vertices connected by an edge.
Note: The numeration of edges doesn't matter for this task. Your solution will be considered correct if your tree produces the same pairs as given in the input file (possibly reordered). That means that you can print the edges of the tree you reconstructed in any order.
Examples
Input
4
3 4
1 4
3 4
Output
YES
1 3
3 2
2 4
Input
3
1 3
1 3
Output
NO
Input
3
1 2
2 3
Output
NO
Note
Possible tree from the first example. Dotted lines show edges you need to remove to get appropriate pairs.
<image>
Submitted Solution:
```
#
def solve():
n = int(input())
d = {}
for _ in range(n-1):
u, v = map(int, input().split())
min_ = min(u, v)
max_ = max(u, v)
if max_ != n:
return False, None
if min_ not in d:
d[min_] = 0
d[min_] += 1
if sum(list(d.values())) + 1 != n:
return False, None
edge = []
used = {i:False for i in range(1, n+1)}
for k in sorted(list(d.keys())):
used[k] = True
mid = [n]
for i in range(k-1, 0, -1): # k-1->1
if len(mid) == d[k]:
break
if used[i] == False:
used[i] = True
mid.append(i)
if len(mid) < d[k]:
return False, None
mid.append(k)
for u, v in zip(mid[:-1], mid[1:]):
edge.append([u, v])
return True, edge
ans, arr = solve()
if ans == False:
print('No')
else:
print('Yes')
for u, v in arr:
print(str(u)+' '+str(v))
#4
#3 4
#1 4
#3 4
```
No
| 94,411 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
Tags: graphs, shortest paths
Correct Solution:
```
from collections import deque
n, m = map(int, input().split())
sx, sy = map(int, input().split())
tl, tr = map(int, input().split())
g = [input() for i in range(n)]
sx -= 1
sy -= 1
dis = [[-1 for j in range(m)] for i in range(n)]
q = deque()
def go(x, y, s, left=False):
if 0 <= x < n and 0 <= y < m:
if g[x][y] == '.' and dis[x][y] == -1:
dis[x][y] = s
if left:
q.appendleft((x, y))
else:
q.append((x, y));
go(sx, sy, 0)
ans = 0
while q:
x, y = q.popleft()
s = dis[x][y]
# print(x, y)
ans += s + y - sy <= tr * 2 and s - y + sy <= tl * 2
go(x - 1, y, s, left=True)
go(x + 1, y, s, left=True)
go(x, y - 1, s + 1)
go(x, y + 1, s + 1)
print(ans)
```
| 94,412 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
Tags: graphs, shortest paths
Correct Solution:
```
from collections import deque
n,m = map(int, input().split())
r,c = map(int, input().split())
x,y = map(int, input().split())
gr = []
vd = [[0]*m for i in range(n)]
r -= 1
c -= 1
ans = 0
for i in range(n):
gr.append(input())
to_visit = deque()
to_visit.append((r,c,x,y))
while to_visit:
ri, ci, xi, yi = to_visit.popleft()
ru = ri
while ru >= 0 and gr[ru][ci] == '.' and not vd[ru][ci]:
vd[ru][ci] = 1
ans += 1
if xi > 0 and ci-1 >= 0 and gr[ru][ci-1] == '.' and not vd[ru][ci-1]:
to_visit.append((ru, ci-1, xi-1, yi))
if yi > 0 and ci+1 < m and gr[ru][ci+1] == '.' and not vd[ru][ci+1]:
to_visit.append((ru, ci+1, xi, yi-1))
ru -= 1
rd = ri + 1
while rd < n and gr[rd][ci] == '.' and not vd[rd][ci]:
vd[rd][ci] = 1
ans += 1
if xi > 0 and ci-1 >= 0 and gr[rd][ci-1] == '.' and not vd[rd][ci-1]:
to_visit.append((rd, ci-1, xi-1, yi))
if yi > 0 and ci+1 < m and gr[rd][ci+1] == '.' and not vd[rd][ci+1]:
to_visit.append((rd, ci+1, xi, yi-1))
rd += 1
# print(*vd, sep='\n')
# print(*gr, sep='\n')
print(ans)
```
| 94,413 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
Tags: graphs, shortest paths
Correct Solution:
```
'''input
4 5
3 2
1 2
.....
.***.
...**
*....
3 5
3 2
1 2
.....
.***.
...**
4 4
2 2
0 1
....
..*.
....
....
'''
from collections import deque
n, m = map(int, input().split())
sx, sy = map(int, input().split())
tl, tr = map(int, input().split())
g = [input() for i in range(n)]
sx -= 1
sy -= 1
dis = [[-1 for j in range(m)] for i in range(n)]
q = deque()
def go(x, y, s, left=False):
if 0 <= x < n and 0 <= y < m:
if s + y - sy > tr * 2:
return
if s - y + sy > tl * 2:
return
if g[x][y] == '*':
return
if dis[x][y] == -1:
dis[x][y] = s
if left:
q.appendleft((x, y))
else:
q.append((x, y));
go(sx, sy, 0)
ans = 0
while q:
x, y = q.popleft()
s = dis[x][y]
# print(x, y)
ans += 1
go(x - 1, y, s, left=True)
go(x + 1, y, s, left=True)
go(x, y - 1, s + 1)
go(x, y + 1, s + 1)
print(ans)
```
| 94,414 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
Tags: graphs, shortest paths
Correct Solution:
```
n, m = map(int, input().split())
r, c = map(int, input().split())
r, c = r-1, c-1
X, Y = map(int, input().split())
S = [input() for i in range(n)]
L = [[-1]*m for i in range(n)]
R = [[-1]*m for i in range(n)]
from collections import deque
q = deque([])
q.append((r, c))
L[r][c] = 0
R[r][c] = 0
while q:
y, x = q.popleft()
for dy in (-1, 1):
ny, x = y+dy, x
if 0 <= ny < n:
if S[ny][x] == '*':
continue
if L[ny][x] == -1 and R[ny][x] == -1:
q.appendleft((ny, x))
L[ny][x] = L[y][x]
R[ny][x] = R[y][x]
if L[ny][x] > L[y][x]:
L[ny][x] = L[y][x]
if R[ny][x] > R[y][x]:
R[ny][x] = R[y][x]
for dx in (-1, 1):
y, nx = y, x+dx
if 0 <= nx < m:
if S[y][nx] == '*':
continue
if L[y][nx] == -1 and R[y][nx] == -1:
q.append((y, nx))
if dx == 1:
R[y][nx] = R[y][x]+1
L[y][nx] = L[y][x]
else:
L[y][nx] = L[y][x]+1
R[y][nx] = R[y][x]
if L[y][nx] > L[y][x]+1:
L[y][nx] = L[y][x]+1
if R[y][nx] > R[y][x]+1:
R[y][nx] = R[y][x]+1
#print(L)
#print(R)
ans = 0
for i in range(n):
for j in range(m):
if L[i][j] == -1 or R[i][j] == -1:
continue
if L[i][j] <= X and R[i][j] <= Y:
ans += 1
print(ans)
```
| 94,415 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
Tags: graphs, shortest paths
Correct Solution:
```
from collections import deque
def move(tx, ty, s, left=False):
if 0 <= tx < n and 0 <= ty < m:
if smap[tx][ty] == '.' and mp[tx][ty] == -1:
mp[tx][ty] = s
if left:
q.appendleft((tx, ty))
else:
q.append((tx, ty))
[n, m] = map(int, input().split())
[sx, sy] = map(int, input().split())
[ll, rr] = map(int, input().split())
smap = [input() for i in range(n)]
q = deque()
mp = [[-1]*m for i in range(n)]
sx, sy = sx-1, sy-1
mp[sx][sy] = 0
ans = 0
q.append((sx, sy))
while q:
px, py = q.popleft()
s = mp[px][py]
ans += s + py - sy <= rr * 2 and s - py + sy <= ll * 2
move(px + 1, py, s, left=True)
move(px - 1, py, s, left=True)
move(px, py - 1, s + 1)
move(px, py + 1, s + 1)
print(ans)
```
| 94,416 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
Tags: graphs, shortest paths
Correct Solution:
```
from collections import deque
n,m = map(int, input().split())
r,c = map(int, input().split())
x,y = map(int, input().split())
gr = []
vd = [[0]*m for i in range(n)]
r -= 1
c -= 1
ans = 0
for i in range(n):
gr.append(list(input()))
to_visit = deque()
to_visit.append((r,c,x,y))
while to_visit:
ri, ci, xi, yi = to_visit.popleft()
ru = ri
while ru >= 0 and gr[ru][ci] == '.' and not vd[ru][ci]:
vd[ru][ci] = 1
ans += 1
if xi > 0 and ci-1 >= 0 and gr[ru][ci-1] == '.' and not vd[ru][ci-1]:
to_visit.append((ru, ci-1, xi-1, yi))
if yi > 0 and ci+1 < m and gr[ru][ci+1] == '.' and not vd[ru][ci+1]:
to_visit.append((ru, ci+1, xi, yi-1))
ru -= 1
rd = ri + 1
while rd < n and gr[rd][ci] == '.' and not vd[rd][ci]:
vd[rd][ci] = 1
ans += 1
if xi > 0 and ci-1 >= 0 and gr[rd][ci-1] == '.' and not vd[rd][ci-1]:
to_visit.append((rd, ci-1, xi-1, yi))
if yi > 0 and ci+1 < m and gr[rd][ci+1] == '.' and not vd[rd][ci+1]:
to_visit.append((rd, ci+1, xi, yi-1))
rd += 1
# print(*vd, sep='\n')
# print(*gr, sep='\n')
print(ans)
```
| 94,417 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
Tags: graphs, shortest paths
Correct Solution:
```
import collections
n,m = map(int,input().split())
r,c = map(int,input().split())
x,y = map(int,input().split())
arr = []
for i in range(n):
arr.append(input())
que = collections.deque([(r-1,c-1)])
dist = [[float("inf")]*m for i in range(n)]
dist[r-1][c-1] = 0
while que:
v = que.popleft()
if v[0]>0 and arr[v[0]-1][v[1]] != "*" and dist[v[0]-1][v[1]] > dist[v[0]][v[1]]:
dist[v[0]-1][v[1]] = dist[v[0]][v[1]]
que.appendleft((v[0]-1,v[1]))
if v[0]<n-1 and arr[v[0]+1][v[1]] != "*" and dist[v[0]+1][v[1]] > dist[v[0]][v[1]]:
dist[v[0]+1][v[1]] = dist[v[0]][v[1]]
que.appendleft((v[0]+1,v[1]))
if v[1]<m-1 and arr[v[0]][v[1]+1] != "*" and dist[v[0]][v[1]+1] > dist[v[0]][v[1]]:
dist[v[0]][v[1]+1] = dist[v[0]][v[1]]
que.appendleft((v[0],v[1]+1))
if v[1]>0 and arr[v[0]][v[1]-1] != "*" and dist[v[0]][v[1]-1] > dist[v[0]][v[1]]+1:
dist[v[0]][v[1]-1] = dist[v[0]][v[1]]+1
que.append((v[0],v[1]-1))
count = 0
for i in range(n):
for e in range(m):
if dist[i][e] <= x and e-(c-1)+dist[i][e] <= y:
count+=1
print(count)
```
| 94,418 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
Tags: graphs, shortest paths
Correct Solution:
```
import queue
import collections
n, m = list(map(int, input().split()))
x, y = list(map(int, input().split()))
l, r = list(map(int, input().split()))
maze = []
for _ in range(n):
maze.append(list(input()))
cost = [[float("inf")]*m for _ in range(n)]
def bfs(start_x, start_y):
cost[start_x][start_y] = 0
q = collections.deque([(start_x,start_y)])
while q:
x, y = q.popleft()
if 0 < x and maze[x-1][y] == "." and cost[x][y] < cost[x-1][y]:
q.append((x-1, y))
cost[x-1][y] = cost[x][y]
if x < n-1 and maze[x+1][y] == "." and cost[x][y] < cost[x+1][y]:
q.append((x+1, y))
cost[x + 1][y] = cost[x][y]
if l > 0 and 0 < y and maze[x][y-1] == "." and cost[x][y] < cost[x][y-1]:
q.append((x, y-1))
cost[x][y - 1] = cost[x][y]
if r > 0 and y < m - 1 and maze[x][y + 1] == "." and cost[x][y] + 1 < cost[x][y+1] and cost[x][y] < r:
q.append((x, y + 1))
cost[x][y + 1] = cost[x][y] + 1
bfs(x-1, y-1)
v = 0
for i in range(n):
for j in range(m):
if cost[i][j]+(y-1)-j <= l:
v += 1
print(v)
```
| 94,419 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
Submitted Solution:
```
from collections import deque
n,m=map(int,input().split())
r,c=map(int,input().split())
r-=1
c-=1
x,y=map(int,input().split())
grid=[]
for i in range(n):
s=input()
grid.append(s)
visited=[]
for i in range(n):
visited.append([0]*m)
visited[r][c]=1
stack=deque([(r,c,0)])
stack2=[]
ans=0
while stack or stack2:
if not stack:
for i,j,k in stack2:
stack.append((i,j,k))
stack2=[]
i,j,val=stack.popleft()
if visited[i][j]!=val+1:
continue
ans+=1
visited[i][j]=1
if i>0 and grid[i-1][j]=='.' and ((not visited[i-1][j]) or visited[i-1][j]>val+1):
stack.append((i-1,j,val))
visited[i-1][j]=val+1
if i<n-1 and grid[i+1][j]=='.' and ((not visited[i+1][j]) or visited[i+1][j]>val+1):
stack.append((i+1,j,val))
visited[i+1][j]=val+1
if j>0 and grid[i][j-1]=='.' and not(val+1>x or j-1+val+1-c>y) and ((not visited[i][j-1]) or visited[i][j-1]>val+2):
stack2.append((i,j-1,val+1))
visited[i][j-1]=val+2
if j<m-1 and grid[i][j+1]=='.' and not(val>x or j+1+val-c>y) and ((not visited[i][j+1]) or visited[i][j+1]>val+1):
stack.append((i,j+1,val))
visited[i][j+1]=val+1
print(ans)
```
Yes
| 94,420 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
Submitted Solution:
```
#!/usr/bin/env python3
import sys
from collections import deque
from math import inf
def rint():
return map(int, sys.stdin.readline().split())
#lines = stdin.readlines()
def bfs(sr, sc):
global ans
q = deque()
q.append((x, y, sr, sc))
visit[sr][sc] = 1
ans += 1
while q:
ll, rr, r, c, = q.popleft()
nadj = []
if r+1 < n and maze[r+1][c] == '.':
nadj.append([r+1, c])
if r-1 >= 0 and maze[r-1][c] == '.':
nadj.append([r-1, c])
if c+1 < m and maze[r][c+1] == '.':
nadj.append([r, c+1])
if c-1 >= 0 and maze[r][c-1] == '.':
nadj.append([r, c-1])
for adr, adc in nadj:
if visit[adr][adc] == 1:
continue
if c == adc:
visit[adr][adc] = 1
ans += 1
q.appendleft([ll, rr, adr, adc])
else:
if adc < c:
if ll-1 >= 0:
visit[adr][adc] = 1
ans += 1
q.append([ll-1, rr, adr, adc])
else:
if rr - 1 >= 0:
visit[adr][adc] = 1
ans += 1
q.append([ll, rr-1, adr, adc])
n, m = rint()
sr, sc = rint()
x, y = rint()
sr -= 1
sc -= 1
maze = []
for i in range(n):
maze.append(input())
#maze.append('.'*2000)
# v[r][c] = [l, r] left l, r
visit = [[0 for i in range(m)] for j in range(n)]
ans = 0
bfs(sr, sc)
print(ans)
```
Yes
| 94,421 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
Submitted Solution:
```
import queue
import collections
n, m = list(map(int, input().split()))
x, y = list(map(int, input().split()))
l, r = list(map(int, input().split()))
maze = []
for _ in range(n):
maze.append(list(input()))
cost = [[float("inf")]*m for _ in range(n)]
def bfs(start_x, start_y):
cost[start_x][start_y] = 0
q = collections.deque([(start_x,start_y)])
v = 1
while q:
x, y = q.popleft()
if 0 < x and maze[x-1][y] == "." and cost[x][y] < cost[x-1][y]:
q.append((x-1, y))
if cost[x-1][y] == float("inf"):
v += 1
cost[x-1][y] = cost[x][y]
if x < n-1 and maze[x+1][y] == "." and cost[x][y] < cost[x+1][y]:
q.append((x+1, y))
if cost[x+1][y] == float("inf"):
v += 1
cost[x + 1][y] = cost[x][y]
if l > 0 and 0 < y and maze[x][y-1] == "." and cost[x][y] < cost[x][y-1]:
q.append((x, y-1))
if cost[x][y-1] == float("inf"):
v += 1
cost[x][y - 1] = cost[x][y]
if r > 0 and y < m - 1 and maze[x][y + 1] == "." and cost[x][y] + 1 < cost[x][y+1] and cost[x][y] < r:
q.append((x, y + 1))
if cost[x][y+1] == float("inf"):
v += 1
cost[x][y + 1] = cost[x][y] + 1
return v
print(bfs(x-1, y-1))
```
No
| 94,422 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
Submitted Solution:
```
from collections import deque
n,m=map(int,input().split())
r,c=map(int,input().split())
r-=1
c-=1
x,y=map(int,input().split())
grid=[]
for i in range(n):
s=input()
grid.append(s)
visited=[]
for i in range(n):
visited.append([0]*m)
stack=deque([(r,c,0)])
ans=0
while stack:
i,j,val=stack.popleft()
ans+=1
visited[i][j]=1
if i>0 and grid[i-1][j]=='.' and not visited[i-1][j]:
stack.append((i-1,j,val))
visited[i-1][j]=1
if i<n-1 and grid[i+1][j]=='.' and not visited[i+1][j]:
stack.append((i+1,j,val))
visited[i+1][j]=1
if j>0 and grid[i][j-1]=='.' and not visited[i][j-1] and not(val+1>x or j-1+val+1-c>y):
stack.append((i,j-1,val+1))
visited[i][j-1]=1
if j<m-1 and grid[i][j+1]=='.' and not visited[i][j+1] and not(val>x or j+1+val-c>y):
stack.append((i,j+1,val))
visited[i][j+1]=1
print(ans)
```
No
| 94,423 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
Submitted Solution:
```
from collections import deque
n,m=map(int,input().split())
r,c=map(int,input().split())
r-=1
c-=1
x,y=map(int,input().split())
grid=[]
for i in range(n):
s=input()
grid.append(s)
visited=[]
for i in range(n):
visited.append([0]*m)
stack=deque([(r,c,0)])
ans=0
while stack:
i,j,val=stack.popleft()
if val>x or j+val-c>y:
continue
ans+=1
visited[i][j]=1
if i>0 and grid[i-1][j]=='.' and not visited[i-1][j]:
stack.append((i-1,j,val))
visited[i-1][j]=1
if i<n-1 and grid[i+1][j]=='.' and not visited[i+1][j]:
stack.append((i+1,j,val))
visited[i+1][j]=1
if j>0 and grid[i][j-1]=='.' and not visited[i][j-1]:
stack.append((i,j-1,val+1))
visited[i][j-1]=1
if j<m-1 and grid[i][j+1]=='.' and not visited[i][j+1]:
stack.append((i,j+1,val))
visited[i][j+1]=1
print(ans)
```
No
| 94,424 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
Submitted Solution:
```
n, m = list(map(int, input().split()))
x, y = list(map(int, input().split()))
l, r = list(map(int, input().split()))
maze = []
for _ in range(n):
maze.append(list(input()))
available = set()
def dfs(x, y, l_left, r_left, visited):
if (x,y) in visited:
return
print(x,y, l_left, r_left)
if 0 <= x < n and 0 <= y < m:
visited.add((x,y))
available.add((x, y))
if l_left > 0:
if 0 < y:
if maze[x][y-1] == ".":
dfs(x, y-1, l_left-1, r_left, visited)
if r_left > 0:
if y < m-1:
if maze[x][y+1] == ".":
dfs(x, y+1, l_left, r_left-1, visited)
if 0 < x:
if maze[x-1][y] == ".":
dfs(x-1, y, l_left, r_left, visited)
if x < n-1:
if maze[x+1][y] == ".":
dfs(x+1, y, l_left, r_left, visited)
dfs(x-1, y-1, l, r, set())
print(len(available))
```
No
| 94,425 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Tags: constructive algorithms, implementation, trees
Correct Solution:
```
n, s = map(int, input().split())
gr = {i: [] for i in range(1, n + 1)}
for _ in range(n - 1):
a, b = map(int, input().split())
gr[a].append(b)
gr[b].append(a)
ans = 2 * s / sum([1 if len(gr[i]) == 1 else 0 for i in range(1, n + 1)])
print(ans)
```
| 94,426 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Tags: constructive algorithms, implementation, trees
Correct Solution:
```
n,s = map(int,input().split())
c = [[] for i in range(n)]
for i in range(n - 1):
a, b = map(int,input().split())
c[a-1].append(b)
c[b-1].append(a)
d = set()
k = 0
for i in range(n):
if len(c[i]) == 1:
d.add(i)
if not (c[i][0] - 1) in d:
k += 1
if n == 2:
print(s)
else:
print(round(s * 2 / k,7))
```
| 94,427 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Tags: constructive algorithms, implementation, trees
Correct Solution:
```
from collections import Counter
cnt = Counter()
n, s = map(int, input().split())
for _ in range(n-1):
cnt.update(map(int, input().split()))
#print(cnt)
k = sum(cnt[i] == 1 for i in cnt)
print(2*s/k)
```
| 94,428 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Tags: constructive algorithms, implementation, trees
Correct Solution:
```
n,s=map(int, input().split())
g=[[] for i in range(n+1)]
ind=[0]*n
for i in range(n-1):
u,v=map(int, input().split())
ind[u-1]+=1
ind[v-1]+=1
#g[u-1].append(v-1)
#g[v-1].append(u-1)
ans=0
for i in range(n):
if ind[i]==1:
ans+=1
print(f"{(2*s/ans):.10f}")
```
| 94,429 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Tags: constructive algorithms, implementation, trees
Correct Solution:
```
# list(map(int, input().split()))
# map(int, input().split())
n, s = map(int, input().split())
g = [[] for i in range(n)]
for i in range(n - 1):
a, b = map(int, input().split())
a -= 1
b -= 1
g[a].append(b)
g[b].append(a)
cnt = 0
for i in range(n):
if len(g[i]) == 1:
cnt += 1
print(2 * s / cnt)
```
| 94,430 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Tags: constructive algorithms, implementation, trees
Correct Solution:
```
n,s = [int(i) for i in input().split()]
lst = [0 for i in range(n)]
for i in range(n-1):
x,y = [int(i) for i in input().split()]
lst[x-1]+=1
lst[y-1]+=1
count = 0
for i in lst:
if i == 1:
count+=1
print(2*s/count)
```
| 94,431 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Tags: constructive algorithms, implementation, trees
Correct Solution:
```
n, s = map(int, input().split())
d = {}
for i in range(n - 1):
vertex = list(map(int, input().split()))
d[vertex[0]] = d.get(vertex[0], 0) + 1
d[vertex[1]] = d.get(vertex[1], 0) + 1
c = 0
for i in d:
if d[i] == 1: c += 1
print(2 * s / c)
```
| 94,432 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Tags: constructive algorithms, implementation, trees
Correct Solution:
```
n, s = map(int, input().split())
dict = {}
for i in range(n - 1):
temp = list(map(int, input().split()))
dict[temp[0]] = dict.get(temp[0], 0) + 1
dict[temp[1]] = dict.get(temp[1], 0) + 1
k = 0
for i in dict:
if dict[i] == 1:
k = k + 1
res = 2 * s / k
print(res)
```
| 94,433 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Submitted Solution:
```
n, k = list(map(int,input().split()))
arr = []
for i in range(n):
arr.append([])
for i in range(n-1):
a,b = list(map(int,input().split()))
a-=1
b-=1
arr[a].append(b)
arr[b].append(a)
c = 0
for i in range(n):
if len(arr[i]) == 1:
c+=1
print((2*k)/c)
```
Yes
| 94,434 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Submitted Solution:
```
n, s = map(int, input().split())
g = [0 for i in range(n)]
for i in range(n - 1):
a, b = map(int, input().split())
g[a - 1] += 1
g[b - 1] += 1
print((s * 2) / g.count(1))
```
Yes
| 94,435 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Submitted Solution:
```
def ii():
return int(input())
def mi():
return map(int, input().split())
def li():
return list(mi())
# B. Minimum Diameter Tree
from collections import Counter
n, s = mi()
d = Counter()
for i in range(n - 1):
u, v = mi()
d[u] += 1
d[v] += 1
l = sum(v == 1 for v in d.values())
ans = s / l * 2
print('%.10f' % (ans,))
```
Yes
| 94,436 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Submitted Solution:
```
n,s=map(int,input().split())
a=[0]*(n+1)
if n==2:
print(s)
exit(0)
for _ in range(n-1):
u,v=map(int,input().split())
a[u]+=1
a[v]+=1
print(2.0*s/a.count(1))
```
Yes
| 94,437 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Submitted Solution:
```
n, s = map(int, input().split())
d = {}
max_vert = 1
for i in range(n - 1):
vertex = list(map(int, input().split()))
d[vertex[0]] = d.get(vertex[0], 0) + 1
d[vertex[1]] = d.get(vertex[1], 0) + 1
cnt = 0
for i in d:
if d[i] == 1:
cnt += 1
m = max(d.values())
c = 0
for i in d:
if d[i] == m:
c += 1
if c == 1:
print(2 * (s / m))
else:
print(s / ((m - 1) * c))
```
No
| 94,438 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Submitted Solution:
```
n, s = map(int, input().split())
d = {}
max_vert = 1
for i in range(n - 1):
vertex = list(map(int, input().split()))
d[vertex[0]] = d.get(vertex[0], 0) + 1
d[vertex[1]] = d.get(vertex[1], 0) + 1
cnt = 0
for i in d:
if d[i] == 1:
cnt += 1
m = max(d.values())
c = 0
for i in d:
if d[i] == m:
c += 1
if c == 1:
print(2 * (s / m))
else:
print(2 * (s / ((m - 1) * c)))
```
No
| 94,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Submitted Solution:
```
n,s = map(int,input().split())
c = [[] for i in range(n)]
for i in range(n - 1):
a, b = map(int,input().split())
c[a-1].append(b)
c[b-1].append(a)
d = set()
k = 0
for i in range(n):
if len(c[i]) == 1:
d.add(i)
if not (c[i][0] - 1) in d:
k += 1
print(round(s * 2 / k,10))
```
No
| 94,440 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a tree (an undirected connected graph without cycles) and an integer s.
Vanya wants to put weights on all edges of the tree so that all weights are non-negative real numbers and their sum is s. At the same time, he wants to make the diameter of the tree as small as possible.
Let's define the diameter of a weighed tree as the maximum sum of the weights of the edges lying on the path between two some vertices of the tree. In other words, the diameter of a weighed tree is the length of the longest simple path in the tree, where length of a path is equal to the sum of weights over all edges in the path.
Find the minimum possible diameter that Vanya can get.
Input
The first line contains two integer numbers n and s (2 ≤ n ≤ 10^5, 1 ≤ s ≤ 10^9) — the number of vertices in the tree and the sum of edge weights.
Each of the following n−1 lines contains two space-separated integer numbers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the indexes of vertices connected by an edge. The edges are undirected.
It is guaranteed that the given edges form a tree.
Output
Print the minimum diameter of the tree that Vanya can get by placing some non-negative real weights on its edges with the sum equal to s.
Your answer will be considered correct if its absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac {|a-b|} {max(1, b)} ≤ 10^{-6}.
Examples
Input
4 3
1 2
1 3
1 4
Output
2.000000000000000000
Input
6 1
2 1
2 3
2 5
5 4
5 6
Output
0.500000000000000000
Input
5 5
1 2
2 3
3 4
3 5
Output
3.333333333333333333
Note
In the first example it is necessary to put weights like this:
<image>
It is easy to see that the diameter of this tree is 2. It can be proved that it is the minimum possible diameter.
In the second example it is necessary to put weights like this:
<image>
Submitted Solution:
```
a, s = list(map(int, input().split()))
graph = [[] for _ in range(a)]
for _ in range(a - 1):
x, y = list(map(int, input().split()))
graph[x-1].append(y-1)
graph[y-1].append(x-1)
k = 0
for i in graph:
if len(i) == 1:
k += 1
print(k)
print((s*2) / k)
```
No
| 94,441 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Tags: data structures, implementation
Correct Solution:
```
import sys
from heapq import heappush , heappop , heapify
def get_array(): return list(map(int, sys.stdin.readline().split()))
def get_ints(): return map(int, sys.stdin.readline().split())
def input(): return sys.stdin.readline().strip('\n')
n , k = get_ints()
khana = get_array()
rate = get_array()
paisa = [ [j,i] for i , j in enumerate(rate) ]
paisa.sort()
i = 0
for _ in range(k):
thali , plate = get_ints()
thali-=1
if khana[thali] >=plate:
print(rate[thali]*plate)
khana[thali] -= plate
else:
#print('thali to kam hai')
kharcha = khana[thali]*rate[thali]
plate -= khana[thali]
khana[thali] = 0
#print(khana)
while i < n:
rupaya , jagah = paisa[i][0] , paisa[i][1]
if khana[jagah] >= plate:
kharcha += rate[jagah]*plate
khana[jagah] -= plate
plate = 0
break
else:
kharcha += rate[jagah]*khana[jagah]
plate -= khana[jagah]
khana[jagah] = 0
i+=1
if plate == 0:
print(kharcha)
else:
print(0)
#is this brute force hai?
#priority queue ka koi idea?
```
| 94,442 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Tags: data structures, implementation
Correct Solution:
```
import sys
from collections import deque
input_ = lambda: sys.stdin.readline().strip("\r\n")
ii = lambda : int(input_())
il = lambda : list(map(int, input_().split()))
ilf = lambda : list(map(float, input().split()))
ip = lambda : input()
fi = lambda : float(input())
li = lambda : list(input())
pr = lambda x : print(x)
n,m = il()
a = il()
c = il()
z = [[c[i],i] for i in range (n)]
z.sort()
z = deque(z)
for _ in range(m) :
x,y = il()
ans = 0
x -=1
t = min(y,a[x])
a[x] -= t
ans += t*c[x]
y -= t
while y > 0 and z :
f = z[0]
t = min(a[f[1]],y)
a[f[1]] -= t
y -= t
ans += f[0]*t
if a[f[1]] == 0 :
z.popleft()
if y == 0 :
print(ans)
else :
print(0)
```
| 94,443 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Tags: data structures, implementation
Correct Solution:
```
n,m=map(int,input().split())
aa=list(map(int,input().split()))
c=list(map(int,input().split()))
a=[(j,i) for i,j in enumerate(c)]
a.sort();
ans=[];su=0
for _ in range(m):
cost=0
i,j=map(int,input().split())
if j>aa[i-1]:cost+=aa[i-1]*c[i-1];j-=aa[i-1];aa[i-1]=0
else:cost+=j*c[i-1];aa[i-1]-=j;j=0
ii=su
#print(_,cost,j)
while j>0 and ii<n:
z,k=a[ii]
if aa[k]<=0:ii+=1;su=ii;continue
if j>aa[k]:cost+=aa[k]*c[k];j-=aa[k];aa[k]=0
else:cost+=j*c[k];aa[k]-=j;j=0
ii+=1
#print(_,k,aa[k],j)
if ii==n and j!=0:cost=0
#print(_,ii,i,cost)
ans.append(cost)
print(*ans,sep='\n')
```
| 94,444 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Tags: data structures, implementation
Correct Solution:
```
n, m = map(int, input().split())
a = [int(x) for x in input().split()]
c = [int(x) for x in input().split()]
costs = sorted([(i, cost) for i, cost in enumerate(c)],key=lambda x: (x[1], x[0]))
co = 0
for i in range(m):
t, d = map(int, input().split())
t -= 1
price = 0
if a[t] > d:
price = d*c[t]
a[t] -= d
else:
price = a[t]*c[t]
d -= a[t]
a[t] = 0
while d > 0 and co < n:
ai, cost = costs[co]
if a[ai] > d:
price += d*cost
a[ai] -= d
d = 0
else:
price += a[ai]*cost
d -= a[ai]
a[ai] = 0
co += 1
if d > 0:
price = 0
print(price)
```
| 94,445 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Tags: data structures, implementation
Correct Solution:
```
n,m=map(int,input().split())
a=list(map(int,input().split()))
c=list(map(int,input().split()))
p=[]
for i in range(n):
p.append([i,c[i]])
p=sorted(p,key=lambda item:item[1])
zer0=0
for i in range(m):
# ans=
#ans
t,d=map(int,input().split())
t-=1
if a[t]>=d:
print(c[t]*d)
a[t]-=d
continue
else:
ans=0
# ii=zer0
req=d
req-=a[t]
ans+=(c[t]*a[t])
a[t]=0
if req>0:
for j in range(zer0,n):
y=min(req,a[p[j][0]])
ans+=(p[j][1]*y)
a[p[j][0]]-=y
req-=y
if a[p[j][0]]==0:
zer0+=1
if req==0:
break
# print(req,ans)
if req!=0:
print(0)
continue
else:
print(ans)
```
| 94,446 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Tags: data structures, implementation
Correct Solution:
```
n,m=map(int,input().split())
a=list(map(int,input().split()))
c=list(map(int,input().split()))
p=[]
for i in range(n):
p.append([i,c[i]])
p=sorted(p,key=lambda item:item[1])
zer0=0
for i in range(m):
# ans=
t,d=map(int,input().split())
t-=1
if a[t]>=d:
print(c[t]*d)
a[t]-=d
continue
else:
ans=0
# ii=zer0
req=d
req-=a[t]
ans+=(c[t]*a[t])
a[t]=0
if req>0:
for j in range(zer0,n):
y=min(req,a[p[j][0]])
ans+=(p[j][1]*y)
a[p[j][0]]-=y
req-=y
if a[p[j][0]]==0:
zer0+=1
if req==0:
break
# print(req,ans)
if req!=0:
print(0)
continue
else:
print(ans)
```
| 94,447 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Tags: data structures, implementation
Correct Solution:
```
n, m = map(int, input().split())
dish = list(map(int, input().split()))
cost = list(map(int, input().split()))
scost = []
for i in range(n):
scost.append([cost[i], dish[i], i])
scost = sorted(scost)
cur = 0
for i in range(m):
x, y = map(int, input().split())
x -= 1
price = 0
if dish[x] >= y:
price += cost[x] * y
dish[x] -= y
y = 0
else:
price += cost[x] * dish[x]
y -= dish[x]
dish[x] = 0
while y > 0:
try:
tmp = scost[cur][-1]
if dish[tmp] >= y:
price += cost[tmp] * y
dish[tmp] -= y
y = 0
else:
price += cost[tmp] * dish[tmp]
y -= dish[tmp]
dish[tmp] = 0
cur += 1
except IndexError:
price = 0
y = 0
print(price)
```
| 94,448 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Tags: data structures, implementation
Correct Solution:
```
from heapq import*
R=lambda:[*map(int,input().split())]
n,m=R()
a,c=R(),R()
b=[*zip(c,range(n))]
heapify(b)
for _ in[0]*m:
t,d=R();t-=1;r=0
e=min(a[t],d);a[t]-=e;d-=e;r+=c[t]*e
while d and b:
x,t=b[0]
e=min(a[t],d);a[t]-=e;d-=e;r+=x*e
if a[t]==0:heappop(b)
print((0,r)[d==0])
```
| 94,449 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Submitted Solution:
```
R=lambda:[*map(int,input().split())]
n,m=R()
a,c=R(),R()
def f():global r,d;e=min(a[t],d);a[t]-=e;d-=e;r+=x*e
b=sorted(zip(c,range(n)))
i=0
for _ in[0]*m:
t,d=R();t-=1;r=0;x=c[t];f()
while d and i<n:x,t=b[i];f();i+=a[t]==0
print((r,0)[d>0])
```
Yes
| 94,450 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Submitted Solution:
```
def main():
n,m = map(int,input().split())
remain = list(map(int,input().split()))
cost = list(map(int,input().split()))
stack = []
for i in range(n):
stack.append((cost[i],i))
stack.sort()
stack.reverse()
for i in range(m):
t,d = map(int,input().split())
cst = 0
if remain[t-1] >= d:
remain[t-1] -= d
cst += d*cost[t-1]
else:
r = d - remain[t-1]
cst += remain[t-1]*cost[t-1]
remain[t-1] = 0
while r != 0:
if not stack:
cst = 0
break
c = stack.pop()
if remain[c[1]] >= r:
cst += r*cost[c[1]]
remain[c[1]] -= r
r = 0
if remain[c[1]] > 0:
stack.append(c)
else:
r -= remain[c[1]]
cst += remain[c[1]]*cost[c[1]]
remain[c[1]] = 0
print (cst)
main()
```
Yes
| 94,451 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
from collections import defaultdict, deque, Counter, OrderedDict
import threading
from heapq import *
def main():
n,m=map(int,input().split())
a = [*map(int,input().split())]
c = [*map(int,input().split())]
D = []
for i in range(n):
D.append([c[i],i])
D.sort(key = lambda z: z[0])
q = deque(D)
for i in range(m):
ans = 0
t, d = map(int,input().split()); t-=1
if a[t] > d:
ans = d * c[t]
a[t] -= d
d = 0
else:
ans = a[t] * c[t]
d -= a[t]
a[t] = 0
while q:
if a[q[0][1]] >= d:
ans += c[q[0][1]] * d
a[q[0][1]]-=d
d = 0
if a[q[0][1]] == 0: q.popleft()
break
else:
ans += c[q[0][1]] * a[q[0][1]]
d -= a[q[0][1]]
a[q[0][1]] = 0
q.popleft()
if d > 0: print(0)
else:print(ans)
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
if __name__ == "__main__":
"""sys.setrecursionlimit(400000)
threading.stack_size(40960000)
thread = threading.Thread(target=main)
thread.start()"""
main()
```
Yes
| 94,452 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Submitted Solution:
```
n , m = map( int , input().split() )
a = [int(x) for x in input().split()]
c = [int(x) for x in input().split()]
s = [(i,c[i]) for i in range(n)]
s = sorted(s , key = lambda x:(x[1],x[0]))
cheapest = 0
for _ in range(m):
cost = 0
t , d = map(int , input().split())
minimo = min(a[t-1],d)
cost+= minimo*c[t-1]
a[t-1]-=minimo
d-=minimo
while(d>0 and cheapest < n): #O salí, o agote productos
i_min = s[cheapest][0]
cost_min = s[cheapest][1]
minimo = min(a[i_min] , d)
a[i_min]-= minimo
cost+= cost_min*minimo
d-= minimo
if(a[i_min]==0):
cheapest+=1
if(d == 0):
print(cost)
else:
print(0)
```
Yes
| 94,453 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Submitted Solution:
```
import sys
import math
def read_int():
return int(input().strip())
def read_int_list():
return list(map(int,input().strip().split()))
def read_string():
return input().strip()
def read_string_list(delim=" "):
return input().strip().split(delim)
###### Author : Samir Vyas #######
###### Write Code Below #######
import heapq
n,k = read_int_list()
remains = read_int_list()
costs = read_int_list()
total = sum(remains)
#heap has [cost,index]
heap = []
for i in range(n):
heap.append([costs[i],i])
heapq.heapify(heap)
for i in range(k):
index, demanded_quant = read_int_list()
index -= 1
cost = 0
#if total is 0 then cannot do anythin
if total <= 0:
print(0)
continue
#give available
available_quant = min(remains[index], demanded_quant)
cost += costs[index]*available_quant
demanded_quant -= available_quant
remains[index] -= available_quant
total -= available_quant
#give as many cheapest as you can
while demanded_quant > 0 and len(heap) > 0:
index = heapq.heappop(heap)[1]
#if item is not remaining
if remains[index] <= 0:
continue
#if anything is remaining
available_quant = min(remains[index], demanded_quant)
cost += costs[index]*available_quant
demanded_quant -= available_quant
remains[index] -= available_quant
total -= available_quant
#push new entry to heap
if remains[index] > 0:
heapq.heappush(heap, [costs[index],index])
#if heap is empty then custommer won't pay
if len(heap) == 0:
print(0)
else:
print(cost)
```
No
| 94,454 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Submitted Solution:
```
def get_i(l):
m=10000000000000
index=0
for i in range(len(l)):
if l[i]<m and l[i]!=0:
m=l[i]
index=i
return index
n,m=map(int,input().split())
a=list(map(int,input().split()))
c=list(map(int,input().split()))
s=sum(a)
for i in range(m):
total=0
t,d=map(int,input().split())
t-=1
while d!=0 and s!=0:
if s-a[t]>=0:
if a[t]-d>0:
a[t]-=d
s-=d
total+=d*c[t]
break
elif a[t]>0:
s-=a[t]
d-=a[t]
total+=a[t]*c[t]
c[t]=0
a[t]=0
t=get_i(c)
else:
t=get_i(c)
else:
total=0
break
print(total)
```
No
| 94,455 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Submitted Solution:
```
from bisect import*
R=lambda:[*map(int,input().split())]
n,m=R()
a,c=R(),R()
b=sorted(zip(c,range(n)))
for _ in[0]*m:
t,d=R();t-=1;r=0
if a[t]:e=min(a[t],d);a[t]-=e;d-=e;r+=c[t]*e;i=0
for x,j in b:
e=min(a[j],d);a[j]-=e;d-=e;r+=x*e
if d==0:break
i+=1
b[:i]=[]
print((0,r)[d==0])
```
No
| 94,456 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Lunar New Year is approaching, and Bob is planning to go for a famous restaurant — "Alice's".
The restaurant "Alice's" serves n kinds of food. The cost for the i-th kind is always c_i. Initially, the restaurant has enough ingredients for serving exactly a_i dishes of the i-th kind. In the New Year's Eve, m customers will visit Alice's one after another and the j-th customer will order d_j dishes of the t_j-th kind of food. The (i + 1)-st customer will only come after the i-th customer is completely served.
Suppose there are r_i dishes of the i-th kind remaining (initially r_i = a_i). When a customer orders 1 dish of the i-th kind, the following principles will be processed.
1. If r_i > 0, the customer will be served exactly 1 dish of the i-th kind. The cost for the dish is c_i. Meanwhile, r_i will be reduced by 1.
2. Otherwise, the customer will be served 1 dish of the cheapest available kind of food if there are any. If there are multiple cheapest kinds of food, the one with the smallest index among the cheapest will be served. The cost will be the cost for the dish served and the remain for the corresponding dish will be reduced by 1.
3. If there are no more dishes at all, the customer will leave angrily. Therefore, no matter how many dishes are served previously, the cost for the customer is 0.
If the customer doesn't leave after the d_j dishes are served, the cost for the customer will be the sum of the cost for these d_j dishes.
Please determine the total cost for each of the m customers.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 10^5), representing the number of different kinds of food and the number of customers, respectively.
The second line contains n positive integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7), where a_i denotes the initial remain of the i-th kind of dishes.
The third line contains n positive integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 10^6), where c_i denotes the cost of one dish of the i-th kind.
The following m lines describe the orders of the m customers respectively. The j-th line contains two positive integers t_j and d_j (1 ≤ t_j ≤ n, 1 ≤ d_j ≤ 10^7), representing the kind of food and the number of dishes the j-th customer orders, respectively.
Output
Print m lines. In the j-th line print the cost for the j-th customer.
Examples
Input
8 5
8 6 2 1 4 5 7 5
6 3 3 2 6 2 3 2
2 8
1 4
4 7
3 4
6 10
Output
22
24
14
10
39
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 6
3 6
4 6
5 6
6 66
Output
36
396
3996
39996
399996
0
Input
6 6
6 6 6 6 6 6
6 66 666 6666 66666 666666
1 6
2 13
3 6
4 11
5 6
6 6
Output
36
11058
99996
4333326
0
0
Note
In the first sample, 5 customers will be served as follows.
1. Customer 1 will be served 6 dishes of the 2-nd kind, 1 dish of the 4-th kind, and 1 dish of the 6-th kind. The cost is 6 ⋅ 3 + 1 ⋅ 2 + 1 ⋅ 2 = 22. The remain of the 8 kinds of food will be \{8, 0, 2, 0, 4, 4, 7, 5\}.
2. Customer 2 will be served 4 dishes of the 1-st kind. The cost is 4 ⋅ 6 = 24. The remain will be \{4, 0, 2, 0, 4, 4, 7, 5\}.
3. Customer 3 will be served 4 dishes of the 6-th kind, 3 dishes of the 8-th kind. The cost is 4 ⋅ 2 + 3 ⋅ 2 = 14. The remain will be \{4, 0, 2, 0, 4, 0, 7, 2\}.
4. Customer 4 will be served 2 dishes of the 3-rd kind, 2 dishes of the 8-th kind. The cost is 2 ⋅ 3 + 2 ⋅ 2 = 10. The remain will be \{4, 0, 0, 0, 4, 0, 7, 0\}.
5. Customer 5 will be served 7 dishes of the 7-th kind, 3 dishes of the 1-st kind. The cost is 7 ⋅ 3 + 3 ⋅ 6 = 39. The remain will be \{1, 0, 0, 0, 4, 0, 0, 0\}.
In the second sample, each customer is served what they order except the last one, who leaves angrily without paying. For example, the second customer is served 6 dishes of the second kind, so the cost is 66 ⋅ 6 = 396.
In the third sample, some customers may not be served what they order. For example, the second customer is served 6 dishes of the second kind, 6 of the third and 1 of the fourth, so the cost is 66 ⋅ 6 + 666 ⋅ 6 + 6666 ⋅ 1 = 11058.
Submitted Solution:
```
n, m = map(int,input().split(' '))
kol = list(map(int,input().split(' ')))
prices = list(map(int,input().split(' ')))
for i in range(m):
tip, koli = map(int,input().split(' '))
chek = 0
while koli != 0:
if kol[tip-1] > 0:
kol[tip-1] -=1
chek += prices[tip-1]
elif sum(kol)>0:
pm = 0
for j in range(1,n):
if (kol[j] > 0) and (prices[j]<prices[pm]):
pm = j
chek += prices[pm]
kol[pm] -=1
else:
chek = 0
break
koli -= 1
print(chek)
```
No
| 94,457 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Tags: sortings, two pointers
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
a.sort()
l=r=0;ans=0
for i in range(n):
while l<r and a[r]-a[l]>5:
l+=1
ans=max(ans,r-l+1)
r+=1
print(ans)
```
| 94,458 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Tags: sortings, two pointers
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
m=1
a.sort()
cur=1
d=0
l=1
for i in range(1,n):
d+=a[i]-a[i-1]
if d<=5:
cur+=1
m=max(m,cur)
else:
while d>5:
d-=a[l]-a[l-1]
l+=1
cur-=1
if d<=5:
cur+=1
m=max(m,cur)
print(m)
```
| 94,459 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Tags: sortings, two pointers
Correct Solution:
```
from bisect import bisect_right
n = int(input())
A = sorted(list(map(int, input().split())))
mx = 0
for i in range(n):
th = A[i] + 5
idx = bisect_right(A, th)
mx = max(mx, idx - i)
print(mx)
```
| 94,460 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Tags: sortings, two pointers
Correct Solution:
```
n = int(input())
a = input().split(" ")
a = [int(i) for i in a]
l=0
r=0
ans=1
a.sort()
# print(a)
while(l<=r and r<n):
if((a[r]-a[l])<=5):
ans = max(ans,(r-l+1))
r+=1
elif(l == r-1):
r+=1
else:
l+=1
# print(l,r)
print(ans)
```
| 94,461 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Tags: sortings, two pointers
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
l=0
r=1
br=0
brm=1
a.sort()
while(r<n):
if(a[r]-a[l]<=5):
r=r+1
br=r-l
else:
l=l+1
if(l==r):
r=r+1
brm=max(brm,br)
print(brm)
```
| 94,462 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Tags: sortings, two pointers
Correct Solution:
```
import sys
n = int(sys.stdin.readline().strip())
a = list(map(int, sys.stdin.readline().strip().split()))
a.sort()
i = 0
j = 0
d = 1
while j < n - 1:
if a[j + 1] <= a[i] + 5:
j = j + 1
d = max([d, j - i + 1])
else:
i = i + 1
print(d)
```
| 94,463 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Tags: sortings, two pointers
Correct Solution:
```
import sys
import math
from functools import reduce
import bisect
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def input():
return sys.stdin.readline().rstrip()
def index(a, x, pos):
i = bisect.bisect(a, x) - 1
if i == len(a) or i == 0:
return -1
return i - pos + 1
#############
# MAIN CODE #
#############
n = getN()
arr = sorted(getList())
ans = 1
for i in range(n):
ans = max(ans, index(arr, arr[i] + 5, i))
print(ans)
```
| 94,464 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Tags: sortings, two pointers
Correct Solution:
```
n = int(input())
a = [int(j) for j in input().split()]
a.sort()
# arr = [a[0]]
ans = []
ma = 1
y = 0
if n == 1:
print(1)
else:
# print(a)
for x in range(1, len(a)):
# print(a[x], a[y])
while a[x]-a[y] > 5:
# print('t')
y += 1
ans += [x-y+1]
# print(ans)
print(max(ans))
```
| 94,465 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Submitted Solution:
```
n = int(input())
A = list(map(int,input().split()))
A.sort()
ans=0;j=0
for i in range(n):
while(A[j]+5<A[i]):
j+=1
ans = max(ans,i-j+1)
print(ans)
```
Yes
| 94,466 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Submitted Solution:
```
n=int(input())
a=list(map(int, input().split()))
a.sort()
l=0
ans=0
for r in range(n):
while not a[r]-a[l]<=5:
l+=1
ans=max(ans, r-l+1)
print(ans)
```
Yes
| 94,467 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Submitted Solution:
```
c=dict()
def cou(x):
ans=0
for i in range(x,x+6):
if i in c:
ans+=c[i]
return ans
n=int(input())
a=[int(i) for i in input().split()]
b=set(a)
for i in a:
if i in c:
c[i]+=1
else:
c[i]=1
#for i in b:
# c[i]=a.count(i)
#a.sort()
m=0
for i in b:
y=cou(i)
if y>m:
m=y
#ii=i
print(m)#,ii)
```
Yes
| 94,468 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Submitted Solution:
```
import sys
from collections import Counter
def i_ints():
return map(int, sys.stdin.readline().split())
n, k = i_ints()
c = Counter(i_ints())
c2 = dict()
a = sorted(c)
for i in sorted(a):
c2[i] = sum(c[j] for j in range(i, i + 6))
# a are all possible levels of students
# c2[i] is maximal group size where lowest level is i
len_a = len(a)
next_group = [-1] * len(a)
for i in range(len_a):
for j in range(i + 1, len_a):
if a[j] > a[i] + 5:
next_group[i] = j
break
# if a group starts with i-th element,
# then the next possible group starts with next_group[i]-th element
maxes = [0] * n # for a maximum of 0 groups
for ii in range(k):
old_maxes = maxes
old_maxes.append(0) # access where next_group[...] == -1
maxes = []
# max number of groups, try to find better maxes each round
for i, aa in enumerate(a):
maxes.append(c2[a[i]] + old_maxes[next_group[i]])
m = 0
for i in range(len(a)-1, -1, -1):
if maxes[i] > m:
m = maxes[i]
else:
maxes[i] = m
print(max(maxes))
```
Yes
| 94,469 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Submitted Solution:
```
n = int(input())
A = list(map(int, input().strip().split()))
count = {}
A = sorted(A)
for a in A:
count[a] = 0
for i in range(len(A)):
count[A[i]] += 1
for j in range(i+1, i+6):
try:
if A[j] - A[i] <=5 and A[j]!= A[i]:
count[A[i]] += 1
except:
abc = 123
print(max(count.values()))
```
No
| 94,470 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Submitted Solution:
```
n, k = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
s = []
slen = 0
l = 0
for i in range(0, n):
if a[i] - a[l] <= 5:
slen += 1
else:
s.append(slen)
slen = 1
l = i
s.append(slen)
s = sorted(s, reverse=True)
ans = 0
for i in range(min(k, len(s))):
ans += s[i]
print (ans)
```
No
| 94,471 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Submitted Solution:
```
#
# tag(s):
def getMaxNumMembers(n, team):
team = sorted(team)
a = 0
b = 0
ans = 1
cont = 1
while b < (n-1):
if abs(team[b] - team[b+1]) <= 5:
if abs(team[b+1] - team[a]) <= 5:
cont += 1
if cont > ans:
ans = cont
b += 1
else:
cont = 1
a = b
b = b + 1
else:
cont = 1
a = b
b = b + 1
return ans
if __name__ == '__main__':
n = int(input())
team = map(int, input().split())
print(getMaxNumMembers(n, team))
```
No
| 94,472 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are a coach at your local university. There are n students under your supervision, the programming skill of the i-th student is a_i.
You have to create a team for a new programming competition. As you know, the more students some team has the more probable its victory is! So you have to create a team with the maximum number of students. But you also know that a team should be balanced. It means that the programming skill of each pair of students in a created team should differ by no more than 5.
Your task is to report the maximum possible number of students in a balanced team.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of students.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is a programming skill of the i-th student.
Output
Print one integer — the maximum possible number of students in a balanced team.
Examples
Input
6
1 10 17 12 15 2
Output
3
Input
10
1337 1337 1337 1337 1337 1337 1337 1337 1337 1337
Output
10
Input
6
1 1000 10000 10 100 1000000000
Output
1
Note
In the first example you can create a team with skills [12, 17, 15].
In the second example you can take all students in a team because their programming skills are equal.
In the third example you can create a team consisting of a single student (and you cannot create a team consisting of at least two students).
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
#l.sort()
count1=1
count=1
for i in range(0,n-1):
if abs(l[i+1]-l[i])<=5:
count+=1
if count1<count:
count1=count
else:
count=1
print(count1)
```
No
| 94,473 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n intervals in form [l; r] on a number line.
You are also given m queries in form [x; y]. What is the minimal number of intervals you have to take so that every point (not necessarily integer) from x to y is covered by at least one of them?
If you can't choose intervals so that every point from x to y is covered, then print -1 for that query.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of intervals and the number of queries, respectively.
Each of the next n lines contains two integer numbers l_i and r_i (0 ≤ l_i < r_i ≤ 5 ⋅ 10^5) — the given intervals.
Each of the next m lines contains two integer numbers x_i and y_i (0 ≤ x_i < y_i ≤ 5 ⋅ 10^5) — the queries.
Output
Print m integer numbers. The i-th number should be the answer to the i-th query: either the minimal number of intervals you have to take so that every point (not necessarily integer) from x_i to y_i is covered by at least one of them or -1 if you can't choose intervals so that every point from x_i to y_i is covered.
Examples
Input
2 3
1 3
2 4
1 3
1 4
3 4
Output
1
2
1
Input
3 4
1 3
1 3
4 5
1 2
1 3
1 4
1 5
Output
1
1
-1
-1
Note
In the first example there are three queries:
1. query [1; 3] can be covered by interval [1; 3];
2. query [1; 4] can be covered by intervals [1; 3] and [2; 4]. There is no way to cover [1; 4] by a single interval;
3. query [3; 4] can be covered by interval [2; 4]. It doesn't matter that the other points are covered besides the given query.
In the second example there are four queries:
1. query [1; 2] can be covered by interval [1; 3]. Note that you can choose any of the two given intervals [1; 3];
2. query [1; 3] can be covered by interval [1; 3];
3. query [1; 4] can't be covered by any set of intervals;
4. query [1; 5] can't be covered by any set of intervals. Note that intervals [1; 3] and [4; 5] together don't cover [1; 5] because even non-integer points should be covered. Here 3.5, for example, isn't covered.
Submitted Solution:
```
import sys
input = sys.stdin.readline
n,m = map(int,input().split())
a = [tuple(map(int,input().split())) for i in range(n)]
q = [tuple(map(int,input().split())) for j in range(m)]
a.sort(key = lambda x:x[1],reverse=True)
rng = 5*10**5+1
g = [0 for i in range(rng)]
idx = 0
for i in range(1,rng)[::-1]:
while idx <= n-1 and i < a[idx][0]:
idx += 1
if idx == n:
break
if a[idx][0] <= i <= a[idx][1]:
g[i] = a[idx][1]
dbl = [g]+[[0 for i in range(rng)] for j in range(20)]
for i in range(1,21):
for j in range(rng):
dbl[i][j] = dbl[i-1][dbl[i-1][j]]
for l,r in q:
if dbl[-1][l] < r:
print(-1)
continue
ans = 0
for i in range(21)[::-1]:
if dbl[i][l] < r:
ans += 2**i
l = dbl[i][l]
print(ans+1)
```
No
| 94,474 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n intervals in form [l; r] on a number line.
You are also given m queries in form [x; y]. What is the minimal number of intervals you have to take so that every point (not necessarily integer) from x to y is covered by at least one of them?
If you can't choose intervals so that every point from x to y is covered, then print -1 for that query.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of intervals and the number of queries, respectively.
Each of the next n lines contains two integer numbers l_i and r_i (0 ≤ l_i < r_i ≤ 5 ⋅ 10^5) — the given intervals.
Each of the next m lines contains two integer numbers x_i and y_i (0 ≤ x_i < y_i ≤ 5 ⋅ 10^5) — the queries.
Output
Print m integer numbers. The i-th number should be the answer to the i-th query: either the minimal number of intervals you have to take so that every point (not necessarily integer) from x_i to y_i is covered by at least one of them or -1 if you can't choose intervals so that every point from x_i to y_i is covered.
Examples
Input
2 3
1 3
2 4
1 3
1 4
3 4
Output
1
2
1
Input
3 4
1 3
1 3
4 5
1 2
1 3
1 4
1 5
Output
1
1
-1
-1
Note
In the first example there are three queries:
1. query [1; 3] can be covered by interval [1; 3];
2. query [1; 4] can be covered by intervals [1; 3] and [2; 4]. There is no way to cover [1; 4] by a single interval;
3. query [3; 4] can be covered by interval [2; 4]. It doesn't matter that the other points are covered besides the given query.
In the second example there are four queries:
1. query [1; 2] can be covered by interval [1; 3]. Note that you can choose any of the two given intervals [1; 3];
2. query [1; 3] can be covered by interval [1; 3];
3. query [1; 4] can't be covered by any set of intervals;
4. query [1; 5] can't be covered by any set of intervals. Note that intervals [1; 3] and [4; 5] together don't cover [1; 5] because even non-integer points should be covered. Here 3.5, for example, isn't covered.
Submitted Solution:
```
import io, os
input = io.StringIO(os.read(0, os.fstat(0).st_size).decode()).readline
MX = 5 * 10 ** 5 + 5
LG = 20
n, m = map(int, input().split())
jmp = [[0] * MX for i in range(LG)]
for _ in range(n):
l, r = map(int, input().split())
jmp[0][l] = max(jmp[0][l], r)
for i in range(MX):
jmp[0][i] = max(jmp[0][i - 1], jmp[0][i])
for i in range(MX - 1, 0, -1):
for j in range(1, LG):
jmp[j][i] = jmp[j - 1][jmp[j - 1][i]]
out = []
for _ in range(m):
x, y = map(int, input().split())
ans = n + 1
if x == y:
if jmp[0][x] >= y: ans = 1
elif jmp[-1][x] >= y:
cur = 0
for j in range(LG - 1, -1, -1):
if jmp[j][x] < y:
x = jmp[j][x]
cur += 1 << j
else:
ans = min(ans, cur + (1 << j))
out.append(ans if ans <= n else -1)
print(*out, sep='\n')
```
No
| 94,475 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n intervals in form [l; r] on a number line.
You are also given m queries in form [x; y]. What is the minimal number of intervals you have to take so that every point (not necessarily integer) from x to y is covered by at least one of them?
If you can't choose intervals so that every point from x to y is covered, then print -1 for that query.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of intervals and the number of queries, respectively.
Each of the next n lines contains two integer numbers l_i and r_i (0 ≤ l_i < r_i ≤ 5 ⋅ 10^5) — the given intervals.
Each of the next m lines contains two integer numbers x_i and y_i (0 ≤ x_i < y_i ≤ 5 ⋅ 10^5) — the queries.
Output
Print m integer numbers. The i-th number should be the answer to the i-th query: either the minimal number of intervals you have to take so that every point (not necessarily integer) from x_i to y_i is covered by at least one of them or -1 if you can't choose intervals so that every point from x_i to y_i is covered.
Examples
Input
2 3
1 3
2 4
1 3
1 4
3 4
Output
1
2
1
Input
3 4
1 3
1 3
4 5
1 2
1 3
1 4
1 5
Output
1
1
-1
-1
Note
In the first example there are three queries:
1. query [1; 3] can be covered by interval [1; 3];
2. query [1; 4] can be covered by intervals [1; 3] and [2; 4]. There is no way to cover [1; 4] by a single interval;
3. query [3; 4] can be covered by interval [2; 4]. It doesn't matter that the other points are covered besides the given query.
In the second example there are four queries:
1. query [1; 2] can be covered by interval [1; 3]. Note that you can choose any of the two given intervals [1; 3];
2. query [1; 3] can be covered by interval [1; 3];
3. query [1; 4] can't be covered by any set of intervals;
4. query [1; 5] can't be covered by any set of intervals. Note that intervals [1; 3] and [4; 5] together don't cover [1; 5] because even non-integer points should be covered. Here 3.5, for example, isn't covered.
Submitted Solution:
```
import sys
input = sys.stdin.readline
from bisect import *
n,m = map(int,input().split())
a = [list(map(int,input().split())) for i in range(n)]
q = [list(map(int,input().split())) for j in range(m)]
a.sort()
an = [a[0]]
notcovered = []
if a[0][0] > 1:
for i in range(1,a[0][0]):
notcovered.append(i)
for i in range(1,n):
if a[i][1] > an[-1][1]:
if a[i][0] > an[-1][0]:
an.append(a[i])
if an[-1][0] > an[-2][1]:
if an[-1][0] == an[-2][1]+1:
notcovered.append(an[-1][0]-0.5)
else:
notcovered.extend(list(range(an[-2][1]+1,an[-1][0])))
else:
an[-1][1] = a[i][1]
if an[-1][1] < 5*10**5:
notcovered.extend(list(range(an[-1][1]+1,5*10**5+1)))
anl,anr = list(zip(*an))
for i,j in q:
if notcovered:
jdg = bisect_right(notcovered,j)-bisect_left(notcovered,i)
if jdg > 0:
print(-1)
continue
idl = bisect_right(anl,i)
idr = bisect_left(anr,j)
print(idr-idl+2)
```
No
| 94,476 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n intervals in form [l; r] on a number line.
You are also given m queries in form [x; y]. What is the minimal number of intervals you have to take so that every point (not necessarily integer) from x to y is covered by at least one of them?
If you can't choose intervals so that every point from x to y is covered, then print -1 for that query.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of intervals and the number of queries, respectively.
Each of the next n lines contains two integer numbers l_i and r_i (0 ≤ l_i < r_i ≤ 5 ⋅ 10^5) — the given intervals.
Each of the next m lines contains two integer numbers x_i and y_i (0 ≤ x_i < y_i ≤ 5 ⋅ 10^5) — the queries.
Output
Print m integer numbers. The i-th number should be the answer to the i-th query: either the minimal number of intervals you have to take so that every point (not necessarily integer) from x_i to y_i is covered by at least one of them or -1 if you can't choose intervals so that every point from x_i to y_i is covered.
Examples
Input
2 3
1 3
2 4
1 3
1 4
3 4
Output
1
2
1
Input
3 4
1 3
1 3
4 5
1 2
1 3
1 4
1 5
Output
1
1
-1
-1
Note
In the first example there are three queries:
1. query [1; 3] can be covered by interval [1; 3];
2. query [1; 4] can be covered by intervals [1; 3] and [2; 4]. There is no way to cover [1; 4] by a single interval;
3. query [3; 4] can be covered by interval [2; 4]. It doesn't matter that the other points are covered besides the given query.
In the second example there are four queries:
1. query [1; 2] can be covered by interval [1; 3]. Note that you can choose any of the two given intervals [1; 3];
2. query [1; 3] can be covered by interval [1; 3];
3. query [1; 4] can't be covered by any set of intervals;
4. query [1; 5] can't be covered by any set of intervals. Note that intervals [1; 3] and [4; 5] together don't cover [1; 5] because even non-integer points should be covered. Here 3.5, for example, isn't covered.
Submitted Solution:
```
n, m = map(int, input().split())
def overlap(i1, i2):
if i1[0] > i2[0]:
i1, i2 = i2, i1
return i2[0] <= i1[1]
def contains(i1, i2):
return i2[0] >= i1[0] and i2[1] <= i1[1]
intervals = {}
for i in range(n):
x, y = map(int, input().split())
if (x, y) in intervals:
continue
new_entries = {(x, y): 1}
for interval in intervals:
if overlap(interval, (x, y)):
old = intervals[interval]
new_entries[(min(interval[0], x), max(interval[1], y))] = old + 1
intervals.update(new_entries)
for i in range(m):
x, y = map(int, input().split())
match = None
for interval in intervals:
if contains(interval, (x, y)):
if match is None:
match = intervals[interval]
else:
match = min(match, intervals[interval])
if match is None:
print('-1')
else:
print(match)
```
No
| 94,477 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Tags: games, math
Correct Solution:
```
def solve():
[n, k] = (int(x) for x in input().split())
if k % 3 != 0:
if n % 3 == 0:
print('Bob')
else:
print('Alice')
else:
tc = k // 3
n = n % (1 + 3 * tc)
if n == 3 * tc:
print('Alice')
else:
if n % 3 == 0:
print('Bob')
else:
print('Alice')
t = int(input())
for _ in range(t):
solve()
```
| 94,478 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Tags: games, math
Correct Solution:
```
T = int(input())
for i in range(T):
n, k = list(map(int, input().split()))
if k % 3 != 0:
if n % 3 == 0:
print("Bob")
else:
print("Alice")
else:
quotient = k + 1
remainder = n % quotient
if remainder % 3 == 0 and remainder != k:
print("Bob")
else:
print("Alice")
```
| 94,479 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Tags: games, math
Correct Solution:
```
def solve(n, k):
sol = [None] * (n+1)
for i in range(n+1):
if i == 0:
sol[i] = 'B'
continue
for offset in (1, 2, k):
if i - offset >= 0 and sol[i - offset] == 'B':
sol[i] = 'A'
break
else:
sol[i] = 'B'
print(''.join(sol))
return sol[-1]
def solve2(n, k):
if k % 3 > 0:
return n % 3 != 0
d = k // 3 - 1
m = d*3 + 4 # BAA * d + BAAA
r = n % m
return r % 3 != 0 or r == m - 1
T = int(input().strip())
for _ in range(T):
n, k = list(map(int, input().strip().split()))
print("Alice" if solve2(n,k) else "Bob")
```
| 94,480 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Tags: games, math
Correct Solution:
```
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
def rl(proc=None):
if proc is not None:
return proc(sys.stdin.readline())
else:
return sys.stdin.readline().rstrip()
def srl(proc=None):
if proc is not None:
return list(map(proc, rl().split()))
else:
return rl().split()
def solve(n, k):
if k % 3:
return n % 3
n = n % (k + 1)
if n == k:
return 1
return n % 3
def main():
T = rl(int)
for t in range(1, T+1):
n, k = srl(int)
print('Alice' if solve(n, k) else 'Bob')
if __name__ == '__main__':
main()
```
| 94,481 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Tags: games, math
Correct Solution:
```
import sys
import math as mt
import bisect
input=sys.stdin.readline
t=int(input())
def issub(str1,str2):
m = len(str1)
n = len(str2)
j = 0
i = 0
while j<m and i<n:
if str1[j] == str2[i]:
j=j+1
i=i+1
return j==m
def ncr_util():
inv[0]=inv[1]=1
fact[0]=fact[1]=1
for i in range(2,300001):
inv[i]=(inv[i%p]*(p-p//i))%p
for i in range(1,300001):
inv[i]=(inv[i-1]*inv[i])%p
fact[i]=(fact[i-1]*i)%p
def solve():
s2='Bob'
s1='Alice'
if k%3!=0:
if n%3==0:
return (s2)
else:
return(s1)
else:
x=n%(k+1)
if x%3==0 and x!=k:
return (s2)
else:
return s1
for _ in range(t):
#n=int(input())
n,k=(map(int,input().split()))
#n1=n
#a=int(input())
#b=int(input())
#a,b,c,r=map(int,input().split())
#x2,y2=map(int,input().split())
#n=int(input())
#s=input()
#s1=input()
#p=input()
#l=list(map(int,input().split()))
#l2=list(map(int,input().split()))
#l=str(n)
#l.sort(reverse=True)
#l2.sort(reverse=True)
#l1.sort(reverse=True)
print(solve())
```
| 94,482 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Tags: games, math
Correct Solution:
```
t = int(input())
for i in range(t):
n,k = map(int,input().split())
if k % 3 != 0 or k > n:
print('Bob' if n % 3 == 0 else 'Alice')
else:
print('Bob' if (n % (k + 1)) % 3 == 0 and (n % (k + 1)) != k else 'Alice')
```
| 94,483 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Tags: games, math
Correct Solution:
```
'''
# Sample code to perform I/O:
name = input() # Reading input from STDIN
print('Hi, %s.' % name) # Writing output to STDOUT
# Warning: Printing unwanted or ill-formatted data to output will cause the test cases to fail
'''
# Write your code here
''' CODED WITH LOVE BY SATYAM KUMAR '''
from sys import stdin, stdout
import heapq
import cProfile, math
from collections import Counter, defaultdict, deque
from bisect import bisect_left, bisect, bisect_right
import itertools
from copy import deepcopy
from fractions import Fraction
import sys, threading
import operator as op
from functools import reduce
import sys
sys.setrecursionlimit(10 ** 6) # max depth of recursion
threading.stack_size(2 ** 27) # new thread will get stack of such size
fac_warm_up = False
printHeap = str()
memory_constrained = False
P = 10 ** 9 + 7
class MergeFind:
def __init__(self, n):
self.parent = list(range(n))
self.size = [1] * n
self.num_sets = n
self.lista = [[_] for _ in range(n)]
def find(self, a):
to_update = []
while a != self.parent[a]:
to_update.append(a)
a = self.parent[a]
for b in to_update:
self.parent[b] = a
return self.parent[a]
def merge(self, a, b):
a = self.find(a)
b = self.find(b)
if a == b:
return
if self.size[a] < self.size[b]:
a, b = b, a
self.num_sets -= 1
self.parent[b] = a
self.size[a] += self.size[b]
self.lista[a] += self.lista[b]
def set_size(self, a):
return self.size[self.find(a)]
def __len__(self):
return self.num_sets
def display(string_to_print):
stdout.write(str(string_to_print) + "\n")
def prime_factors(n): # n**0.5 complex
factors = dict()
for i in range(2, math.ceil(math.sqrt(n)) + 1):
while n % i == 0:
if i in factors:
factors[i] += 1
else:
factors[i] = 1
n = n // i
if n > 2:
factors[n] = 1
return (factors)
def all_factors(n):
return set(reduce(list.__add__,
([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
def fibonacci_modP(n, MOD):
if n < 2: return 1
return (cached_fn(fibonacci_modP, (n + 1) // 2, MOD) * cached_fn(fibonacci_modP, n // 2, MOD) + cached_fn(
fibonacci_modP, (n - 1) // 2, MOD) * cached_fn(fibonacci_modP, (n - 2) // 2, MOD)) % MOD
def factorial_modP_Wilson(n, p):
if (p <= n):
return 0
res = (p - 1)
for i in range(n + 1, p):
res = (res * cached_fn(InverseEuler, i, p)) % p
return res
def binary(n, digits=20):
b = bin(n)[2:]
b = '0' * (digits - len(b)) + b
return b
def is_prime(n):
"""Returns True if n is prime."""
if n < 4:
return True
if n % 2 == 0:
return False
if n % 3 == 0:
return False
i = 5
w = 2
while i * i <= n:
if n % i == 0:
return False
i += w
w = 6 - w
return True
def generate_primes(n):
prime = [True for i in range(n + 1)]
p = 2
while p * p <= n:
if prime[p]:
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 1
return prime
factorial_modP = []
def warm_up_fac(MOD):
global factorial_modP, fac_warm_up
if fac_warm_up: return
factorial_modP = [1 for _ in range(fac_warm_up_size + 1)]
for i in range(2, fac_warm_up_size):
factorial_modP[i] = (factorial_modP[i - 1] * i) % MOD
fac_warm_up = True
def InverseEuler(n, MOD):
return pow(n, MOD - 2, MOD)
def nCr(n, r, MOD):
global fac_warm_up, factorial_modP
if not fac_warm_up:
warm_up_fac(MOD)
fac_warm_up = True
return (factorial_modP[n] * (
(pow(factorial_modP[r], MOD - 2, MOD) * pow(factorial_modP[n - r], MOD - 2, MOD)) % MOD)) % MOD
def test_print(*args):
if testingMode:
print(args)
def display_list(list1, sep=" "):
stdout.write(sep.join(map(str, list1)) + "\n")
def display_2D_list(li):
for i in li:
print(i)
def prefix_sum(li):
sm = 0
res = []
for i in li:
sm += i
res.append(sm)
return res
def get_int():
return int(stdin.readline().strip())
def get_tuple():
return map(int, stdin.readline().split())
def get_list():
return list(map(int, stdin.readline().split()))
memory = dict()
def clear_cache():
global memory
memory = dict()
def cached_fn(fn, *args):
global memory
if args in memory:
return memory[args]
else:
result = fn(*args)
memory[args] = result
return result
def ncr(n, r):
return math.factorial(n) / (math.factorial(n - r) * math.factorial(r))
def binary_search(i, li):
fn = lambda x: li[x] - x // i
x = -1
b = len(li)
while b >= 1:
while b + x < len(li) and fn(b + x) > 0: # Change this condition 2 to whatever you like
x += b
b = b // 2
return x
# -------------------------------------------------------------- MAIN PROGRAM
TestCases = True
fac_warm_up_size = 10 ** 5 + 100
optimise_for_recursion = False # Can not be used clubbed with TestCases WHen using recursive functions, use Python 3
def main():
n, k = get_tuple()
if k%3!=0:
print("Alice") if n%3!=0 else print("Bob")
else:
mod = n%(k+1)
print("Bob") if mod%3==0 and mod<k else print("Alice")
# --------------------------------------------------------------------- END=
if TestCases:
for i in range(get_int()):
main()
else:
main() if not optimise_for_recursion else threading.Thread(target=main).start()
```
| 94,484 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Tags: games, math
Correct Solution:
```
a = int(input())
for i in range(a):
b, c = map(int,input().split())
if c % 3 == 0:
if b % (c+1) == c:
print("Alice")
elif (b % (c+1)) % 3 == 0:
print("Bob")
else:
print("Alice")
else:
if b % 3 == 0:
print("Bob")
else:
print("Alice")
```
| 94,485 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Submitted Solution:
```
t=int(input())
while(t):
n,k=map(int,input().split())
if(k%3==0):
n=n%(k+1)
if(n%3==0 and n!=k):
print("Bob")
else:
print("Alice")
t-=1
```
Yes
| 94,486 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Submitted Solution:
```
for _ in range(int(input())):
n,k = [*map(int, input().split())]
if k % 3 != 0:
loss = ((n%3) == 0)
else:
cycle_length = ((k // 3) - 1) * 3 + 4
n = n % cycle_length
loss = (((n%3) == 0) and (n != cycle_length-1))
print("Bob" if loss else "Alice")
```
Yes
| 94,487 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Submitted Solution:
```
T = int(input())
while T:
T -= 1
str = list(map(int, input().split()))
n = str[0]
k = str[1]
if k % 3 != 0:
print("Bob" if n % 3 == 0 else "Alice")
else:
n = n%(k+1)
if n==k or n%3!=0:
print("Alice")
else:
print("Bob")
```
Yes
| 94,488 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Submitted Solution:
```
for _ in range(int(input())):
n,k = map(int,input().split())
if(k % 3 == 0):
n %= (k+1)
if(n % 3 == 0 and n != k):
print("Bob")
else:
print("Alice")
```
Yes
| 94,489 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Submitted Solution:
```
n = int(input())
for i in range(n):
a, b = map(int, input().split())
if a == 0:
print("Bob")
continue
if a <= 2 or a == b:
print("Alice")
continue
if a%3==0 or a%(b+1)==0 or a%(b+2)==0:
print("Bob")
continue
else:
print("Alice")
```
No
| 94,490 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Submitted Solution:
```
t = int(input())
for i in range(t):
n,k = map(int,input().split())
if k % 3 != 0:
if n % 3 == 0:
print('Bob')
else:
print('Alice')
else:
if n % 4 == 0:
print('Bob')
else:
print('Alice')
```
No
| 94,491 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Submitted Solution:
```
Q=int(input())
for i in range(Q):
n,m=map(int,input().split())
if n<m:
if n%3==0:
print("Bob")
else:
print("Alice")
elif n ==m:
print("Alice")
else:
if m%3==0:
print("Alice")
elif m%3!=0 and n%3==0:
print("Bob")
else:
print("Alice")
```
No
| 94,492 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob play a game. There is a paper strip which is divided into n + 1 cells numbered from left to right starting from 0. There is a chip placed in the n-th cell (the last one).
Players take turns, Alice is first. Each player during his or her turn has to move the chip 1, 2 or k cells to the left (so, if the chip is currently in the cell i, the player can move it into cell i - 1, i - 2 or i - k). The chip should not leave the borders of the paper strip: it is impossible, for example, to move it k cells to the left if the current cell has number i < k. The player who can't make a move loses the game.
Who wins if both participants play optimally?
Alice and Bob would like to play several games, so you should determine the winner in each game.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of games. Next T lines contain one game per line. All games are independent.
Each of the next T lines contains two integers n and k (0 ≤ n ≤ 109, 3 ≤ k ≤ 109) — the length of the strip and the constant denoting the third move, respectively.
Output
For each game, print Alice if Alice wins this game and Bob otherwise.
Example
Input
4
0 3
3 3
3 4
4 4
Output
Bob
Alice
Bob
Alice
Submitted Solution:
```
T = int(input())
l = []
for i in range(T):
n, k = map(int, input().split())
if n == 0:
x = 2
else:
x = n % k
l.append(x)
for i in range(T):
if l[i] == 0:
print("Alice")
else:
print("Bob")
```
No
| 94,493 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers. You need to choose a subset and put the chosen numbers in a beautiful rectangle (rectangular matrix). Each chosen number should occupy one of its rectangle cells, each cell must be filled with exactly one chosen number. Some of the n numbers may not be chosen.
A rectangle (rectangular matrix) is called beautiful if in each row and in each column all values are different.
What is the largest (by the total number of cells) beautiful rectangle you can construct? Print the rectangle itself.
Input
The first line contains n (1 ≤ n ≤ 4⋅10^5). The second line contains n integers (1 ≤ a_i ≤ 10^9).
Output
In the first line print x (1 ≤ x ≤ n) — the total number of cells of the required maximum beautiful rectangle. In the second line print p and q (p ⋅ q=x): its sizes. In the next p lines print the required rectangle itself. If there are several answers, print any.
Examples
Input
12
3 1 4 1 5 9 2 6 5 3 5 8
Output
12
3 4
1 2 3 5
3 1 5 4
5 6 8 9
Input
5
1 1 1 1 1
Output
1
1 1
1
Tags: brute force, combinatorics, constructive algorithms, data structures, greedy, math
Correct Solution:
```
n = int(input())
l = list(map(int,input().split()))
if n == 1:
print(1)
print(1,1)
print(l[0])
else:
d = {}
for i in l:
d[i] = 0
for i in l:
d[i] += 1
equal = [0] * (n + 1)
for i in d:
equal[d[i]] += 1
atmost = [0] * (n + 1)
atmost[0] = equal[0]
for i in range(1, n+1):
atmost[i] = atmost[i-1] + equal[i]
sumka = 0
best_iloczyn = 0
best_a = 0
best_b = 0
for a in range(1, n):
if a**2 > n:
break
sumka += (len(d) - atmost[a-1])
b_cand = sumka//a
if b_cand < a:
continue
if a * b_cand > best_iloczyn:
best_iloczyn = a * b_cand
best_a = a
best_b = b_cand
print(best_iloczyn)
print(best_a, best_b)
li = []
for i in d:
if d[i] >= best_a:
li += [i]*min(best_a, d[i])
for i in d:
if d[i] < best_a:
li += [i]*min(best_a, d[i])
#print(li)
mat = [[0] * best_b for i in range(best_a)]
for dd in range(1, best_a + 1):
if best_a%dd==0 and best_b%dd==0:
du = dd
i = 0
for st in range(du):
for j in range(best_iloczyn//du):
mat[i%best_a][(st+i)%best_b] = li[i]
i += 1
for i in range(best_a):
print(*mat[i])
```
| 94,494 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers. You need to choose a subset and put the chosen numbers in a beautiful rectangle (rectangular matrix). Each chosen number should occupy one of its rectangle cells, each cell must be filled with exactly one chosen number. Some of the n numbers may not be chosen.
A rectangle (rectangular matrix) is called beautiful if in each row and in each column all values are different.
What is the largest (by the total number of cells) beautiful rectangle you can construct? Print the rectangle itself.
Input
The first line contains n (1 ≤ n ≤ 4⋅10^5). The second line contains n integers (1 ≤ a_i ≤ 10^9).
Output
In the first line print x (1 ≤ x ≤ n) — the total number of cells of the required maximum beautiful rectangle. In the second line print p and q (p ⋅ q=x): its sizes. In the next p lines print the required rectangle itself. If there are several answers, print any.
Examples
Input
12
3 1 4 1 5 9 2 6 5 3 5 8
Output
12
3 4
1 2 3 5
3 1 5 4
5 6 8 9
Input
5
1 1 1 1 1
Output
1
1 1
1
Tags: brute force, combinatorics, constructive algorithms, data structures, greedy, math
Correct Solution:
```
def play(arr):
n = len(arr)
number2Count = {}
for p in arr:
number2Count[p] = number2Count.get(p, 0) + 1
count2Numbers = {}
maxCnt = 0
for num in number2Count:
cnt = number2Count[num]
if not cnt in count2Numbers:
count2Numbers[cnt] = []
count2Numbers[cnt].append(num)
maxCnt = max(maxCnt, cnt)
numRepeats = [0] * (n + 1)
numRepeats[n] = len(count2Numbers.get(n, []))
for i in range(n - 1, 0, -1):
numRepeats[i] = numRepeats[i + 1] + len(count2Numbers.get(i, []))
a_ideal = 0
b_ideal = 0
square = 0
square_ideal = 0
for a in range(1, n + 1):
square += numRepeats[a]
b = int(square / a)
if a <= b:
if square_ideal < a * b:
square_ideal = a * b
a_ideal = a
b_ideal = b
print(a_ideal * b_ideal)
print(str(a_ideal) + ' ' + str(b_ideal))
matrix = [[0] * b_ideal for p in range(0, a_ideal)]
x = 0
y = 0
for cnt in range(maxCnt, 0, -1):
for num in count2Numbers.get(cnt, []):
for i in range(0, min(cnt, a_ideal)):
if matrix[x][y] > 0:
x = (x + 1) % a_ideal
if matrix[x][y] == 0:
matrix[x][y] = num
x = (x + 1) % a_ideal
y = (y + 1) % b_ideal
for i in range(0, a_ideal):
print(*matrix[i])
def main():
input()
arr = list(map(int, input().split()))
play(arr)
main()
#print(play([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8]))
#print(play([4, 9, 5, 9, 6, 8, 9, 8, 7]))
# play(['010', '101', '0'])
# play(['00000', '00001'])
# play(['01', '001', '0001', '00001'])
```
| 94,495 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers. You need to choose a subset and put the chosen numbers in a beautiful rectangle (rectangular matrix). Each chosen number should occupy one of its rectangle cells, each cell must be filled with exactly one chosen number. Some of the n numbers may not be chosen.
A rectangle (rectangular matrix) is called beautiful if in each row and in each column all values are different.
What is the largest (by the total number of cells) beautiful rectangle you can construct? Print the rectangle itself.
Input
The first line contains n (1 ≤ n ≤ 4⋅10^5). The second line contains n integers (1 ≤ a_i ≤ 10^9).
Output
In the first line print x (1 ≤ x ≤ n) — the total number of cells of the required maximum beautiful rectangle. In the second line print p and q (p ⋅ q=x): its sizes. In the next p lines print the required rectangle itself. If there are several answers, print any.
Examples
Input
12
3 1 4 1 5 9 2 6 5 3 5 8
Output
12
3 4
1 2 3 5
3 1 5 4
5 6 8 9
Input
5
1 1 1 1 1
Output
1
1 1
1
Tags: brute force, combinatorics, constructive algorithms, data structures, greedy, math
Correct Solution:
```
n = int(input())
arr = list(map(int, input().split()))
d = {}
for i in arr:
d[i] = d.get(i, 0) + 1
d2 = {}
for k, v in d.items():
d2.setdefault(v, []).append(k)
s = n
prev = 0
ansp = ansq = anss = 0
for p in range(n, 0, -1):
q = s // p
if p <= q and q * p > anss:
anss = q * p
ansq = q
ansp = p
prev += len(d2.get(p, []))
s -= prev
def get_ans():
cur_i = 0
cur_j = 0
cur = 0
for k, v in d3:
for val in v:
f = min(k, anss - cur, ansp)
cur += f
for i in range(f):
cur_i = (cur_i + 1) % ansp
cur_j = (cur_j + 1) % ansq
if ans[cur_i][cur_j]:
cur_i = (cur_i + 1) % ansp
ans[cur_i][cur_j] = val
print(anss)
print(ansp, ansq)
d3 = sorted(d2.items(), reverse=True)
ans = [[0] * ansq for i in range(ansp)]
get_ans()
for i in range(ansp):
print(*ans[i])
```
| 94,496 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers. You need to choose a subset and put the chosen numbers in a beautiful rectangle (rectangular matrix). Each chosen number should occupy one of its rectangle cells, each cell must be filled with exactly one chosen number. Some of the n numbers may not be chosen.
A rectangle (rectangular matrix) is called beautiful if in each row and in each column all values are different.
What is the largest (by the total number of cells) beautiful rectangle you can construct? Print the rectangle itself.
Input
The first line contains n (1 ≤ n ≤ 4⋅10^5). The second line contains n integers (1 ≤ a_i ≤ 10^9).
Output
In the first line print x (1 ≤ x ≤ n) — the total number of cells of the required maximum beautiful rectangle. In the second line print p and q (p ⋅ q=x): its sizes. In the next p lines print the required rectangle itself. If there are several answers, print any.
Examples
Input
12
3 1 4 1 5 9 2 6 5 3 5 8
Output
12
3 4
1 2 3 5
3 1 5 4
5 6 8 9
Input
5
1 1 1 1 1
Output
1
1 1
1
Tags: brute force, combinatorics, constructive algorithms, data structures, greedy, math
Correct Solution:
```
from sys import stdin, stdout
def getmaxrectangle(n, a):
dic = {}
dicCntVals = {}
for va in a:
if va not in dic:
dic[va] = 0
dic[va] += 1
for val in dic.keys():
cnt = dic[val]
if cnt not in dicCntVals:
dicCntVals[cnt] = []
dicCntVals[cnt].append(val)
geq = [0]*(n+1)
if n in dicCntVals:
geq[n] = len(dicCntVals[n])
for cnt in range(n-1, 0, -1):
geq[cnt] = geq[cnt + 1]
if cnt in dicCntVals:
geq[cnt] += len(dicCntVals[cnt])
#print(geq)
b_pq = 0
b_p = 0
b_q = 0
ttl = 0
for p in range(1, n+1):
ttl += geq[p]
q = int(ttl/p)
if q >= p and q*p > b_pq:
b_pq = q*p
b_p = p
b_q = q
x = 0
y = 0
#print(str(b_pq))
r = [[0 for j in range(b_q)] for i in range(b_p)]
#print(str((b_p)))
#print(str((b_q)))
#print(str(len(r)))
#print(str(len(r[0])))
for i in range(n, 0, -1):
if i not in dicCntVals:
continue
for j in dicCntVals[i]:
for k in range(min(b_p, i)):
if r[x][y] != 0:
x = (x + 1) % b_p;
if r[x][y] == 0:
r[x][y] = j
x = (x + 1) % b_p
y = (y + 1) % b_q
return r
if __name__ == '__main__':
n = int(stdin.readline())
a = list(map(int, stdin.readline().split()))
res = getmaxrectangle(n, a)
stdout.write(str(len(res) * len(res[0])))
stdout.write('\n')
stdout.write(str(len(res)) + ' ' + str(len(res[0])))
stdout.write('\n')
for i in range(len(res)):
for j in range(len(res[i])):
stdout.write(str(res[i][j]))
stdout.write(' ')
stdout.write('\n')
```
| 94,497 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers. You need to choose a subset and put the chosen numbers in a beautiful rectangle (rectangular matrix). Each chosen number should occupy one of its rectangle cells, each cell must be filled with exactly one chosen number. Some of the n numbers may not be chosen.
A rectangle (rectangular matrix) is called beautiful if in each row and in each column all values are different.
What is the largest (by the total number of cells) beautiful rectangle you can construct? Print the rectangle itself.
Input
The first line contains n (1 ≤ n ≤ 4⋅10^5). The second line contains n integers (1 ≤ a_i ≤ 10^9).
Output
In the first line print x (1 ≤ x ≤ n) — the total number of cells of the required maximum beautiful rectangle. In the second line print p and q (p ⋅ q=x): its sizes. In the next p lines print the required rectangle itself. If there are several answers, print any.
Examples
Input
12
3 1 4 1 5 9 2 6 5 3 5 8
Output
12
3 4
1 2 3 5
3 1 5 4
5 6 8 9
Input
5
1 1 1 1 1
Output
1
1 1
1
Tags: brute force, combinatorics, constructive algorithms, data structures, greedy, math
Correct Solution:
```
from itertools import accumulate
import math
from collections import Counter
import sys
input = sys.stdin.readline
n = int(input())
A = list(map(int, input().split()))
D = Counter(A)
MAXV = max(max(D.values()), int(math.sqrt(n)))
VCOUNT = [0] * (MAXV + 1)
for v in D.values():
VCOUNT[v] += 1
SUM = n
ACC = list(accumulate(VCOUNT[::-1]))[::-1]
ANS = 0
for i in range(MAXV, 0, -1):
if SUM // i >= i:
if ANS < i * (SUM // i):
ANS = i * (SUM // i)
ANSX = i, (SUM // i)
SUM -= ACC[i]
print(ANS)
X, Y = ANSX[0], ANSX[1]
print(X, Y)
maxx,a,b=ANS,X,Y
A = []
D = D.most_common()
for key, d in D:
num = min(a, d)
for number in range(num):
A.append(key)
ANS = [[0] * (b) for _ in range(a)]
AIM = A[:maxx]
pos = 0
turn = 0
while True:
posi = 0
posj = turn
for i in range(a):
ANS[(posi + i) % a][(posj + i) % b] = AIM[pos]
pos += 1
if pos == maxx:
break
turn += 1
'''
for i in range(a):
print(*ANS[i])
'''
for ans in ANS:
sys.stdout.write(" ".join(map(str,ans))+"\n")
```
| 94,498 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers. You need to choose a subset and put the chosen numbers in a beautiful rectangle (rectangular matrix). Each chosen number should occupy one of its rectangle cells, each cell must be filled with exactly one chosen number. Some of the n numbers may not be chosen.
A rectangle (rectangular matrix) is called beautiful if in each row and in each column all values are different.
What is the largest (by the total number of cells) beautiful rectangle you can construct? Print the rectangle itself.
Input
The first line contains n (1 ≤ n ≤ 4⋅10^5). The second line contains n integers (1 ≤ a_i ≤ 10^9).
Output
In the first line print x (1 ≤ x ≤ n) — the total number of cells of the required maximum beautiful rectangle. In the second line print p and q (p ⋅ q=x): its sizes. In the next p lines print the required rectangle itself. If there are several answers, print any.
Examples
Input
12
3 1 4 1 5 9 2 6 5 3 5 8
Output
12
3 4
1 2 3 5
3 1 5 4
5 6 8 9
Input
5
1 1 1 1 1
Output
1
1 1
1
Tags: brute force, combinatorics, constructive algorithms, data structures, greedy, math
Correct Solution:
```
from collections import Counter
from sys import stdin
def input():
return next(stdin)[:-1]
def main():
n = int(input())
aa = input().split()
cc = list(Counter(aa).most_common())
if n % cc[0][1] == 0 and cc[0][1] * cc[0][1] <= n:
h = cc[0][1]
w = n//cc[0][1]
best = n
else:
count_count = [0] * (n+1)
for v, c in cc:
count_count[c] += 1
geq = [count_count[n]]
for v in reversed(count_count[:n]):
geq.append(geq[-1] + v)
geq.reverse()
tot = 0
best = 0
for a in range(1,n+1):
tot += geq[a]
b = tot//a
if a <= b and best < a * b:
best = a * b
h = a
w = b
print(best)
print(h,w)
x = 0
y = 0
mat = [[''] * w for _ in range(h) ]
for v, c in cc:
for j in range(min(c, h)):
if mat[x][y] != '':
x = (x+1)%h
if mat[x][y] == '':
mat[x][y] = v
x = (x+1)%h
y = (y+1)%w
for i in range(h):
print(' '.join(mat[i]))
if __name__ == "__main__":
main()
```
| 94,499 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.