text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 ≤ n ≤ 100000, 1 ≤ m ≤ 300000) — the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 ≤ wi ≤ 3, 1 ≤ ci ≤ 109) — the weight and the cost of ith souvenir.
Output
Print one number — maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10
Submitted Solution:
```
def souvenier_calc(max_weight, weights, value):
const = len(weights)
ans = [-1061109567 for x in range(max_weight+1)]
node = [(x, y) for x, y in zip(weights, value)]
node = sorted(node, key=lambda x: x[1]/x[0], reverse=True)
weights = [x[0] for x in node]
value = [x[1] for x in node]
sum = 0
sol = 0
ans[0] = 0
for i in range(const):
sum += weights[i]
if sum > max_weight:
sum = max_weight
down = max(weights[i], sum-3)
for weight in range(sum, down-1, -1):
ans[weight] = max(ans[weight], ans[weight-weights[i]]+value[i])
sol = max(sol, ans[weight])
return sol
if __name__ == '__main__':
N, M = map(int, input().split())
assert(N <= 10**5 and M <= 3*(10**5)), 'Out of range'
weights = []
value = []
for i in range(N):
x, y = map(int, input().split())
assert(x >= 1 and x <= 3), 'Out of range'
assert(y >= 1 and y <= 10**9), 'Out of range'
weights.append(x)
value.append(y)
print(souvenier_calc(M, weights, value))
```
Yes
| 7,200 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 ≤ n ≤ 100000, 1 ≤ m ≤ 300000) — the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 ≤ wi ≤ 3, 1 ≤ ci ≤ 109) — the weight and the cost of ith souvenir.
Output
Print one number — maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10
Submitted Solution:
```
n, m = list(map(int, input().split()))
a = [[], [], []]
for i in range(n):
w, c = list(map(int, input().split()))
a[w-1].append(c)
p = [[0], [0], [0]]
for i in range(3):
a[i].sort(reverse=True)
for x in a[i]:
p[i].append(p[i][-1] + x)
ans = 0
for i in range(min(m//3, len(a[2])) + 1):
w = m - i * 3
if len(a[1]) * 2 + len(a[0]) <= w:
ans = max(ans, p[2][i] + p[1][len(a[1])] + p[0][len(a[0])])
continue
if not len(a[0]):
ans = max(ans, p[2][i] + p[1][min(w//2, len(a[1]))])
continue
if 2 + 2 == 4:
x = min(len(a[0]), w)
y = (w - x) // 2
ans = max(ans, p[2][i] + p[1][y] + p[0][x])
lo = max((w - len(a[0]) + 1) // 2 + 1, 1)
hi = min(len(a[1]), w // 2)
while lo <= hi:
mi = (lo + hi) // 2
if a[1][mi - 1] - (p[0][w-mi*2+2] - p[0][w-mi*2]) > 0:
lo = mi + 1
else:
hi = mi - 1
ans = max(ans, p[2][i] + p[1][hi] + p[0][w-hi*2])
print(ans)
```
Yes
| 7,201 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 ≤ n ≤ 100000, 1 ≤ m ≤ 300000) — the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 ≤ wi ≤ 3, 1 ≤ ci ≤ 109) — the weight and the cost of ith souvenir.
Output
Print one number — maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10
Submitted Solution:
```
a = [int(x) for x in input().split()]
n = a[0]
m = a[1]
dp = [0]*(m+1)
ws = [[0,0,0],[0,0],[0]]
for p in range(n):
a = [int(x) for x in input().split()]
w = a[0]
c = a[1]
ws[w-1].append(c)
ws[0] = sorted(ws[0])[::-1]
ws[1] = sorted(ws[1])[::-1]
ws[2] = sorted(ws[2])[::-1]
if m == 1:
print ((ws[0][0]))
exit(0)
if m == 2:
print( max(ws[0][0] + ws[0][1], ws[1][0]))
exit(0)
if m == 3:
print (max(ws[0][0] + ws[0][1] + ws[0][2], ws[0][0] + ws[1][0], ws[2][0]))
exit(0)
dp[1] = (ws[0][0], [1,0,0])
if ws[0][0]+ws[0][1] <= ws[1][0]:
dp[2] = (ws[1][0], [0,1,0])
else:
dp[2] = (ws[0][0]+ws[0][1], [2,0,0])
if ws[2][0] == max(ws[0][0] + ws[0][1] + ws[0][2], ws[0][0] + ws[1][0], ws[2][0]):
dp[3] = (ws[2][0], [0,0,1])
elif ws[0][0] + ws[1][0] == max(ws[0][0] + ws[0][1] + ws[0][2], ws[0][0] + ws[1][0], ws[2][0]):
dp[3] = (ws[0][0]+ws[1][0], [1,1,0])
else:
dp[3] = (ws[0][0] + ws[0][1] + ws[0][2], [3,0,0])
#s1 = sum(ws[0]) + sum(ws[1]) + sum(ws[2])
#if s1 <= m:
# print(s1)
# exit(0)
for i in range(4, m+1):
# print (i, dp)
if dp[i-3] != 0 and len(ws[2]) > dp[i-3][1][2]:
c1 = dp[i-3][0] + ws[2][dp[i-3][1][2]]
z1 = c1-dp[i-3][0]
else:
z1 = 0
c1 = 0
if dp[i-2] != 0 and len(ws[1]) > dp[i-2][1][1]:
c2 = dp[i-2][0] + ws[1][dp[i-2][1][1]]
z2 = c2-dp[i-2][0]
else:
c2 = 0
z2 = 0
if dp[i-1] != 0 and len(ws[0]) > dp[i-1][1][0]:
c3 = dp[i-1][0] + ws[0][dp[i-1][1][0]]
z3 = c3-dp[i-1][0]
else:
c3 = 0
z3 = 0
z = [z1, z2, z3]
if c1 == max(c1, c2, c3) and c1 != 0:
tmp = [x for x in dp[i-3][1]]
tmp[2] += 1
dp[i] = (c1, tmp)
elif c2 == max(c1, c2, c3) and c2 != 0:
tmp = [x for x in dp[i-2][1]]
tmp[1] += 1
dp[i] = (c2, tmp)
elif c3 == max(c1, c2, c3) and c3 != 0:
tmp = [x for x in dp[i-1][1]]
tmp[0] += 1
dp[i] = (c3, tmp)
elif sum(z) == 0:
if (dp[i-1][0] == 24804061302924):
print ("24804061310402")
else:
print (dp[i-1][0])
exit(0)
if (dp[m][0] == 24804061302924):
print ("24804061310402")
else:
print (dp[m][0])
```
No
| 7,202 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 ≤ n ≤ 100000, 1 ≤ m ≤ 300000) — the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 ≤ wi ≤ 3, 1 ≤ ci ≤ 109) — the weight and the cost of ith souvenir.
Output
Print one number — maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10
Submitted Solution:
```
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
w[wi - 1].append(ci)
w[0].sort(reverse=True)
w[1].sort(reverse=True)
w[2].sort(reverse=True)
m0 = len(w[0])
m1 = len(w[1])
m2 = len(w[2])
dp = [0] * (m + 1)
used = [[0]*3 for i in range(m + 1)]
if m0 > 0:
dp[1] = w[0][0]
used[1] = [1, 0, 0]
else:
pass
if m == 1:
print(dp[1])
return
if m0 > 1:
dp[2] = dp[1] + w[0][1]
used[2] = [2, 0, 0]
else:
dp[2] = dp[1]
used[2] = used[1][:]
if m1 > 0 and w[1][0] > dp[2]:
dp[2] = w[1][0]
used[2] = [0, 1, 0]
if m == 2:
print(dp[2])
return
for i in range(3, m + 1):
if used[i - 1][0] < m0:
dp[i] = dp[i - 1] + w[0][used[i - 1][0]]
used[i] = used[i - 1][:]
used[i][0] += 1
if used[i - 2][1] < m1 and dp[i - 2] + w[1][used[i - 2][1]] > dp[i]:
dp[i] = dp[i - 2] + w[1][used[i - 2][1]]
used[i] = used[i - 2][:]
used[i][1] += 1
if used[i - 3][2] < m2 and dp[i - 3] + w[2][used[i - 3][2]] > dp[i]:
dp[i] = dp[i - 3] + w[2][used[i - 3][2]]
used[i] = used[i - 3][:]
used[i][2] += 1
ans = dp[m]
print(ans)
if __name__ == '__main__':
solve()
```
No
| 7,203 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 ≤ n ≤ 100000, 1 ≤ m ≤ 300000) — the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 ≤ wi ≤ 3, 1 ≤ ci ≤ 109) — the weight and the cost of ith souvenir.
Output
Print one number — maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10
Submitted Solution:
```
import sys
n, m = map(int, input().split())
w1 = [10**10]
w2 = [10**10]
w3 = [10**10]
for w, c in (map(int, l.split()) for l in sys.stdin):
if w == 1:
w1.append(c)
elif w == 2:
w2.append(c)
else:
w3.append(c)
w1.sort(reverse=True)
w1[0] = 0
for i in range(len(w1)-1):
w1[i+1] += w1[i]
w2.sort(reverse=True)
w2[0] = 0
for i in range(len(w2)-1):
w2[i+1] += w2[i]
w3.sort(reverse=True)
w3[0] = 0
for i in range(len(w3)-1):
w3[i+1] += w3[i]
w1_size, w2_size = len(w1)-1, len(w2)-1
ans = 0
for c3 in range(len(w3)):
if c3*3 > m:
break
if c3*3 == m:
ans = max(ans, w3[c3])
break
W = m - c3*3
l, r = 0, min(W//2, w2_size)
while r-l > 1:
ml, mr = l+(r-l+2)//3, r-(r-l+2)//3
c1 = w2[ml] + w1[min(W-ml*2, w1_size)]
c2 = w2[mr] + w1[min(W-mr*2, w1_size)]
if c1 > c2:
r = mr
else:
l = ml
ans = max(ans,
w3[c3] + w2[l]+w1[min(W-l*2, w1_size)],
w3[c3] + w2[r]+w1[min(W-r*2, w1_size)]
)
print(ans)
```
No
| 7,204 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 ≤ n ≤ 100000, 1 ≤ m ≤ 300000) — the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 ≤ wi ≤ 3, 1 ≤ ci ≤ 109) — the weight and the cost of ith souvenir.
Output
Print one number — maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10
Submitted Solution:
```
import sys
from itertools import accumulate
def solve():
n, m = map(int, input().split())
w = [[] for i in range(3)]
for i in range(n):
wi, ci = map(int, sys.stdin.readline().split())
wi -= 1
w[wi].append(ci)
for i in range(3):
w[i].sort(reverse=True)
m0 = len(w[0])
m1 = len(w[1])
m2 = len(w[2])
# print(w)
dp = [0] * (m + 1)
used = [[0]*3 for i in range(m + 1)]
for i in range(1, m + 1):
tmp = 0
tmp_u = []
if used[i - 1][0] < m0:
tmp = dp[i - 1] + w[0][used[i - 1][0]]
tmp_u = used[i - 1][:]
tmp_u[0] += 1
else:
tmp = dp[i - 1]
tmp_u = used[i - 1][:]
if i - 2 < 0:
dp[i] = tmp
used[i] = tmp_u[:]
continue
if used[i - 2][1] < m1 and tmp < dp[i - 2] + w[1][used[i - 2][1]]:
tmp = dp[i - 2] + w[1][used[i - 2][1]]
tmp_u = used[i - 2][:]
used[i][1] += 1
if i - 3 < 0:
dp[i] = tmp
used[i] = tmp_u[:]
continue
if used[i - 3][2] < m2 and tmp < dp[i - 3] + w[2][used[i - 3][2]]:
tmp = dp[i - 3] + w[2][used[i - 3][2]]
tmp_u = used[i - 3][:]
used[i][2] += 1
dp[i] = tmp
used[i] = tmp_u[:]
# print(dp)
# print(used)
ans = dp[m]
print(ans)
if __name__ == '__main__':
solve()
```
No
| 7,205 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
Tags: math, number theory
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
avl=AvlTree()
#-----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default='z', func=lambda a, b: min(a ,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left)/ 2)
# Check if middle element is
# less than or equal to key
if (arr[mid]<=key):
count = mid+1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def countGreater( arr,n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
for i in range(int(input())):
a,b=map(int,input().split())
c=a*b
l=int(c**(1./3)+0.5)
if l**3==a*b and a%l==0 and b%l==0:
print("YES")
else:
print("NO")
```
| 7,206 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
Tags: math, number theory
Correct Solution:
```
import sys,os,io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_left , bisect_right
import math
def ii():
return int(input())
def li():
return list(map(int,input().split()))
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
else:
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
no = "No"
yes = "Yes"
def solve():
a,b = li()
x = (pow(a*b,1/3))
x=round(x)
if x*x*x==a*b and a%x==b%x==0:
print(yes)
else:
print(no)
t = 1
t = int(input())
for _ in range(t):
solve()
```
| 7,207 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
Tags: math, number theory
Correct Solution:
```
import sys
input = sys.stdin.readline
print = sys.stdout.write
cbrt = {i**3:i for i in range(1001)}
n = int(input())
all_res = []
for _ in range(n):
a, b = map(int, input().split())
if a == b:
all_res.append('Yes' if a in cbrt else 'No')
continue
if a > b:
a, b = b, a
r = cbrt.get(a * a // b, 0)
if r == 0 or a % (r * r) > 0:
all_res.append('No')
continue
y = a //(r * r)
if r * r * y == a and r * y * y == b:
all_res.append('Yes')
else:
all_res.append('No')
print('\n'.join(all_res))
```
| 7,208 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
Tags: math, number theory
Correct Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
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-----------------------------------------------------
for t in range (int(input())):
a,b=map(int,input().split())
p=a*b
#print(p)
c=int(round(p**(1./3)))
#print (c)
if c**3==p and a%c==0 and b%c==0:
print("Yes")
else:
print("No")
```
| 7,209 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
Tags: math, number theory
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
avl=AvlTree()
#-----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default='z', func=lambda a, b: min(a ,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left)/ 2)
# Check if middle element is
# less than or equal to key
if (arr[mid]<=key):
count = mid+1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def countGreater( arr,n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
for i in range(int(input())):
a,b=map(int,input().split())
#c=a*b
l=int((a*b)**(1/3)+0.5)
if l**3==a*b and a%l==0 and b%l==0:
print("YES")
else:
print("NO")
```
| 7,210 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
Tags: math, number theory
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
from math import pow
# ------------------------------
def main():
for _ in range(N()):
a, b = RL()
mt = a*b
res = round(pow(mt, 1/3))
if res**3==mt and a%res==0 and b%res==0:
print('Yes')
else:
print('No')
if __name__ == "__main__":
main()
```
| 7,211 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
Tags: math, number theory
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
avl=AvlTree()
#-----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default='z', func=lambda a, b: min(a ,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left)/ 2)
# Check if middle element is
# less than or equal to key
if (arr[mid]<=key):
count = mid+1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def countGreater( arr,n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
for i in range(int(input())):
a,b=map(int,input().split())
c=a*b
l=int(c**(1/3)+0.5)
if l**3==a*b and a%l==0 and b%l==0:
print("YES")
else:
print("NO")
```
| 7,212 |
Provide tags and a correct Python 3 solution for this coding contest problem.
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
Tags: math, number theory
Correct Solution:
```
import os, sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
for _ in range(int(input())):
a, b = map(int, input().split())
q = a * b
t = round(q ** (1 / 3))
if t * t * t == q and a % t == b % t == 0:
print('YES')
else:
print('NO')
```
| 7,213 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
Submitted Solution:
```
import sys
input = sys.stdin.buffer.readline
def gcd(a, b):
if a > b:
a, b = b, a
if b % a==0:
return a
return gcd(b % a, a)
def process(a, b):
g = gcd(a, b)
r = a//g
s = b//g
if g % r != 0:
return 'No'
g = g//r
if g % s != 0:
return 'No'
G3 = g//s
G = round(G3**(1/3))
cube = False
for i in range(10):
if (G-i)**3==G3 or (G+i)**3==G3:
cube = True
break
if not cube:
return 'No'
return 'Yes'
n = int(input())
for i in range(n):
a, b = [int(x) for x in input().split()]
sys.stdout.write(process(a, b)+'\n')
```
Yes
| 7,214 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
Submitted Solution:
```
import io
import os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
t = int(input())
for tc in range(t):
a, b = map(int, input().split())
cbrt = round(pow(a*b, 1/3))
if pow(cbrt, 3) == a*b:
if a % cbrt == b % cbrt == 0:
print("Yes")
continue
print("No")
```
Yes
| 7,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
Submitted Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
avl=AvlTree()
#-----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default='z', func=lambda a, b: min(a ,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left)/ 2)
# Check if middle element is
# less than or equal to key
if (arr[mid]<=key):
count = mid+1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def countGreater( arr,n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
for i in range(int(input())):
a,b=map(int,input().split())
l=(a*b)**(Fraction(1,3))+0.5
if int(l)**3==a*b and a%l==0 and b%l==0:
print("YES")
else:
print("NO")
```
No
| 7,216 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
Submitted Solution:
```
primes = []
M = 10**9
for p in range(2, M):
if p*p > M:
break
is_prime = True
for p2 in primes:
if p2*p2 > p:
break
if p % p2==0:
is_prime = False
break
if is_prime:
primes.append(p)
def factor(n):
d = {}
for p in primes:
if p*p > n:
break
if n % p==0:
c = 0
while n % p==0:
c+=1
n = n//p
d[p] = c
if n > 1:
d[n] = 1
return d
def process(a, b):
d1 = factor(a)
d2 = factor(b)
L = []
for p in d1:
L.append(p)
for p in d2:
if p not in d1:
L.append(p)
for p in L:
x = d1.get(p, 0)
y = d2.get(p, 0)
if (x+y) % 3 != 0:
return 'No'
if x < 2*y or y < 2*x:
return 'No'
return 'Yes'
n = int(input())
for i in range(n):
a, b = [int(x) for x in input().split()]
print(process(a, b))
```
No
| 7,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
Submitted Solution:
```
n = int(input())
for _ in range (n):
a, b = map(int, input().split())
p = a * b
c = int(round(p ** .333))
if c ** 3 == p and a % c == 0 and b % c == 0:
print("Yes")
else:
print("No")
```
No
| 7,218 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
<image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3.
Submitted Solution:
```
import math
t = int(input())
for tc in range(t):
a, b = map(int, input().split())
if not round(pow(a*b, 1/3), 2) ** 3 != a*b:
if a % round(pow(a*b, 1/3), 2) == b % round(pow(a*b, 1/3), 2) == 0:
print("Yes")
continue
print("No")
```
No
| 7,219 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Michael has just bought a new electric car for moving across city. Michael does not like to overwork, so each day he drives to only one of two his jobs.
Michael's day starts from charging his electric car for getting to the work and back. He spends 1000 burles on charge if he goes to the first job, and 2000 burles if he goes to the second job.
On a charging station he uses there is a loyalty program that involves bonus cards. Bonus card may have some non-negative amount of bonus burles. Each time customer is going to buy something for the price of x burles, he is allowed to pay an amount of y (0 ≤ y ≤ x) burles that does not exceed the bonus card balance with bonus burles. In this case he pays x - y burles with cash, and the balance on the bonus card is decreased by y bonus burles.
If customer pays whole price with cash (i.e., y = 0) then 10% of price is returned back to the bonus card. This means that bonus card balance increases by <image> bonus burles. Initially the bonus card balance is equal to 0 bonus burles.
Michael has planned next n days and he knows how much does the charge cost on each of those days. Help Michael determine the minimum amount of burles in cash he has to spend with optimal use of bonus card. Assume that Michael is able to cover any part of the price with cash in any day. It is not necessary to spend all bonus burles at the end of the given period.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 300 000), the number of days Michael has planned.
Next line contains n integers a1, a2, ..., an (ai = 1000 or ai = 2000) with ai denoting the charging cost at the day i.
Output
Output the minimum amount of burles Michael has to spend.
Examples
Input
3
1000 2000 1000
Output
3700
Input
6
2000 2000 2000 2000 2000 1000
Output
10000
Note
In the first sample case the most optimal way for Michael is to pay for the first two days spending 3000 burles and get 300 bonus burles as return. After that he is able to pay only 700 burles for the third days, covering the rest of the price with bonus burles.
In the second sample case the most optimal way for Michael is to pay the whole price for the first five days, getting 1000 bonus burles as return and being able to use them on the last day without paying anything in cash.
Submitted Solution:
```
read = lambda: map(int, input().split())
n = int(input())
a = list(read())
cur = 0
ans = 0
for i in range(n):
t = 0
if i == n - 1 or a[i] <= cur:
t = 1
if t == 0:
ans += a[i]
cur += a[i] // 10
else:
y = min(cur, a[i])
ans += a[i] - y
cur -= y
print(ans)
```
No
| 7,220 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Michael has just bought a new electric car for moving across city. Michael does not like to overwork, so each day he drives to only one of two his jobs.
Michael's day starts from charging his electric car for getting to the work and back. He spends 1000 burles on charge if he goes to the first job, and 2000 burles if he goes to the second job.
On a charging station he uses there is a loyalty program that involves bonus cards. Bonus card may have some non-negative amount of bonus burles. Each time customer is going to buy something for the price of x burles, he is allowed to pay an amount of y (0 ≤ y ≤ x) burles that does not exceed the bonus card balance with bonus burles. In this case he pays x - y burles with cash, and the balance on the bonus card is decreased by y bonus burles.
If customer pays whole price with cash (i.e., y = 0) then 10% of price is returned back to the bonus card. This means that bonus card balance increases by <image> bonus burles. Initially the bonus card balance is equal to 0 bonus burles.
Michael has planned next n days and he knows how much does the charge cost on each of those days. Help Michael determine the minimum amount of burles in cash he has to spend with optimal use of bonus card. Assume that Michael is able to cover any part of the price with cash in any day. It is not necessary to spend all bonus burles at the end of the given period.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 300 000), the number of days Michael has planned.
Next line contains n integers a1, a2, ..., an (ai = 1000 or ai = 2000) with ai denoting the charging cost at the day i.
Output
Output the minimum amount of burles Michael has to spend.
Examples
Input
3
1000 2000 1000
Output
3700
Input
6
2000 2000 2000 2000 2000 1000
Output
10000
Note
In the first sample case the most optimal way for Michael is to pay for the first two days spending 3000 burles and get 300 bonus burles as return. After that he is able to pay only 700 burles for the third days, covering the rest of the price with bonus burles.
In the second sample case the most optimal way for Michael is to pay the whole price for the first five days, getting 1000 bonus burles as return and being able to use them on the last day without paying anything in cash.
Submitted Solution:
```
def main():
n = int(input())
c = list(input().split())
m = int(0)
for o in range(n-1):
if m < int(c[n-1]):
m += int(c[o])/10
else:
m -= int(c[n-1])
print(int(sum(int(b) for b in c)-m))
if __name__ == "__main__" : main()
```
No
| 7,221 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Michael has just bought a new electric car for moving across city. Michael does not like to overwork, so each day he drives to only one of two his jobs.
Michael's day starts from charging his electric car for getting to the work and back. He spends 1000 burles on charge if he goes to the first job, and 2000 burles if he goes to the second job.
On a charging station he uses there is a loyalty program that involves bonus cards. Bonus card may have some non-negative amount of bonus burles. Each time customer is going to buy something for the price of x burles, he is allowed to pay an amount of y (0 ≤ y ≤ x) burles that does not exceed the bonus card balance with bonus burles. In this case he pays x - y burles with cash, and the balance on the bonus card is decreased by y bonus burles.
If customer pays whole price with cash (i.e., y = 0) then 10% of price is returned back to the bonus card. This means that bonus card balance increases by <image> bonus burles. Initially the bonus card balance is equal to 0 bonus burles.
Michael has planned next n days and he knows how much does the charge cost on each of those days. Help Michael determine the minimum amount of burles in cash he has to spend with optimal use of bonus card. Assume that Michael is able to cover any part of the price with cash in any day. It is not necessary to spend all bonus burles at the end of the given period.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 300 000), the number of days Michael has planned.
Next line contains n integers a1, a2, ..., an (ai = 1000 or ai = 2000) with ai denoting the charging cost at the day i.
Output
Output the minimum amount of burles Michael has to spend.
Examples
Input
3
1000 2000 1000
Output
3700
Input
6
2000 2000 2000 2000 2000 1000
Output
10000
Note
In the first sample case the most optimal way for Michael is to pay for the first two days spending 3000 burles and get 300 bonus burles as return. After that he is able to pay only 700 burles for the third days, covering the rest of the price with bonus burles.
In the second sample case the most optimal way for Michael is to pay the whole price for the first five days, getting 1000 bonus burles as return and being able to use them on the last day without paying anything in cash.
Submitted Solution:
```
def main():
n = int(input())
c = list(input().split())
m = int(0)
for o in range(n-1):
if m < int(c[n-1]):
m += int(c[o])/10
else:
m -= int(c[n-1])
print(int(sum(int(b) for b in c)-m))
```
No
| 7,222 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Michael has just bought a new electric car for moving across city. Michael does not like to overwork, so each day he drives to only one of two his jobs.
Michael's day starts from charging his electric car for getting to the work and back. He spends 1000 burles on charge if he goes to the first job, and 2000 burles if he goes to the second job.
On a charging station he uses there is a loyalty program that involves bonus cards. Bonus card may have some non-negative amount of bonus burles. Each time customer is going to buy something for the price of x burles, he is allowed to pay an amount of y (0 ≤ y ≤ x) burles that does not exceed the bonus card balance with bonus burles. In this case he pays x - y burles with cash, and the balance on the bonus card is decreased by y bonus burles.
If customer pays whole price with cash (i.e., y = 0) then 10% of price is returned back to the bonus card. This means that bonus card balance increases by <image> bonus burles. Initially the bonus card balance is equal to 0 bonus burles.
Michael has planned next n days and he knows how much does the charge cost on each of those days. Help Michael determine the minimum amount of burles in cash he has to spend with optimal use of bonus card. Assume that Michael is able to cover any part of the price with cash in any day. It is not necessary to spend all bonus burles at the end of the given period.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 300 000), the number of days Michael has planned.
Next line contains n integers a1, a2, ..., an (ai = 1000 or ai = 2000) with ai denoting the charging cost at the day i.
Output
Output the minimum amount of burles Michael has to spend.
Examples
Input
3
1000 2000 1000
Output
3700
Input
6
2000 2000 2000 2000 2000 1000
Output
10000
Note
In the first sample case the most optimal way for Michael is to pay for the first two days spending 3000 burles and get 300 bonus burles as return. After that he is able to pay only 700 burles for the third days, covering the rest of the price with bonus burles.
In the second sample case the most optimal way for Michael is to pay the whole price for the first five days, getting 1000 bonus burles as return and being able to use them on the last day without paying anything in cash.
Submitted Solution:
```
def main():
n = int(input())
c = list(input().split())
print(int(sum(int(b) for b in c)-sum(int(d) for d in c[:n-1])/10))
if __name__ == "__main__" : main()
```
No
| 7,223 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This time the Berland Team Olympiad in Informatics is held in a remote city that can only be reached by one small bus. Bus has n passenger seats, seat i can be occupied only by a participant from the city ai.
Today the bus has completed m trips, each time bringing n participants. The participants were then aligned in one line in the order they arrived, with people from the same bus standing in the order of their seats (i. e. if we write down the cities where the participants came from, we get the sequence a1, a2, ..., an repeated m times).
After that some teams were formed, each consisting of k participants form the same city standing next to each other in the line. Once formed, teams left the line. The teams were formed until there were no k neighboring participants from the same city.
Help the organizers determine how many participants have left in the line after that process ended. We can prove that answer doesn't depend on the order in which teams were selected.
Input
The first line contains three integers n, k and m (1 ≤ n ≤ 105, 2 ≤ k ≤ 109, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105), where ai is the number of city, person from which must take seat i in the bus.
Output
Output the number of remaining participants in the line.
Examples
Input
4 2 5
1 2 3 1
Output
12
Input
1 9 10
1
Output
1
Input
3 2 10
1 2 1
Output
0
Note
In the second example, the line consists of ten participants from the same city. Nine of them will form a team. At the end, only one participant will stay in the line.
Tags: data structures, implementation
Correct Solution:
```
import sys
from collections import deque
input=sys.stdin.readline
n,k,m=map(int,input().split())
a=list(map(int,input().split()))
r=a[0]
flag=0
for i in range(n):
if r!=a[i]:
flag=1
break
if flag==0:
print((m*n)%k)
sys.exit()
if k>n:
print(m*n)
sys.exit()
curr=a[0]
tmp=1
que=deque([(a[0],1)])
for i in range(1,n):
if a[i]==curr:
tmp+=1
que.append((a[i],tmp))
if tmp==k:
for j in range(k):
que.pop()
if que:
tmp=que[-1][1]
curr=que[-1][0]
else:
curr=-1
else:
tmp=1
curr=a[i]
que.append((a[i],tmp))
quecop=[]
for i in que:
quecop.append(i[0])
leftrem=0
rightrem=0
if not que:
print(0)
sys.exit()
while que[0][0]==que[-1][0]:
r=que[0][0]
count1=0
p=len(que)
count2=p-1
while count1<p and que[count1][0]==r:
count1+=1
if count1==p:
break
while count2>=0 and que[count2][0]==r:
count2-=1
if count1+p-1-count2<k:
break
leftrem+=count1
rightrem+=k-count1
for i in range(count1):
que.popleft()
for i in range(k-count1):
que.pop()
if que:
t=que[0][0]
flag=0
for i in que:
if i[0]!=t:
flag=1
break
if flag:
print(leftrem+rightrem+len(que)*m)
else:
r=[]
for i in range(leftrem):
if r and r[-1][0]==quecop[i]:
r[-1][1]+=1
else:
r.append([quecop[i],1])
if r and r[-1][0]==que[0][0]:
r[-1][0]=(r[-1][0]+(len(que)*m))%k
if r[-1][1]==0:
r.pop()
else:
if (len(que)*m)%k:
r.append([que[0][0],(len(que)*m)%k])
for i in range(len(quecop)-rightrem,len(quecop)):
if r and r[-1][0]==quecop[i]:
r[-1][1]+=1
if r[-1][1]==k:
r.pop()
else:
r.append([quecop[i],1])
finans=0
for i in r:
finans+=i[1]
print(finans)
```
| 7,224 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This time the Berland Team Olympiad in Informatics is held in a remote city that can only be reached by one small bus. Bus has n passenger seats, seat i can be occupied only by a participant from the city ai.
Today the bus has completed m trips, each time bringing n participants. The participants were then aligned in one line in the order they arrived, with people from the same bus standing in the order of their seats (i. e. if we write down the cities where the participants came from, we get the sequence a1, a2, ..., an repeated m times).
After that some teams were formed, each consisting of k participants form the same city standing next to each other in the line. Once formed, teams left the line. The teams were formed until there were no k neighboring participants from the same city.
Help the organizers determine how many participants have left in the line after that process ended. We can prove that answer doesn't depend on the order in which teams were selected.
Input
The first line contains three integers n, k and m (1 ≤ n ≤ 105, 2 ≤ k ≤ 109, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105), where ai is the number of city, person from which must take seat i in the bus.
Output
Output the number of remaining participants in the line.
Examples
Input
4 2 5
1 2 3 1
Output
12
Input
1 9 10
1
Output
1
Input
3 2 10
1 2 1
Output
0
Note
In the second example, the line consists of ten participants from the same city. Nine of them will form a team. At the end, only one participant will stay in the line.
Tags: data structures, implementation
Correct Solution:
```
def process(A, m, k):
n = len(A)
start = n*m
d = []
for i in range(n):
if len(d)==0 or d[-1][0] != A[i]:
d.append([A[i], 1])
else:
d[-1][1]+=1
if d[-1][1]==k:
start-=k*m
d.pop()
if m==1:
return start
p1 = 0
start_d = []
middle_d = []
end_d = []
for x in d:
a, b = x
start_d.append([a, b])
middle_d.append([a, b])
end_d.append([a, b])
if m==2:
middle_d = []
else:
middle_d = [x for x in d]
# print(start_d, middle_d, end_d, start)
#the sequence is start_d + (m-2)* middle_d + end_d
while True:
if p1 >= len(middle_d):
if len(start_d)==0 or p1==len(end_d):
break
v1, c1 = start_d[-1]
v2, c2 = end_d[p1]
if v1==v2 and (c1+c2) >= k:
start-=k
start_d.pop()
if (c1+c2)==k:
p1+=1
else:
end_d[1] = (c1+c2) % k
else:
break
else:
if len(middle_d)-p1==1:
v1, c1 = start_d[-1]
v2, c2 = middle_d[p1]
v3, c3 = end_d[p1]
total_value = c2*(m-2)
if v2==v1:
total_value+=c1
if v2==v3:
total_value+=c3
start-=(total_value-(total_value%k))
if total_value % k==0:
middle_d = []
if v2==v1:
start_d.pop()
if v2==v3:
end_d = end_d
p1+=1
else:
break
else:
v1, c1 = start_d[-1]
v2, c2 = middle_d[p1]
v3, c3 = middle_d[-1]
v4, c4 = end_d[p1]
if v2==v3 and (c2+c3) >= k:
this_value = (c2+c3-(c2+c3) % k)*(m-1)
start-=this_value
middle_d.pop()
start_d.pop()
middle_d[p1][1] = (c2+c3) % k
end_d[p1][1] = (c2+c3) % k
if middle_d[p1][1]==0:
p1+=1
else:
break
# print('start', start_d, start)
# print('middle', middle_d)
# print('end', end_d)
return start
n, k, m = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
print(process(A, m, k))
```
| 7,225 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This time the Berland Team Olympiad in Informatics is held in a remote city that can only be reached by one small bus. Bus has n passenger seats, seat i can be occupied only by a participant from the city ai.
Today the bus has completed m trips, each time bringing n participants. The participants were then aligned in one line in the order they arrived, with people from the same bus standing in the order of their seats (i. e. if we write down the cities where the participants came from, we get the sequence a1, a2, ..., an repeated m times).
After that some teams were formed, each consisting of k participants form the same city standing next to each other in the line. Once formed, teams left the line. The teams were formed until there were no k neighboring participants from the same city.
Help the organizers determine how many participants have left in the line after that process ended. We can prove that answer doesn't depend on the order in which teams were selected.
Input
The first line contains three integers n, k and m (1 ≤ n ≤ 105, 2 ≤ k ≤ 109, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105), where ai is the number of city, person from which must take seat i in the bus.
Output
Output the number of remaining participants in the line.
Examples
Input
4 2 5
1 2 3 1
Output
12
Input
1 9 10
1
Output
1
Input
3 2 10
1 2 1
Output
0
Note
In the second example, the line consists of ten participants from the same city. Nine of them will form a team. At the end, only one participant will stay in the line.
Tags: data structures, implementation
Correct Solution:
```
def main():
_, k, m = [int(x) for x in input().split()]
a = []
last = ("-1", 0)
a.append(last)
for ai in input().split():
if last[0] == ai:
last = (ai, last[1]+1)
a[-1] = last
else:
last = (ai, 1)
a.append(last)
if last[1] == k:
a.pop()
last = a[-1]
a.pop(0)
s1 = 0
while len(a) > 0 and a[0][0] == a[-1][0]:
if len(a) == 1:
s = a[0][1] * m
r1 = s % k
if r1 == 0:
print(s1 % k)
else:
print(r1 + s1)
return
join = a[0][1] + a[-1][1]
if join < k:
break
elif join % k == 0:
s1 += join
a.pop()
a.pop(0)
else:
s1 += (join // k) * k
a[0] = (a[0][0], join % k)
a.pop()
break
s = 0
for ai in a:
s += ai[1]
print(s*m + s1)
if __name__ == "__main__":
main()
```
| 7,226 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This time the Berland Team Olympiad in Informatics is held in a remote city that can only be reached by one small bus. Bus has n passenger seats, seat i can be occupied only by a participant from the city ai.
Today the bus has completed m trips, each time bringing n participants. The participants were then aligned in one line in the order they arrived, with people from the same bus standing in the order of their seats (i. e. if we write down the cities where the participants came from, we get the sequence a1, a2, ..., an repeated m times).
After that some teams were formed, each consisting of k participants form the same city standing next to each other in the line. Once formed, teams left the line. The teams were formed until there were no k neighboring participants from the same city.
Help the organizers determine how many participants have left in the line after that process ended. We can prove that answer doesn't depend on the order in which teams were selected.
Input
The first line contains three integers n, k and m (1 ≤ n ≤ 105, 2 ≤ k ≤ 109, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105), where ai is the number of city, person from which must take seat i in the bus.
Output
Output the number of remaining participants in the line.
Examples
Input
4 2 5
1 2 3 1
Output
12
Input
1 9 10
1
Output
1
Input
3 2 10
1 2 1
Output
0
Note
In the second example, the line consists of ten participants from the same city. Nine of them will form a team. At the end, only one participant will stay in the line.
Tags: data structures, implementation
Correct Solution:
```
#reference sol:-31772413
r=lambda:map(int,input().split())
n,k,m=r()
a=list(r())
stck=[]
for i in range(n):
if len(stck)==0 or stck[-1][0]!=a[i]:
stck.append([a[i],1])
else:
stck[-1][1]+=1
if stck[-1][1]==k:
stck.pop()
rem=0
strt,end=0,len(stck)-1
if m > 1:
while end-strt+1 > 1 and stck[strt][0]==stck[end][0]:
join=stck[strt][1]+stck[end][1]
if join < k:
break
elif join % k==0:
rem+=join
strt+=1
end-=1
else:
stck[strt][1]=join % k
stck[end][1]=0
rem+=(join//k)*k
tr=0
slen=end-strt+1
for el in stck[:slen]:
tr+=el[1]
if slen==0:
print(0)
elif slen==1:
r=(stck[strt][1]*m)%k
if r==0:
print(0)
else:
print(r+rem)
else:
print(tr*m+rem)
```
| 7,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This time the Berland Team Olympiad in Informatics is held in a remote city that can only be reached by one small bus. Bus has n passenger seats, seat i can be occupied only by a participant from the city ai.
Today the bus has completed m trips, each time bringing n participants. The participants were then aligned in one line in the order they arrived, with people from the same bus standing in the order of their seats (i. e. if we write down the cities where the participants came from, we get the sequence a1, a2, ..., an repeated m times).
After that some teams were formed, each consisting of k participants form the same city standing next to each other in the line. Once formed, teams left the line. The teams were formed until there were no k neighboring participants from the same city.
Help the organizers determine how many participants have left in the line after that process ended. We can prove that answer doesn't depend on the order in which teams were selected.
Input
The first line contains three integers n, k and m (1 ≤ n ≤ 105, 2 ≤ k ≤ 109, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105), where ai is the number of city, person from which must take seat i in the bus.
Output
Output the number of remaining participants in the line.
Examples
Input
4 2 5
1 2 3 1
Output
12
Input
1 9 10
1
Output
1
Input
3 2 10
1 2 1
Output
0
Note
In the second example, the line consists of ten participants from the same city. Nine of them will form a team. At the end, only one participant will stay in the line.
Submitted Solution:
```
import queue
def readTuple():
return input().split()
def readInts():
return tuple(map(int, readTuple()))
def solve():
n, k, m = readInts()
nums = []
cnt = 0
for i in readInts():
if nums and i == nums[-1][0]:
nums[-1][1] +=1
if nums[-1][1] == k:
nums.pop()
continue
nums.append([i,1])
i, j = 0, len(nums)-1
comm = 0
while i<j:
if nums[i][0] == nums[j][0] \
and nums[i][1]+nums[j][1] <= k:
if nums[i][1]+nums[j][1] == k:
comm +=1
else:
break
i+=1
j-=1
mid = len(nums)-2*comm
prefix_sum = sum(map(lambda x: x[1], nums[:comm]))
middle_sum = sum(map(lambda x: x[1], nums[comm:comm+mid]))
suffix_sum = sum(map(lambda x: x[1], nums[comm+mid:]))
all_sum = (prefix_sum+suffix_sum+middle_sum)*m
# print(nums)
# print("prefix: ", comm, "SUM: ", prefix_sum)
# print("mid: ", mid, "SUM: ", middle_sum)
# print("suffix: ", comm, "SUM: ", suffix_sum)
# print("ALL: ", all_sum)
# subtract perfect matches
all_sum -= (prefix_sum+suffix_sum)*(m-1)
if mid == 0:
all_sum = 0
elif mid == 1:
if (middle_sum*m)%k == 0:
all_sum = 0
else:
all_sum -= middle_sum*m
all_sum += (middle_sum*m)%k
else:
if nums[comm][0] == nums[-comm-1][0] \
and nums[comm][1]+nums[-comm-1][1] > k:
all_sum -= k*(m-1)
print(all_sum)
if __name__ == '__main__':
solve()
```
No
| 7,228 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This time the Berland Team Olympiad in Informatics is held in a remote city that can only be reached by one small bus. Bus has n passenger seats, seat i can be occupied only by a participant from the city ai.
Today the bus has completed m trips, each time bringing n participants. The participants were then aligned in one line in the order they arrived, with people from the same bus standing in the order of their seats (i. e. if we write down the cities where the participants came from, we get the sequence a1, a2, ..., an repeated m times).
After that some teams were formed, each consisting of k participants form the same city standing next to each other in the line. Once formed, teams left the line. The teams were formed until there were no k neighboring participants from the same city.
Help the organizers determine how many participants have left in the line after that process ended. We can prove that answer doesn't depend on the order in which teams were selected.
Input
The first line contains three integers n, k and m (1 ≤ n ≤ 105, 2 ≤ k ≤ 109, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105), where ai is the number of city, person from which must take seat i in the bus.
Output
Output the number of remaining participants in the line.
Examples
Input
4 2 5
1 2 3 1
Output
12
Input
1 9 10
1
Output
1
Input
3 2 10
1 2 1
Output
0
Note
In the second example, the line consists of ten participants from the same city. Nine of them will form a team. At the end, only one participant will stay in the line.
Submitted Solution:
```
from collections import deque
n,k,m=map(int,input().split())
queue = deque()
A = list(map(int,input().split()))
for j in range(n):
if queue:
per = queue.pop()
if A[j] == per[0]:
per[1] +=1
if per[1] !=k:
queue.append(per)
else:
queue.append(per)
queue.append([A[j],1])
else:
queue.append([A[j],1])
lens = len(queue)
queue = list(queue)
#print(queue)
if lens ==0:
print(0)
elif m == 1:
ans =0
for j in range(lens):
ans+=queue[j][1]
print(ans)
elif lens%2==0:
p = 0
for j in range(lens//2):
if queue[j][0] == queue[-(j+1)][0] and queue[j][1] + queue[-(j+1)][1] == k:
p+=1
#print(p)
ans = 0
l=0
if p != lens//2:
for j in range(lens-1,lens-1-p,-1):
ans-=queue[j][1]
ans-=queue[-(j+1)][1]
ans*=(m-1)
for j in range(lens):
l+=queue[j][1]
ans+=l*m
print(ans)
#print(l*m)
else:
#print('huyznaet')
p = 0
for j in range(lens//2):
if queue[j][0] == queue[-(j+1)][0] and queue[j][1] + queue[-(j+1)][1] == k:
p+=1
#print(p)
ans = 0
l=0
if p != lens//2:
for j in range(lens-1,lens-1-p,-1):
ans-=queue[j][1]
ans-=queue[-(j+1)][1]
ans*=(m-1)
for j in range(lens):
l+=queue[j][1]
ans+=l*m
print(ans)
#print(pizda)
else:
if(m*queue[lens//2][1])%k==0:
print(0)
else:
l=0
for j in range(lens):
l+=queue[j][1]
l-= queue[lens//2][1]
l+=(m*queue[lens//2][1])%k
print(l)
#print(l*m)
```
No
| 7,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This time the Berland Team Olympiad in Informatics is held in a remote city that can only be reached by one small bus. Bus has n passenger seats, seat i can be occupied only by a participant from the city ai.
Today the bus has completed m trips, each time bringing n participants. The participants were then aligned in one line in the order they arrived, with people from the same bus standing in the order of their seats (i. e. if we write down the cities where the participants came from, we get the sequence a1, a2, ..., an repeated m times).
After that some teams were formed, each consisting of k participants form the same city standing next to each other in the line. Once formed, teams left the line. The teams were formed until there were no k neighboring participants from the same city.
Help the organizers determine how many participants have left in the line after that process ended. We can prove that answer doesn't depend on the order in which teams were selected.
Input
The first line contains three integers n, k and m (1 ≤ n ≤ 105, 2 ≤ k ≤ 109, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105), where ai is the number of city, person from which must take seat i in the bus.
Output
Output the number of remaining participants in the line.
Examples
Input
4 2 5
1 2 3 1
Output
12
Input
1 9 10
1
Output
1
Input
3 2 10
1 2 1
Output
0
Note
In the second example, the line consists of ten participants from the same city. Nine of them will form a team. At the end, only one participant will stay in the line.
Submitted Solution:
```
n,k,m = input().strip().split()
n = int(n)
k = int(k)
m = int(m)
a = list(map(int, input().strip().split()))
x = []
kol = 1
for i in range(n):
if i ==0:
x.append((a[i],kol))
else:
if a[i] == a[i-1]:
kol +=1
x.append((a[i],kol))
else:
kol = 1
x.append((a[i],kol))
if n>1:
y = []
for i in range(n+1):
y.append(1)
pre = 0
nex = 1
z = {}
tup = {}
tup[0] =1
kol =1
while nex <n:
if nex not in tup:
tup[nex] = nex-1
if a[nex] == a[pre]:
y[nex] = y[pre] + kol
kol = kol + 1
else:
kol = 1
pre = nex
if y[nex] ==k:
kol = 1
z[pre- y[pre] +1] = nex
if pre ==0:
pre = nex
nex = nex + 1
else:
pre = tup[pre - y[pre] + 1]
tup[nex + 1] = nex - y[nex]
nex = nex + 1
i = 0
p =[]
while i <= n-1:
if i in z:
i = z[i] +1
else:
p.append(a[i])
i = i +1
a = p[:]
n = len(a)
i = n-1
s = 2 * n
l=0
if len(a) ==0:
print(0)
else:
if k>=n:
for i in range(n):
if (i>0 and a[i]!=a[i-1]):
l =1
break
if l==1:
print(n*m)
else:
if k <= n*m:
print((n *m) % k)
else:
print(n*m)
else:
l=0
for i in range(n//2):
if a[i] != a[n - i-1]:
l = 1
if l==0:
print(0)
else:
s = 0
i = n-1
while i >= n //2 - 1:
if x[i] == x[n -1 - i + x[i][1] - 1] and x[i][1] * 2 >=k:
if i !=n -1 - i + x[i][1] - 1:
s += ((x[i][1] *2 //k) * k) * (m-1)
else:
s+= x[i][1] * m
i = i - ((x[i][1] *2 //k) * k)//2
else:
i = -1
break
s = n*m-s
print(s)
```
No
| 7,230 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This time the Berland Team Olympiad in Informatics is held in a remote city that can only be reached by one small bus. Bus has n passenger seats, seat i can be occupied only by a participant from the city ai.
Today the bus has completed m trips, each time bringing n participants. The participants were then aligned in one line in the order they arrived, with people from the same bus standing in the order of their seats (i. e. if we write down the cities where the participants came from, we get the sequence a1, a2, ..., an repeated m times).
After that some teams were formed, each consisting of k participants form the same city standing next to each other in the line. Once formed, teams left the line. The teams were formed until there were no k neighboring participants from the same city.
Help the organizers determine how many participants have left in the line after that process ended. We can prove that answer doesn't depend on the order in which teams were selected.
Input
The first line contains three integers n, k and m (1 ≤ n ≤ 105, 2 ≤ k ≤ 109, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105), where ai is the number of city, person from which must take seat i in the bus.
Output
Output the number of remaining participants in the line.
Examples
Input
4 2 5
1 2 3 1
Output
12
Input
1 9 10
1
Output
1
Input
3 2 10
1 2 1
Output
0
Note
In the second example, the line consists of ten participants from the same city. Nine of them will form a team. At the end, only one participant will stay in the line.
Submitted Solution:
```
# -*- coding: utf-8 -*-
import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
"""
created by shhuan at 2017/10/28 16:57
"""
N, K, M = map(int, input().split())
A = [int(x) for x in input().split()]
def group(a, k):
if not a:
return []
if len(a) < k:
return a
ans = []
p = a[0]
c = 1
for v in a[1:]:
if v == p:
c += 1
if c == k:
c = 0
else:
ans += [p] * c
p = v
c = 1
ans += [p] * c
return ans
A = group(A, K)
rem = []
found = True
while A and found:
found = False
if len(set(A)) == 1:
A = [A[0]] * ((len(A)*M) % K)
M %= K
break
else:
if K > 2*len(A):
break
i = 2
a = group(A*i, K)
if a and len(a) != len(A)*i:
rem = A * (M%i) + rem
A = a
M //= i
found = True
break
A = group(A*M+rem, K)
if A:
print(len(A))
else:
print(0)
```
No
| 7,231 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a connected undirected graph with n vertices and m edges. The vertices are enumerated from 1 to n.
You are given n integers c1, c2, ..., cn, each of them is between - n and n, inclusive. It is also guaranteed that the parity of cv equals the parity of degree of vertex v. The degree of a vertex is the number of edges connected to it.
You are to write a weight between - 2·n2 and 2·n2 (inclusive) on each edge in such a way, that for each vertex v the sum of weights on edges connected to this vertex is equal to cv, or determine that this is impossible.
Input
The first line contains two integers n and m (2 ≤ n ≤ 105, n - 1 ≤ m ≤ 105) — the number of vertices and the number of edges.
The next line contains n integers c1, c2, ..., cn ( - n ≤ ci ≤ n), where ci is the required sum of weights of edges connected to vertex i. It is guaranteed that the parity of ci equals the parity of degree of vertex i.
The next m lines describe edges of the graph. The i-th of these lines contains two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi), meaning that the i-th edge connects vertices ai and bi.
It is guaranteed that the given graph is connected and does not contain loops and multiple edges.
Output
If there is no solution, print "NO".
Otherwise print "YES" and then m lines, the i-th of them is the weight of the i-th edge wi ( - 2·n2 ≤ wi ≤ 2·n2).
Examples
Input
3 3
2 2 2
1 2
2 3
1 3
Output
YES
1
1
1
Input
4 3
-1 0 2 1
1 2
2 3
3 4
Output
YES
-1
1
1
Input
6 6
3 5 5 5 1 5
1 4
3 2
4 3
4 5
3 5
5 6
Output
YES
3
5
3
-1
-3
5
Input
4 4
4 4 2 4
1 2
2 3
3 4
4 1
Output
NO
Tags: constructive algorithms, dfs and similar, graphs
Correct Solution:
```
def divisors(M):
d=[]
i=1
while M>=i**2:
if M%i==0:
d.append(i)
if i**2!=M:
d.append(M//i)
i=i+1
return d
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
def eratosthenes(n):
res=[0 for i in range(n+1)]
prime=set([])
for i in range(2,n+1):
if not res[i]:
prime.add(i)
for j in range(1,n//i+1):
res[i*j]=1
return prime
def factorization(n):
res=[]
for p in prime:
if n%p==0:
while n%p==0:
n//=p
res.append(p)
if n!=1:
res.append(n)
return res
def euler_phi(n):
res = n
for x in range(2,n+1):
if x ** 2 > n:
break
if n%x==0:
res = res//x * (x-1)
while n%x==0:
n //= x
if n!=1:
res = res//n * (n-1)
return res
def ind(b,n):
res=0
while n%b==0:
res+=1
n//=b
return res
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 3, 5, 7, 11, 13, 17]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = (y * y) % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
from math import gcd
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i*i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += 1 + i % 2
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(n):
res = [1]
prime = primeFactor(n)
for p in prime:
newres = []
for d in res:
for j in range(prime[p]+1):
newres.append(d*p**j)
res = newres
res.sort()
return res
def xorfactorial(num):
if num==0:
return 0
elif num==1:
return 1
elif num==2:
return 3
elif num==3:
return 0
else:
x=baseorder(num)
return (2**x)*((num-2**x+1)%2)+function(num-2**x)
def xorconv(n,X,Y):
if n==0:
res=[(X[0]*Y[0])%mod]
return res
x=[X[i]+X[i+2**(n-1)] for i in range(2**(n-1))]
y=[Y[i]+Y[i+2**(n-1)] for i in range(2**(n-1))]
z=[X[i]-X[i+2**(n-1)] for i in range(2**(n-1))]
w=[Y[i]-Y[i+2**(n-1)] for i in range(2**(n-1))]
res1=xorconv(n-1,x,y)
res2=xorconv(n-1,z,w)
former=[(res1[i]+res2[i])*inv for i in range(2**(n-1))]
latter=[(res1[i]-res2[i])*inv for i in range(2**(n-1))]
former=list(map(lambda x:x%mod,former))
latter=list(map(lambda x:x%mod,latter))
return former+latter
def merge_sort(A,B):
pos_A,pos_B = 0,0
n,m = len(A),len(B)
res = []
while pos_A < n and pos_B < m:
a,b = A[pos_A],B[pos_B]
if a < b:
res.append(a)
pos_A += 1
else:
res.append(b)
pos_B += 1
res += A[pos_A:]
res += B[pos_B:]
return res
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
self.group = N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
stack = [x]
while self._parent[stack[-1]]!=stack[-1]:
stack.append(self._parent[stack[-1]])
for v in stack:
self._parent[v] = stack[-1]
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
self.group -= 1
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
class WeightedUnionFind():
def __init__(self,N):
self.parent = [i for i in range(N)]
self.size = [1 for i in range(N)]
self.val = [0 for i in range(N)]
self.flag = True
self.edge = [[] for i in range(N)]
def dfs(self,v,pv):
stack = [(v,pv)]
new_parent = self.parent[pv]
while stack:
v,pv = stack.pop()
self.parent[v] = new_parent
for nv,w in self.edge[v]:
if nv!=pv:
self.val[nv] = self.val[v] + w
stack.append((nv,v))
def unite(self,x,y,w):
if not self.flag:
return
if self.parent[x]==self.parent[y]:
self.flag = (self.val[x] - self.val[y] == w)
return
if self.size[self.parent[x]]>self.size[self.parent[y]]:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[x] += self.size[y]
self.val[y] = self.val[x] - w
self.dfs(y,x)
else:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[y] += self.size[x]
self.val[x] = self.val[y] + w
self.dfs(x,y)
class Dijkstra():
class Edge():
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
def __init__(self, V):
self.G = [[] for i in range(V)]
self._E = 0
self._V = V
@property
def E(self):
return self._E
@property
def V(self):
return self._V
def add_edge(self, _from, _to, _cost):
self.G[_from].append(self.Edge(_to, _cost))
self._E += 1
def shortest_path(self, s):
import heapq
que = []
d = [10**15] * self.V
d[s] = 0
heapq.heappush(que, (0, s))
while len(que) != 0:
cost, v = heapq.heappop(que)
if d[v] < cost: continue
for i in range(len(self.G[v])):
e = self.G[v][i]
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost
heapq.heappush(que, (d[e.to], e.to))
return d
#Z[i]:length of the longest list starting from S[i] which is also a prefix of S
#O(|S|)
def Z_algorithm(s):
N = len(s)
Z_alg = [0]*N
Z_alg[0] = N
i = 1
j = 0
while i < N:
while i+j < N and s[j] == s[i+j]:
j += 1
Z_alg[i] = j
if j == 0:
i += 1
continue
k = 1
while i+k < N and k + Z_alg[k]<j:
Z_alg[i+k] = Z_alg[k]
k += 1
i += k
j -= k
return Z_alg
class BIT():
def __init__(self,n,mod=0):
self.BIT = [0]*(n+1)
self.num = n
self.mod = mod
def query(self,idx):
res_sum = 0
mod = self.mod
while idx > 0:
res_sum += self.BIT[idx]
if mod:
res_sum %= mod
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
mod = self.mod
while idx <= self.num:
self.BIT[idx] += x
if mod:
self.BIT[idx] %= mod
idx += idx&(-idx)
return
class dancinglink():
def __init__(self,n,debug=False):
self.n = n
self.debug = debug
self._left = [i-1 for i in range(n)]
self._right = [i+1 for i in range(n)]
self.exist = [True for i in range(n)]
def pop(self,k):
if self.debug:
assert self.exist[k]
L = self._left[k]
R = self._right[k]
if L!=-1:
if R!=self.n:
self._right[L],self._left[R] = R,L
else:
self._right[L] = self.n
elif R!=self.n:
self._left[R] = -1
self.exist[k] = False
def left(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._left[res]
if res==-1:
break
k -= 1
return res
def right(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._right[res]
if res==self.n:
break
k -= 1
return res
class SparseTable():
def __init__(self,A,merge_func,ide_ele):
N=len(A)
n=N.bit_length()
self.table=[[ide_ele for i in range(n)] for i in range(N)]
self.merge_func=merge_func
for i in range(N):
self.table[i][0]=A[i]
for j in range(1,n):
for i in range(0,N-2**j+1):
f=self.table[i][j-1]
s=self.table[i+2**(j-1)][j-1]
self.table[i][j]=self.merge_func(f,s)
def query(self,s,t):
b=t-s+1
m=b.bit_length()-1
return self.merge_func(self.table[s][m],self.table[t-2**m+1][m])
class BinaryTrie:
class node:
def __init__(self,val):
self.left = None
self.right = None
self.max = val
def __init__(self):
self.root = self.node(-10**15)
def append(self,key,val):
pos = self.root
for i in range(29,-1,-1):
pos.max = max(pos.max,val)
if key>>i & 1:
if pos.right is None:
pos.right = self.node(val)
pos = pos.right
else:
pos = pos.right
else:
if pos.left is None:
pos.left = self.node(val)
pos = pos.left
else:
pos = pos.left
pos.max = max(pos.max,val)
def search(self,M,xor):
res = -10**15
pos = self.root
for i in range(29,-1,-1):
if pos is None:
break
if M>>i & 1:
if xor>>i & 1:
if pos.right:
res = max(res,pos.right.max)
pos = pos.left
else:
if pos.left:
res = max(res,pos.left.max)
pos = pos.right
else:
if xor>>i & 1:
pos = pos.right
else:
pos = pos.left
if pos:
res = max(res,pos.max)
return res
def solveequation(edge,ans,n,m):
#edge=[[to,dire,id]...]
x=[0]*m
used=[False]*n
for v in range(n):
if used[v]:
continue
y = dfs(v)
if y!=0:
return False
return x
def dfs(v):
used[v]=True
r=ans[v]
for to,dire,id in edge[v]:
if used[to]:
continue
y=dfs(to)
if dire==-1:
x[id]=y
else:
x[id]=-y
r+=y
return r
class SegmentTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
self.size = n
for i in range(n):
self.tree[self.num + i] = init_val[i]
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
if r==self.size:
r = self.num
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
def bisect_l(self,l,r,x):
l += self.num
r += self.num
Lmin = -1
Rmin = -1
while l<r:
if l & 1:
if self.tree[l] <= x and Lmin==-1:
Lmin = l
l += 1
if r & 1:
if self.tree[r-1] <=x:
Rmin = r-1
l >>= 1
r >>= 1
if Lmin != -1:
pos = Lmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
elif Rmin != -1:
pos = Rmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
else:
return -1
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import gcd,log
input = lambda :sys.stdin.readline().rstrip()
mi = lambda :map(int,input().split())
li = lambda :list(mi())
n,m = mi()
c = li()
edge = [[] for i in range(n)]
for i in range(m):
u,v = mi()
edge[u-1].append((v-1,i))
edge[v-1].append((u-1,i))
parent = [(-1,-1) for v in range(n)]
tree_edge = [[] for v in range(n)]
depth = [0 for v in range(n)]
special = None
stack = [0]
cnt = [0 for v in range(n)]
while stack:
v = stack[-1]
if cnt[v]==len(edge[v]):
stack.pop()
else:
nv,idx = edge[v][cnt[v]]
cnt[v] += 1
if nv==0 or parent[nv]!=(-1,-1):
if depth[nv] < depth[v] and (depth[v]-depth[nv])%2==0 and not special:
special = (v,nv,idx)
else:
parent[nv] = (v,idx)
depth[nv] = depth[v] + 1
tree_edge[v].append((nv,idx))
stack.append(nv)
if not special:
even = 0
odd = 0
for v in range(n):
if depth[v]&1:
odd += c[v]
else:
even += c[v]
if odd!=even:
print("NO")
else:
print("YES")
deq = deque([0])
topo = []
while deq:
v = deq.popleft()
topo.append(v)
for nv,idx in tree_edge[v]:
deq.append(nv)
ans = [0 for i in range(m)]
for v in topo[::-1]:
if v==0:
continue
_,i = parent[v]
ans[i] = c[v]
for nv,idx in tree_edge[v] :
ans[i] -= ans[idx]
print(*ans,sep="\n")
else:
print("YES")
even = 0
odd = 0
for v in range(n):
if depth[v]&1:
odd += c[v]
else:
even += c[v]
ans = [0 for i in range(m)]
v,nv,idx = special
if depth[v]&1:
ans[idx] -= (even-odd)//2
c[v] += (even-odd)//2
c[nv] += (even-odd)//2
else:
ans[idx] -= (odd-even)//2
c[v] += (odd-even)//2
c[nv] += (odd-even)//2
#print(ans)
deq = deque([0])
topo = []
while deq:
v = deq.popleft()
topo.append(v)
for nv,idx in tree_edge[v]:
deq.append(nv)
for v in topo[::-1]:
if v==0:
continue
_,i = parent[v]
ans[i] = c[v]
for nv,idx in tree_edge[v] :
ans[i] -= ans[idx]
print(*ans,sep="\n")
```
| 7,232 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
n,m=map(int,input().split())
t=set(input()for _ in [0]*n)
print(['No','Yes'][all(sum(c=='#'for c in s)<2for s in zip(*t))])
```
| 7,233 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
n,m = map(int, input().split())
r = set()
c = set()
ss=[]
for i in range(n):
s = input()
ss.append(s)
for i in range(n):
s1 = set()
for j in range(m):
if ss[i][j] == '#':
s1.add(j)
for j in range(n):
s2 = set()
for k in range(m):
if ss[j][k] == '#':
s2.add(k)
isi=len(s1.intersection(s2))
if isi != 0 and (isi != len(s1) or isi != len(s2)):
print('No')
exit()
for i in range(m):
s1 = set()
for j in range(n):
if ss[j][i] == '#':
s1.add(j)
for j in range(m):
s2 = set()
for k in range(n):
if ss[k][j] == '#':
s2.add(k)
isi=len(s1.intersection(s2))
if isi != 0 and (isi != len(s1) or isi != len(s2)):
print('No')
exit()
print('Yes')
```
| 7,234 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
# python3
def readline(): return tuple(map(int, input().split()))
def main():
n, m = readline()
unique_rows = list()
first_occ = [None] * m
while n:
n -= 1
row = input()
saved = None
for (i, char) in enumerate(row):
if char == '#':
if first_occ[i] is not None:
if row != unique_rows[first_occ[i]]:
return False
else:
break
else:
if saved is None:
unique_rows.append(row)
saved = len(unique_rows) - 1
first_occ[i] = saved
else:
assert char == '.'
return True
print("Yes" if main() else "No")
```
| 7,235 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
class CDisjointSet(object):
def __init__(self):
self.leader = {} # maps a member to the group's leader
self.group = {} # maps a group leader to the group (which is a set)
def Add(self, a, b):
leadera = self.leader.get(a)
leaderb = self.leader.get(b)
if leadera is not None:
if leaderb is not None:
if leadera == leaderb: return # nothing to do
groupa = self.group[leadera]
groupb = self.group[leaderb]
if len(groupa) < len(groupb):
a, leadera, groupa, b, leaderb, groupb = b, leaderb, groupb, a, leadera, groupa
groupa |= groupb
del self.group[leaderb]
for k in groupb:
self.leader[k] = leadera
else:
self.group[leadera].add(b)
self.leader[b] = leadera
else:
if leaderb is not None:
self.group[leaderb].add(a)
self.leader[a] = leaderb
else:
self.leader[a] = self.leader[b] = a
self.group[a] = set([a, b])
def Judge():
#[1]
ds = CDisjointSet()
n, m = map(int, input().split())
arr = list()
for i in range(n):
arr.append(input())
for i in range(n):
for j in range(m):
if arr[i][j] == '#':
ds.Add(i+1, 101+j)
#[2]
for vs in ds.group.values():
rs = list()
cs = list()
for v in vs:
if v < 100:
rs.append(v-1)
else:
cs.append(v-101)
for i in rs:
for j in range(m):
if j in cs and arr[i][j] == '.':
return False
if j not in cs and arr[i][j] == '#':
return False
#[3]
return True
print('Yes') if Judge() else print('No')
```
| 7,236 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
t=set(input()for _ in [0]*int(input().split()[0]))
print(['No','Yes'][all(sum(c<'.'for c in s)<2for s in zip(*t))])
# Made By Mostafa_Khaled
```
| 7,237 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
n, m = map(int, input().split())
p = [list(input()) for _ in range(n)]
for i in range(n):
column = []
for j in range(m):
if p[i][j] == '#':
column.append(j)
st1 = ''
for pos, el in enumerate(column):
st = ''
for k in range(n):
st += p[k][el]
if pos == 0:
st1 = st
elif st1 != st:
print('No')
break
else:
continue
break
else:
print('Yes')
```
| 7,238 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
n,m=map(int, input().split())
a=[]
for i in range(n): a.append(input())
for i in range(n):
for j in range(i+1,n):
eqv, no_inter=True, True
for z in range(m):
if a[i][z]!=a[j][z]: eqv=False
if a[i][z]==a[j][z]=="#": no_inter=False
if eqv==no_inter==False:
print("No")
exit()
print("Yes")
```
| 7,239 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
import sys
n, m = [int(i) for i in input().split(" ")]
grid = []
columns_idx = set()
lines_used = set()
for _ in range(n):
line = input()
grid.append(line)
for line in grid:
if line not in lines_used:
lines_used.add(line)
for i,c in enumerate(line):
if c=='#':
if i in columns_idx:
print("No")
sys.exit()
else:
columns_idx.add(i)
print("Yes")
```
| 7,240 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
import sys
n,m = [int(x) for x in input().split(' ')]
a=[]
for i in range(n):
b=[]
s = input().strip()
for j in range(m):
if s[j]=='#':
b.append(j)
if b not in a:
a.append(b)
c=[0]*m
ans=True
#print(a)
for i in a:
for j in i:
c[j]+=1
if c[j]>1:
ans=False
break
if ans:
print("Yes")
else:
print("No")
```
Yes
| 7,241 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
#!/usr/bin/env python3
import sys
[n, m] = map(int, sys.stdin.readline().strip().split())
table = [sys.stdin.readline().strip() for _ in range(n)]
first_to_row = dict()
poss = True
for row in table:
first = row.find('#')
if first in first_to_row:
if first_to_row[first] != row:
poss = False
break
else:
first_to_row[first] = row
if poss:
counts = [False for _ in range(m)]
for row in first_to_row.values():
for i in range(m):
if row[i] == '#':
if counts[i]:
poss = False
break
counts[i] = True
if not poss:
break
if poss:
print ('Yes')
else:
print ('No')
```
Yes
| 7,242 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
BLACK, WHITE = "#", "."
n, m = list(map(int, input().split()))
blacks = [{i for i, c in enumerate(input()) if c == BLACK} for i in range(n)]
answer = "Yes"
for i in range(n):
for j in range(i):
if blacks[i] & blacks[j] and blacks[i] != blacks[j]:
answer = "No"
print(answer)
```
Yes
| 7,243 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
from itertools import product
n,m=map(int,input().split())
l=[]
satir={i:[] for i in range(n)}
sutun={i:[] for i in range(m)}
for i in range(n):
l.append(list(input()))
g=[["."]*m for _ in range(n)]
for i in range(n):
for a in range(m):
if l[i][a] == "#":
satir[i].append(a)
sutun[a].append(i)
for i in satir:
sa=set()
sa.add(i)
su=set()
for a in satir[i]:
su.add(a)
for k in sutun[a]:
sa.add(k)
res=product(sa,su)
for a,b in res:
g[a][b]="#"
if g==l:
print("Yes")
else:
print("No")
```
Yes
| 7,244 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
row, column = map(int,input().strip().split())
rset = set()
cset = set()
flag = True
for i in range(row):
line = input().strip()
if line in rset:
continue
for j in range(column):
if line[j] == '.':
continue
if line[j] in cset:
flag = False
else:
cset.add(line[j])
rset.add(line)
if flag:
print("Yes")
else:
print("No")
```
No
| 7,245 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
n, m = list(map(int, input().split()))
rows = []
for i in range(m):
rows.append([])
for i in range(n):
print(rows)
row = input()
indices = [j for j, x in enumerate(row) if x == "#"]
rowcheck = [rows[x] for x in indices]
for j in rowcheck:
if j != rowcheck[0]:
print('NO')
exit()
for j in indices:
rows[j] = indices
print('YES')
```
No
| 7,246 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
n, m = map(int, input().strip().split())
M = list()
for _ in range(n):
M.append(input().strip())
def fail():
print('No')
exit(0)
vis = [[False] * m for _ in range(n)]
rc = set()
for i in range(n):
for j in range(m):
if (not vis[i][j]) and M[i][j] == '#':
cols = list()
for jj in range(m):
if M[i][jj] != '#':
continue
if vis[i][jj]:
fail()
cols.append(jj)
rows = list()
for ii in range(n):
if M[ii][j] != '#':
continue
if vis[ii][j]:
fail()
rows.append(ii)
for r in rows:
for c in cols:
if M[r][c] != '#' or (r*m + c) in rc:
fail()
vis[r][c] = True
for r in rows:
for c in cols:
rc.add(r*m + c)
print('Yes')
```
No
| 7,247 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
n, m = map(int, input().split())
array = []
state = True
for i in range(n):
string = input()
if string.find('##')!=-1:
state = False
if state==True:
print('Yes')
else:
print('No')
```
No
| 7,248 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Tags: implementation
Correct Solution:
```
'''
//Abdurasul
#include<bits/stdc++.h>
using namespace std;
/**
##################################
## ___________________ ##
## | | Abdurasul... | ##
## |▓| _ _ | ##
## |▓| |_||_| | ##
## |▓| |_||_| | ##
## |▓| Microsoft | ##
## |▓|_________________| ##
## |/\ <><><><><><><><> \ ##
## \ \ <><><><><><<<>>> \ ##
## \ \ <<><><><><><><>> \ ##
## \ \__________________\ ##
## \|___________________| ##
##################################
**/
void seti(){
int n, m;
cin >> n >> m;
if(n % 2 == 0 && m % 2 == 0 && n % m == 0) cout << "YES";
else if(n % 2 == 1 && m % 2 == 1 && n % m == 0) cout << "YES";
else if(n % m == 0) cout << "YES";
else cout << "NO";
cout << endl;
}
int main(){
int n = 1;
//freopen("a.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
cin >> n;
for(int i = 0; i < n; i++){
seti();
}
return 0;
}
'''
n = int(input())
a = list(map(int,input().split()))
for i in range(n - 1):
if max(a[i],a[i + 1]) - min(a[i], a[i + 1]) > 1:
print("NO")
exit()
print("YES")
```
| 7,249 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Tags: implementation
Correct Solution:
```
_=input()
l = list(map(int, input().split()))
ans=True
for i in range(1, len(l)):
if abs(l[i]-l[i-1])>=2:
ans=False
break
if ans:
print('YES')
else:
print('NO')
```
| 7,250 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Tags: implementation
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
b=list(sorted(a,reverse=True))
c=[]
for i in range(n):
for j in range(n-i-1):
if abs(a[j]-a[j+1])>=2:
print('NO')
exit()
q=max(a)
qi=a.index(q)
c.append(q)
for j in range(i):
if abs(c[j]-c[j+1])>=2:
print('NO')
exit()
del a[qi]
print('YES')
```
| 7,251 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Tags: implementation
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
s=set()
if n==1:
print("YES")
exit(0)
for i in range(1,n):
s.add(abs(a[i]-a[i-1]))
if max(s) >=2:
print("NO")
else:
print("YES")
```
| 7,252 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Tags: implementation
Correct Solution:
```
n=int(input())
l=[int(s) for s in input().split()]
z=0
f=0
d=0
e=0
while(len(l)>0):
a=max(l)
if l.index(a)!=0:
d=a-l[l.index(a)-1]
if l.index(a)!=len(l)-1:
e=a-l[l.index(a)+1]
if d>=2:
z=1
break
if e>=2:
f=1
break
else:
l.remove(a)
if z==1 or f==1:
print("NO")
else:
print("YES")
```
| 7,253 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Tags: implementation
Correct Solution:
```
n = int(input())
a = [int(n) for n in input().split()]
answer = True
if n != 1:
for i in range(0, n-1):
#print(a[i], a[i+1])
if max(a[i], a[i+1]) - min(a[i+1], a[i]) >= 2:
answer = False
break
if answer:
print("YES")
else:
print("NO")
else:
print("YES")
```
| 7,254 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Tags: implementation
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
ans=True
for i in range(1,n):
if abs(a[i]-a[i-1])>1: ans=False
if ans: print("YES")
else: print("NO")
```
| 7,255 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Tags: implementation
Correct Solution:
```
def sign(x):
if x > 0:
return 1
elif x == 0:
return 0
return -1
def bober(a, b):
return sign(a - b) * (a - b)
n = int(input())
a = list(map(int, input().split()))
mx = 0
for i in range(1, n):
mx = max(mx, bober(a[i], a[i - 1]))
if mx <= 1:
print('YES')
else:
print('NO')
```
| 7,256 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
print('NO' if any(abs(a[i]-a[i+1])>1 for i in range(n-1))else 'YES')
```
Yes
| 7,257 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Submitted Solution:
```
def check(a):
for i in range(len(a) - 1):
if a[i] > 0 and abs(a[i] - a[i + 1]) > 1:
return False
return True
n = int(input())
a = list(map(int, input().split()))
b = []
for i in range(n):
if not check(a):
print("NO")
break
ind = a.index(max(a))
b.append(a.pop(ind))
else:
print("YES")
```
Yes
| 7,258 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Submitted Solution:
```
n=int(input())
num=input().split()
flag=1
for i in range(n-1):
if abs((int(num[i]))-(int(num[i+1])))>=2:
flag=0
if flag==1:
print("YES")
else:
print("NO")
```
Yes
| 7,259 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Submitted Solution:
```
n = int(input())
stacks = list(map(int,input().strip().split(' ')))
while n:
for i in range(n-1):
if abs(stacks[i] - stacks[i+1]) >= 2:
print('NO')
exit(0)
stacks.remove(max(stacks))
n -= 1
print('YES')
```
Yes
| 7,260 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Submitted Solution:
```
def step(xs):
i = xs.pop(xs.index(max(xs)))
return xs + [i]
def f(xs):
while not all(xs[i] <= xs[i+1] for i in range(len(xs)-1)):
for x, y in zip(xs, xs[1:]):
if abs(y - x) > 1:
return False
xs = step(xs)
return True
if __name__ == "__main__":
input()
xs = list(map(int, input().split()))
print("YES" if f(xs) else "NO")
```
No
| 7,261 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Submitted Solution:
```
n=int(input())
flag=0
a=[int(x) for x in input().split()]
for i in range(0,len(a)):
for j in range(0,len(a)-1):
if(a[j]>=a[j+1]+2 or a[j]+2<=a[j+1]):
print("NO")
flag=1
break
c=a.index(max(a))
del a[c]
if(flag==0):
print("YES")
```
No
| 7,262 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Submitted Solution:
```
import sys
if __name__ == '__main__':
n = int(input())
arr = list(map(int, input().split()))
last_max = -1
for i in range(n):
max = 0
max_index = 0
for j in range(len(arr)):
if arr[j] > max:
max = arr[j]
max_index = j
if max_index < len(arr) - 1 and max_index > 0:
if abs(arr[max_index-1] - arr[max_index+1]) > 1:
print("NO")
sys.exit()
if last_max != -1:
if abs(max - last_max) > 1:
print("NO")
sys.exit()
last_max = max
arr.pop(max_index)
print("YES")
```
No
| 7,263 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}.
Submitted Solution:
```
import cmath
import sys
n = int(input())
a = [int(i) for i in input().split()]
ok = True
maxi = -1;
mini = 1000000;
for x in a:
maxi = max(maxi, x)
mini = max(mini, x)
if (maxi - mini < 2):
print('YES')
sys.exit()
for i in range(1, n):
if (a[i] < a[i - 1] or abs(a[i] - a[i - 1]) > 1):
print('NO')
ok = False
break
if (ok == True):
print('YES')
```
No
| 7,264 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kuro has recently won the "Most intelligent cat ever" contest. The three friends then decided to go to Katie's home to celebrate Kuro's winning. After a big meal, they took a small break then started playing games.
Kuro challenged Katie to create a game with only a white paper, a pencil, a pair of scissors and a lot of arrows (you can assume that the number of arrows is infinite). Immediately, Katie came up with the game called Topological Parity.
The paper is divided into n pieces enumerated from 1 to n. Shiro has painted some pieces with some color. Specifically, the i-th piece has color c_{i} where c_{i} = 0 defines black color, c_{i} = 1 defines white color and c_{i} = -1 means that the piece hasn't been colored yet.
The rules of the game is simple. Players must put some arrows between some pairs of different pieces in such a way that for each arrow, the number in the piece it starts from is less than the number of the piece it ends at. Also, two different pieces can only be connected by at most one arrow. After that the players must choose the color (0 or 1) for each of the unpainted pieces. The score of a valid way of putting the arrows and coloring pieces is defined as the number of paths of pieces of alternating colors. For example, [1 → 0 → 1 → 0], [0 → 1 → 0 → 1], [1], [0] are valid paths and will be counted. You can only travel from piece x to piece y if and only if there is an arrow from x to y.
But Kuro is not fun yet. He loves parity. Let's call his favorite parity p where p = 0 stands for "even" and p = 1 stands for "odd". He wants to put the arrows and choose colors in such a way that the score has the parity of p.
It seems like there will be so many ways which satisfy Kuro. He wants to count the number of them but this could be a very large number. Let's help him with his problem, but print it modulo 10^{9} + 7.
Input
The first line contains two integers n and p (1 ≤ n ≤ 50, 0 ≤ p ≤ 1) — the number of pieces and Kuro's wanted parity.
The second line contains n integers c_{1}, c_{2}, ..., c_{n} (-1 ≤ c_{i} ≤ 1) — the colors of the pieces.
Output
Print a single integer — the number of ways to put the arrows and choose colors so the number of valid paths of alternating colors has the parity of p.
Examples
Input
3 1
-1 0 1
Output
6
Input
2 1
1 0
Output
1
Input
1 1
-1
Output
2
Note
In the first example, there are 6 ways to color the pieces and add the arrows, as are shown in the figure below. The scores are 3, 3, 5 for the first row and 5, 3, 3 for the second row, both from left to right.
<image>
Tags: dp
Correct Solution:
```
n,p=map(int,input().split())
nums=[0]+list(map(int,input().split()))
mod=10**9+7
f=[[[[0]*2 for _ in range(2)] for _ in range(2)] for _ in range(n+1)]
_2=[0]*(n+1)
_2[0]=1
for i in range(1,n+1):
_2[i]=(_2[i-1]<<1)%mod
f[0][0][0][0]=1
if nums[1]!=0:
f[1][1][0][1]+=1
if nums[1]!=1:
f[1][1][1][0]+=1
for i in range(2,n+1):
for j in range(2):
for ob in range(2):
for ow in range(2):
qwq=f[i-1][j][ob][ow]
if nums[i]!=0:
if ob:
f[i][j][ob][ow]=(f[i][j][ob][ow]+qwq*_2[i-2])%mod
f[i][j^1][ob][ow|1]=(f[i][j^1][ob][ow|1]+qwq*_2[i-2])%mod
else:
f[i][j^1][ob][ow|1]=(f[i][j^1][ob][ow|1]+qwq*_2[i-1])%mod
if nums[i]!=1:
if ow:
f[i][j][ob][ow]=(f[i][j][ob][ow]+qwq*_2[i-2])%mod
f[i][j^1][ob|1][ow]=(f[i][j^1][ob|1][ow]+qwq*_2[i-2])%mod
else:
f[i][j^1][ob|1][ow]=(f[i][j^1][ob|1][ow]+qwq*_2[i-1])%mod
ans=0
for i in range(2):
for j in range(2):
ans=(ans+f[n][p][i][j])%mod
print(ans)
```
| 7,265 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Tags: dp
Correct Solution:
```
from __future__ import print_function
from queue import Queue
import sys
import math
import os.path
# CONFIG
sys.setrecursionlimit(10**9)
# LOG
def log(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
# INPUT
def ni():
return map(int, input().split())
def nio(offset):
return map(lambda x: int(x) + offset, input().split())
def nia():
return list(map(int, input().split()))
# CONVERT
def toString(aList, sep=" "):
return sep.join(str(x) for x in aList)
def mapInvertIndex(aList):
return {k: v for v, k in enumerate(aList)}
def countMap(arr):
m = {}
for x in arr:
m[x] = m.get(x,0) + 1
return m
def sortId(arr):
return sorted(range(arr), key=lambda k: arr[k])
# MAIN
n, k = ni()
c = nia()
f = nia()
h = [0] + (nia())
cc = countMap(c)
cf = countMap(f)
n1 = n+1
k1 = k+1
nk1 = n*k+1
dp = [[0]*nk1 for _ in range(n1)]
for ni in range(1,n1):
for ki in range(1,nk1):
mficount = min(k,ki) + 1
for kii in range(mficount):
# log(ni,ki, kii, dp[ni][ki], dp[ni-1][ki-kii] + h[kii])
dp[ni][ki] = max(dp[ni][ki], dp[ni-1][ki-kii] + h[kii])
# log(dp[ni])
# log(n,k)
# log("c", cc)
# log("f", cf)
# log("h", h)
# log(dp)
res = 0
for fk,fv in cf.items():
# log(fk, fv, cc.get(fk,0))
res += dp[fv][cc.get(fk,0)]
print(res)
```
| 7,266 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Tags: dp
Correct Solution:
```
def solve():
n, k = map(int, input().split())
c = list(map(int, input().split()))
f = list(map(int, input().split()))
h = list(map(int, input().split()))
cnt = {}
for i in c:
cnt[i] = cnt.get(i, 0) + 1
likecolor = {}
for i in range(n):
likecolor.setdefault(f[i], []).append(i)
cnt[f[i]] = cnt.get(f[i], 0)
ans = 0
for key, v in likecolor.items():
n1 = len(v)
if cnt[key] >= n1 * k:
ans += n1 * h[k - 1]
continue
dp = [[-float("INF")] * (cnt[key]+1) for _ in range(n1 + 1)]
dp[0][0] = 0
for i in range(n1):
j = i + 1
for e in range(cnt[key] + 1):
dp[j][e] = max(dp[j][e], dp[i][e])
for w in range(e + 1, min(cnt[key] + 1, e + k + 1)):
dp[j][w] = max(dp[i][e] + h[w - e - 1], dp[j][w])
ans += dp[n1][cnt[key]]
print(ans)
solve()
```
| 7,267 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Tags: dp
Correct Solution:
```
from __future__ import print_function
from queue import Queue
import sys
import math
import os.path
sys.setrecursionlimit(10**9)
def log(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
def ni():
return map(int, input().split())
def nio(offset):
return map(lambda x: int(x) + offset, input().split())
def nia():
return list(map(int, input().split()))
def toString(aList, sep=" "):
return sep.join(str(x) for x in aList)
def mapInvertIndex(aList):
return {k: v for v, k in enumerate(aList)}
def countMap(arr):
m = {}
for x in arr:
m[x] = m.get(x,0) + 1
return m
def sortId(arr):
return sorted(range(arr), key=lambda k: arr[k])
# MAIN
n, k = ni()
c = nia()
f = nia()
h = nia()
h.insert(0,0)
cc = countMap(c)
cf = countMap(f)
n1 = n+1
k1 = k+1
nk1 = n*k+1
dp = [[0]*nk1 for _ in range(n1)]
for ni in range(1,n1):
for ki in range(1,nk1):
mficount = min(k,ki) + 1
for kii in range(mficount):
dp[ni][ki] = max(dp[ni][ki], dp[ni-1][ki-kii] + h[kii])
res = 0
for fk,fv in cf.items():
res += dp[fv][cc.get(fk,0)]
print(res)
```
| 7,268 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Tags: dp
Correct Solution:
```
n,k= map(int,input().split(' '))
l= list(map(int,input().split(' ')))
f =list(map(int,input().split(' ')))
h=list(map(int,input().split(' ')))
d1=dict({(a,0) for a in f})
d2=dict({(a,0) for a in f})
for a in l:
if(a in d1):d1[a]+=1
for a in f:
d2[a]+=1
#print(d1,d2)
dp = [[0 for i in range(520*12)] for j in range(520)]
#print(len(dp), len(dp[0]))
for x in range(n+1):
for y in range(n*k+1):
for i in range(k+1):
dp[x+1][y+i] = max(dp[x+1][y+i],+dp[x][y]+(0 if i==0 else h[i-1]) )
ss=0
for i in d1:
#print(dp[d1[i]][d2[i]])
ss+=dp[d2[i]][d1[i]]
print(ss)
```
| 7,269 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Tags: dp
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
# ------------------------------
# f = open('./input.txt')
# sys.stdin = f
def main():
n, k = RL()
cds = RLL()
fn = RLL()
sc = [0]+RLL()
rec = set(fn)
uses = 0
dic = defaultdict(int)
for i in cds:
if i in rec:
dic[i]+=1
uses+=1
dp = [[0]*(n*k+1) for _ in range(n+1)]
for i in range(1, n+1):
for j in range(1, n*k+1):
for l in range(k+1):
if l>j: break
val = sc[l]
dp[i][j] = max(dp[i][j], dp[i-1][j-l]+val)
res = 0
for i, v in Counter(fn).items():
res+=dp[v][dic[i]]
# for i in dp: print(i)
print(res)
if __name__ == "__main__":
main()
```
| 7,270 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Tags: dp
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO,IOBase
def main():
n,k = map(int,input().split())
card = list(map(int,input().split()))
fav = list(map(int,input().split()))
joy = [0]+list(map(int,input().split()))
dp = [[0]*(n*k+1) for _ in range(n+1)]
for i in range(len(joy)):
dp[1][i] = joy[i]
for i in range(len(joy),n*k+1):
dp[1][i] = joy[-1]
for i in range(2,n+1):
for j in range(1,n*k+1):
for kk in range(min(k+1,j+1)):
dp[i][j] = max(dp[i][j],dp[i-1][j-kk]+dp[1][kk])
tot = [0]*(10**5+1)
for i in card:
tot[i] += 1
tot1 = [0]*(10**5+1)
for i in fav:
tot1[i] += 1
ans = 0
for i in range(10**5+1):
ans += dp[tot1[i]][tot[i]]
print(ans)
#Fast IO Region
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")
if __name__ == '__main__':
main()
```
| 7,271 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Tags: dp
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
# ------------------------------
# f = open('./input.txt')
# sys.stdin = f
def main():
n, k = RL()
cds = RLL()
fn = RLL()
sc = [0]+RLL()
rec = set(fn)
uses = 0
dic = defaultdict(int)
for i in cds:
if i in rec:
dic[i]+=1
uses+=1
dp = [[0]*(uses+1) for _ in range(n+1)]
for i in range(1, n+1):
for j in range(1, uses+1):
for l in range(k+1):
if l>j: break
val = sc[l]
dp[i][j] = max(dp[i][j], dp[i-1][j-l]+val)
res = 0
for i, v in Counter(fn).items():
res+=dp[v][dic[i]]
# for i in dp: print(i)
print(res)
if __name__ == "__main__":
main()
```
| 7,272 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Tags: dp
Correct Solution:
```
from __future__ import print_function
from queue import Queue
import sys
import math
import os.path
# CONFIG
sys.setrecursionlimit(10**9)
# LOG
def log(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
# INPUT
def ni():
return map(int, input().split())
def nio(offset):
return map(lambda x: int(x) + offset, input().split())
def nia():
return list(map(int, input().split()))
# CONVERT
def toString(aList, sep=" "):
return sep.join(str(x) for x in aList)
def mapInvertIndex(aList):
return {k: v for v, k in enumerate(aList)}
def countMap(arr):
m = {}
for x in arr:
m[x] = m.get(x,0) + 1
return m
def sortId(arr):
return sorted(range(arr), key=lambda k: arr[k])
# MAIN
n, k = ni()
c = nia()
f = nia()
h = [0]
h.extend(nia())
cc = countMap(c)
cf = countMap(f)
n1 = n+1
k1 = k+1
nk1 = n*k+1
dp = [[0]*nk1 for _ in range(n1)]
for ni in range(1,n1):
for ki in range(1,nk1):
mficount = min(k,ki) + 1
for kii in range(mficount):
# log(ni,ki, kii, dp[ni][ki], dp[ni-1][ki-kii] + h[kii])
dp[ni][ki] = max(dp[ni][ki], dp[ni-1][ki-kii] + h[kii])
# log(dp[ni])
# log(n,k)
# log("c", cc)
# log("f", cf)
# log("h", h)
# log(dp)
res = 0
for fk,fv in cf.items():
# log(fk, fv, cc.get(fk,0))
res += dp[fv][cc.get(fk,0)]
print(res)
```
| 7,273 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Submitted Solution:
```
from __future__ import print_function
from collections import Counter
from queue import Queue
import sys
import math
import os.path
# CONFIG
sys.setrecursionlimit(10**9)
# LOG
def log(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
# INPUT
def ni():
return map(int, input().split())
def nio(offset):
return map(lambda x: int(x) + offset, input().split())
def nia():
return list(map(int, input().split()))
# CONVERT
def toString(aList, sep=" "):
return sep.join(str(x) for x in aList)
def mapInvertIndex(aList):
return {k: v for v, k in enumerate(aList)}
def sortId(arr):
return sorted(range(arr), key=lambda k: arr[k])
# MAIN
n, k = ni()
c = nia()
f = nia()
h = nia()
h.insert(0,0)
cc = Counter(c)
cf = Counter(f)
n1 = n+1
k1 = k+1
nk1 = n*k+1
dp = [[0]*nk1 for _ in range(n1)]
for ni in range(1,n1):
for ki in range(1,nk1):
mficount = min(k,ki) + 1
for kii in range(mficount):
# log(ni,ki, kii, dp[ni][ki], dp[ni-1][ki-kii] + h[kii])
dp[ni][ki] = max(dp[ni][ki], dp[ni-1][ki-kii] + h[kii])
# log(dp[ni])
# log(n,k)
# log("c", cc)
# log("f", cf)
# log("h", h)
# log(dp)
res = 0
for fk,fv in cf.items():
# log(fk, fv, cc.get(fk,0))
res += dp[fv][cc.get(fk,0)]
print(res)
```
Yes
| 7,274 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Submitted Solution:
```
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
import io
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
#sys.setrecursionlimit(300000)
#threading.stack_size(10**8)
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")
#-------------------------------------------------------------------------
#mod = 9223372036854775807
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)
class SegmentTree1:
def __init__(self, data, default=10**6, 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)
MOD=10**9+7
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
mod=10**9+7
omod=998244353
#---------------------------------Lazy Segment Tree--------------------------------------
# https://github.com/atcoder/ac-library/blob/master/atcoder/lazysegtree.hpp
class LazySegTree:
def __init__(self, _op, _e, _mapping, _composition, _id, v):
def set(p, x):
assert 0 <= p < _n
p += _size
for i in range(_log, 0, -1):
_push(p >> i)
_d[p] = x
for i in range(1, _log + 1):
_update(p >> i)
def get(p):
assert 0 <= p < _n
p += _size
for i in range(_log, 0, -1):
_push(p >> i)
return _d[p]
def prod(l, r):
assert 0 <= l <= r <= _n
if l == r:
return _e
l += _size
r += _size
for i in range(_log, 0, -1):
if ((l >> i) << i) != l:
_push(l >> i)
if ((r >> i) << i) != r:
_push(r >> i)
sml = _e
smr = _e
while l < r:
if l & 1:
sml = _op(sml, _d[l])
l += 1
if r & 1:
r -= 1
smr = _op(_d[r], smr)
l >>= 1
r >>= 1
return _op(sml, smr)
def apply(l, r, f):
assert 0 <= l <= r <= _n
if l == r:
return
l += _size
r += _size
for i in range(_log, 0, -1):
if ((l >> i) << i) != l:
_push(l >> i)
if ((r >> i) << i) != r:
_push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
_all_apply(l, f)
l += 1
if r & 1:
r -= 1
_all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, _log + 1):
if ((l >> i) << i) != l:
_update(l >> i)
if ((r >> i) << i) != r:
_update((r - 1) >> i)
def _update(k):
_d[k] = _op(_d[2 * k], _d[2 * k + 1])
def _all_apply(k, f):
_d[k] = _mapping(f, _d[k])
if k < _size:
_lz[k] = _composition(f, _lz[k])
def _push(k):
_all_apply(2 * k, _lz[k])
_all_apply(2 * k + 1, _lz[k])
_lz[k] = _id
_n = len(v)
_log = _n.bit_length()
_size = 1 << _log
_d = [_e] * (2 * _size)
_lz = [_id] * _size
for i in range(_n):
_d[_size + i] = v[i]
for i in range(_size - 1, 0, -1):
_update(i)
self.set = set
self.get = get
self.prod = prod
self.apply = apply
MIL = 1 << 20
def makeNode(total, count):
# Pack a pair into a float
return (total * MIL) + count
def getTotal(node):
return math.floor(node / MIL)
def getCount(node):
return node - getTotal(node) * MIL
nodeIdentity = makeNode(0.0, 0.0)
def nodeOp(node1, node2):
return node1 + node2
# Equivalent to the following:
return makeNode(
getTotal(node1) + getTotal(node2), getCount(node1) + getCount(node2)
)
identityMapping = -1
def mapping(tag, node):
if tag == identityMapping:
return node
# If assigned, new total is the number assigned times count
count = getCount(node)
return makeNode(tag * count, count)
def composition(mapping1, mapping2):
# If assigned multiple times, take first non-identity assignment
return mapping1 if mapping1 != identityMapping else mapping2
#-------------------------------------------------------------------------
prime = [True for i in range(10)]
pp=[0]*10
def SieveOfEratosthenes(n=10):
p = 2
c=0
while (p * p <= n):
if (prime[p] == True):
c+=1
for i in range(p, n+1, p):
pp[i]+=1
prime[i] = False
p += 1
#---------------------------------Binary Search------------------------------------------
def binarySearch(arr, n, key):
left = 0
right = n-1
mid = 0
res=arr[n-1]
while (left <= right):
mid = (right + left)//2
if (arr[mid] >= key):
res=arr[mid]
right = mid-1
else:
left = mid + 1
return res
def binarySearch1(arr, n, key):
left = 0
right = n-1
mid = 0
res=arr[0]
while (left <= right):
mid = (right + left)//2
if (arr[mid] > key):
right = mid-1
else:
res=arr[mid]
left = mid + 1
return res
#---------------------------------running code------------------------------------------
n,k= map(int,input().split(' '))
l= list(map(int,input().split(' ')))
f =list(map(int,input().split(' ')))
h=list(map(int,input().split(' ')))
d1=dict({(a,0) for a in f})
d2=dict({(a,0) for a in f})
for a in l:
if(a in d1):d1[a]+=1
for a in f:
d2[a]+=1
#print(d1,d2)
dp = [[0 for i in range(520*12)] for j in range(520)]
#print(len(dp), len(dp[0]))
for x in range(n+1):
for y in range(n*k+1):
for i in range(k+1):
dp[x+1][y+i] = max(dp[x+1][y+i],+dp[x][y]+(0 if i==0 else h[i-1]) )
ss=0
for i in d1:
#print(dp[d1[i]][d2[i]])
ss+=dp[d2[i]][d1[i]]
print(ss)
```
Yes
| 7,275 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Submitted Solution:
```
import math
from collections import defaultdict
def main():
n, k = map(int, input().split())
cards = list(map(int, input().split()))
fav = list(map(int, input().split()))
h = [0] + list(map(int, input().split()))
cards_cnt = defaultdict(int)
for val in cards:
cards_cnt[val] += 1
players_fav_cnt = defaultdict(int)
for val in fav:
players_fav_cnt[val] += 1
# dp[a][b] - a players, b favourite cards (in total)
dp = [[0 for _ in range(k*n+k+1)] for _ in range(n+1)]
for p in range(n):
for c in range(k*n+1):
for hand in range(k+1):
dp[p+1][c+hand] = max(dp[p+1][c+hand], dp[p][c] + h[hand])
res = 0
for f in players_fav_cnt:
res += dp[players_fav_cnt[f]][cards_cnt[f]]
print(res)
if __name__ == '__main__':
main()
```
Yes
| 7,276 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Submitted Solution:
```
from __future__ import print_function
from collections import Counter
from queue import Queue
import sys
import math
import os.path
# CONFIG
sys.setrecursionlimit(10**9)
# LOG
def log(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
# INPUT
def ni():
return map(int, input().split())
def nio(offset):
return map(lambda x: int(x) + offset, input().split())
def nia():
return list(map(int, input().split()))
# CONVERT
def toString(aList, sep=" "):
return sep.join(str(x) for x in aList)
def mapInvertIndex(aList):
return {k: v for v, k in enumerate(aList)}
def sortId(arr):
return sorted(range(arr), key=lambda k: arr[k])
# MAIN
n, k = ni()
c = nia()
f = nia()
h = nia()
h.insert(0,0)
cc = Counter(c)
cf = Counter(f)
n1 = n+1
k1 = k+1
nk1 = n*k+1
dp = [[0]*nk1 for _ in range(n1)]
for ni in range(1,n1):
for ki in range(1,nk1):
mficount = min(k,ki) + 1
for kii in range(mficount):
# log(ni,ki, kii, dp[ni][ki], dp[ni-1][ki-kii] + h[kii])
dp[ni][ki] = max(dp[ni][ki], dp[ni-1][ki-kii] + h[kii])
# log(dp[ni])
# log(n,k)
# log("c", cc)
# log("f", cf)
# log("h", h)
# log(dp)
res = 0
for fk,fv in cf.items():
# log(fk, fv, cc.get(fk,0))
res += dp[fv][cc[fk]]
print(res)
```
Yes
| 7,277 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Submitted Solution:
```
DEBUG = False
def dprint (*args, **kwargs):
pass
print (*args, **kwargs)
if DEBUG:
nk = "4 3"
c = "1 3 2 8 5 5 8 2 2 8 5 2"
f = "1 2 2 5"
h = "2 6 7"
else:
nk = input()
c = input()
f = input()
h = input()
n, k = map(int, nk.split())
c = list(map(int, c.split()))
f = list(map(int, f.split()))
#n = len(f)
#k = len(c) // n
h = list(map(int, h.split()))
znaki = set(c + f) # different card values in game
# find supply and demand
supply = {}
demand = {}
for z in znaki:
supply[z] = c.count(z)
demand[z] = f.count(z)
dprint("supply:", supply)
dprint("demand:", demand)
# build H-matrix
dm = max(demand.values())
sm = max(supply.values())
dprint (znaki, sm, dm)
'''
if n == 4:
print (21)
elif n == 3:
print (0)
else:
#map(int, c.split())
print (znaki, sm, dm)
Ввод
500 10
2 1 1 2 2 ...
{1, 2} 2507 269
Ответ
42588497
'''
def happy_1(num, pl):
if num == 0:
return 0
if pl == 0:
return 0
if pl == 1:
return h[min(num, k) - 1]
if num == 1:
return h[0]
max_hap = 0
for i in range(1, min(num, k) + 1):
hap = h[i - 1] + happy_1(num - i, pl - 1)
if hap > max_hap:
max_hap = hap
return max_hap
#dprint(happy_1(3, 1))
happy_matrix = []
for d in range(dm + 1):
happy_row = []
for s in range(min (sm, dm*k) + 1):
happy_row.append(happy_1(s, d))
# print(s, d, happy_1(s, d))
happy_matrix.append(happy_row)
dprint("happy_matrix:", happy_matrix)
# find H-functions
deficit_sum = 0
for z in znaki:
deficit = demand[z] * k - supply[z]
deficit_sum += deficit
dprint(z, deficit)
#print("deficit_sum", deficit_sum)
# reallocate cards
# calculate result
total_happy = 0
for z in znaki:
total_happy += happy_matrix[demand[z]][min(supply[z], demand[z] * k)]
print(total_happy)
dprint("total_happy:", total_happy)
```
No
| 7,278 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Submitted Solution:
```
DEBUG = False
def dprint(*args, **kwargs):
if DEBUG:
print("#>",*args, **kwargs)
if DEBUG:
nk = "4 3"
c = "1 3 2 8 5 5 8 2 2 8 5 2"
f = "1 2 2 5"
h = "2 6 7"
else:
nk = input()
c = input()
f = input()
h = input()
n, k = map(int, nk.split())
c = list(map(int, c.split()))
f = list(map(int, f.split()))
# n = len(f)
# k = len(c) // n
h = list(map(int, h.split()))
znaki_s = set(c) # different card values in supply
znaki_d = set(f) # different card values in demand
znaki = set(c + f) # different card values in game
# find supply and demand
supply = {}
demand = {}
for z in znaki_s:
supply[z] = c.count(z)
for z in znaki_d:
demand[z] = f.count(z)
dprint("supply:", supply)
dprint("demand:", demand)
# build H-matrix
dm = max(demand.values())
sm = max(supply.values())
dprint(znaki, sm, dm)
if n == 4:
print (21)
elif n == 3:
print (0)
else:
print (n, k, znaki_s, f, h)
```
No
| 7,279 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
# ------------------------------
# f = open('./input.txt')
# sys.stdin = f
def main():
n, k = RL()
cds = RLL()
fn = RLL()
sc = [0]+RLL()
rec = set(fn)
uses = 0
dic = defaultdict(int)
for i in cds:
if i in rec:
dic[i]+=1
uses+=1
dp = [[0]*(uses+1) for _ in range(n+1)]
for i in range(1, n+1):
for j in range(1, uses+1):
if j>i*k: break
for l in range(k+1):
if l>j: break
val = sc[l]
dp[i][j] = max(dp[i][j], dp[i-1][j-l]+val)
res = 0
for i, v in Counter(fn).items():
res+=dp[v][dic[i]]
print(res)
if __name__ == "__main__":
main()
```
No
| 7,280 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0.
Submitted Solution:
```
DEBUG = False
def dprint(*args, **kwargs):
if DEBUG:
print("#>",*args, **kwargs)
if DEBUG:
nk = "4 3"
c = "1 3 2 8 5 5 8 2 2 8 5 2"
f = "1 2 2 5"
h = "2 6 7"
else:
nk = input()
c = input()
f = input()
h = input()
n, k = map(int, nk.split())
c = list(map(int, c.split()))
f = list(map(int, f.split()))
# n = len(f)
# k = len(c) // n
h = list(map(int, h.split()))
znaki_s = set(c) # different card values in supply
znaki_d = set(f) # different card values in demand
znaki = set(c + f) # different card values in game
# find supply and demand
supply = {}
demand = {}
for z in znaki_s:
supply[z] = c.count(z)
for z in znaki_d:
demand[z] = f.count(z)
dprint("supply:", supply)
dprint("demand:", demand)
# build H-matrix
dm = max(demand.values())
sm = max(supply.values())
dprint(znaki, sm, dm)
if n == 4:
print (21)
elif n == 3:
print (0)
else:
print (demand, f, h)
```
No
| 7,281 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
"Correct Solution:
```
import sys
input = sys.stdin.readline
N,K=map(int,input().split())
A=[int(input()) for i in range(N)]
def seg_function(x,y): # Segment treeで扱うfunction
return max(x,y)
seg_el=1<<((300000).bit_length()) # Segment treeの台の要素数
SEG=[0]*(2*seg_el) # 1-indexedなので、要素数2*seg_el.Segment treeの初期値で初期化
def update(n,x,seg_el): # A[n]をxに更新
i=n+seg_el
SEG[i]=max(SEG[i],x)
i>>=1 # 子ノードへ
while i!=0:
SEG[i]=seg_function(SEG[i*2],SEG[i*2+1])
i>>=1
def getvalues(l,r): # 区間[l,r)に関するseg_functionを調べる
L=l+seg_el
R=r+seg_el
ANS=0
while L<R:
if L & 1:
ANS=seg_function(ANS , SEG[L])
L+=1
if R & 1:
R-=1
ANS=seg_function(ANS , SEG[R])
L>>=1
R>>=1
return ANS
for a in A:
MAX=getvalues(max(0,a-K),min(300001,a+K+1))
update(a,MAX+1,seg_el)
print(SEG[1])
```
| 7,282 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
"Correct Solution:
```
import sys
read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7
class SegTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
for i in range(n):
self.tree[self.num + i] = init_val[i]
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
def segfunc(x, y):
return max(x, y)
def main():
N, K = map(int, readline().split())
A = list(int(readline()) for _ in range(N))
Amax = max(A)
dp = [0] * (Amax + 1)
ide_ele = -float('inf')
segtree = SegTree(dp, segfunc, ide_ele)
for a in A:
l = max(0, a - K)
r = min(Amax, a + K)
L = segtree.query(l, r + 1)
segtree.update(a, L + 1)
ans = segtree.query(0, Amax + 1)
print(ans)
if __name__ == '__main__':
main()
```
| 7,283 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
"Correct Solution:
```
class Segment_Tree():
"""
このプログラム内は1-index
"""
def __init__(self,L,calc,unit):
"""calcを演算とするリストLのSegment Treeを作成
calc:演算(2変数関数,モノイド)
unit:モノイドcalcの単位元 (xe=ex=xを満たすe)
"""
self.calc=calc
self.unit=unit
N=len(L)
d=max(1,(N-1).bit_length())
k=1<<d
self.data=[unit]*k+L+[unit]*(k-len(L))
self.N=k
self.depth=d
for i in range(k-1,0,-1):
self.data[i]=calc(self.data[i<<1],self.data[i<<1|1])
def get(self,k,index=1):
"""第k要素を取得
"""
assert 0<=k-index<self.N,"添字が範囲外"
return self.data[k-index+self.N]
def update(self,k,x,index=1):
"""第k要素をxに変え,更新を行う.
k:数列の要素
x:更新後の値
"""
assert 0<=k-index<self.N,"添字が範囲外"
m=(k-index)+self.N
self.data[m]=x
while m>1:
m>>=1
self.data[m]=self.calc(self.data[m<<1],self.data[m<<1|1])
def product(self,From,To,index=1,left_closed=True,right_closed=True):
L=(From-index)+self.N+(not left_closed)
R=(To-index)+self.N+(right_closed)
vL=self.unit
vR=self.unit
while L<R:
if L&1:
vL=self.calc(vL,self.data[L])
L+=1
if R&1:
R-=1
vR=self.calc(self.data[R],vR)
L>>=1
R>>=1
return self.calc(vL,vR)
def all_prod(self):
return self.data[1]
#================================================
N,K=map(int,input().split())
A=[0]*N
for i in range(N):
A[i]=int(input())
T=max(A)
S=Segment_Tree([0]*(T+1),max,0)
DP=[0]*N
for i in range(N-1,-1,-1):
X=S.product(max(0,A[i]-K),min(T,A[i]+K),0)
DP[i]=X+1
S.update(A[i],X+1,0)
print(max(DP))
```
| 7,284 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
"Correct Solution:
```
class SegTree:
X_unit = 0
X_f = max
def __init__(self, N):
self.N = N
self.X = [self.X_unit] * (N + N)
def build(self, seq):
for i, x in enumerate(seq, self.N):
self.X[i] = x
for i in range(self.N - 1, 0, -1):
self.X[i] = self.X_f(self.X[i << 1], self.X[i << 1 | 1])
def set_val(self, i, x):
i += self.N
self.X[i] = x
while i > 1:
i >>= 1
self.X[i] = self.X_f(self.X[i << 1], self.X[i << 1 | 1])
def fold(self, L, R):
L += self.N
R += self.N
vL = self.X_unit
vR = self.X_unit
while L < R:
if L & 1:
vL = self.X_f(vL, self.X[L])
L += 1
if R & 1:
R -= 1
vR = self.X_f(self.X[R], vR)
L >>= 1
R >>= 1
return self.X_f(vL, vR)
n,k = map(int,input().split())
seg = SegTree(300001)
# a = [0]*n
# seg.build(a)
for i in range(n):
a = int(input())
seg.set_val(a,seg.fold(max(0,a-k),min(300001,a+k+1)) + 1)
print(seg.fold(0,300001))
```
| 7,285 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
"Correct Solution:
```
class SegmentTree:
def __init__(self, data, default=0, func=max):
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):
start += self._size
stop += self._size
res_left = res_right = self._default
while start < stop:
if start & 1:
res_left = self._func(res_left, self.data[start])
start += 1
if stop & 1:
stop -= 1
res_right = self._func(self.data[stop], res_right)
start >>= 1
stop >>= 1
return self._func(res_left, res_right)
def __repr__(self):
return "SegmentTree({0})".format(self.data)
import sys
input=sys.stdin.readline
n,k=map(int,input().split())
M=1048576
s=SegmentTree([0]*M)
for i in range(n):
a=int(input())
s[a]=1+s.query(max(a-k,0),a+k+1)
print(s.query(0,M))
```
| 7,286 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
"Correct Solution:
```
class SegmentTree:
_op = None
_e = None
_size = None
_offset = None
_data = None
def __init__(self, size, op, e):
self._op = op
self._e = e
self._size = size
t = 1
while t < size:
t *= 2
self._offset = t - 1
self._data = [0] * (t * 2 - 1)
def build(self, iterable):
op = self._op
data = self._data
data[self._offset:self._offset + self._size] = iterable
for i in range(self._offset - 1, -1, -1):
data[i] = op(data[i * 2 + 1], data[i * 2 + 2])
def update(self, index, value):
op = self._op
data = self._data
i = self._offset + index
data[i] = value
while i >= 1:
i = (i - 1) // 2
data[i] = op(data[i * 2 + 1], data[i * 2 + 2])
def query(self, start, stop):
def iter_segments(data, l, r):
while l < r:
if l & 1 == 0:
yield data[l]
if r & 1 == 0:
yield data[r - 1]
l = l // 2
r = (r - 1) // 2
op = self._op
it = iter_segments(self._data, start + self._offset,
stop + self._offset)
result = self._e
for v in it:
result = op(result, v)
return result
N, K, *A = map(int, open(0).read().split())
st = SegmentTree(300000 + 1, max, 0)
for a in A:
st.update(a, st.query(max(a - K, 0), min(a + K + 1, 300000 + 1)) + 1)
print(st.query(0, 300000 + 1))
```
| 7,287 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
"Correct Solution:
```
class Segtree():
def __init__(self, n):
self.num = 1 << (n - 1).bit_length()
self.tree = [0] * 2 * self.num
for i in range(self.num - 1, 0, -1):
self.tree[i] = max(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = max(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
res = 0
l, r = l + self.num, r + self.num
while l < r:
if l & 1:
res = max(res, self.tree[l])
l += 1
if r & 1:
res = max(res, self.tree[r - 1])
l, r = l >> 1, r >> 1
return res
n, k = map(int, input().split())
a = [int(input()) for _ in range(n)]
a_max = max(a) + 1
seg_dp = Segtree(a_max)
for ai in a:
tmp = seg_dp.query(max(ai - k, 0), min(ai + k + 1, a_max))
seg_dp.update(ai, tmp + 1)
print(max(seg_dp.tree))
```
| 7,288 |
Provide a correct Python 3 solution for this coding contest problem.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
"Correct Solution:
```
class SegTree: # モノイドに対して適用可能、Nが2冪でなくても良い
def __init__(self,N,seg_func,unit):
self.N = 1 << (N-1).bit_length()
self.func = seg_func
self.unit = unit
self.tree = [self.unit]*(2*self.N)
def build(self,init_value): # 初期値を[N,2N)に格納
for i in range(len(init_value)):
self.tree[i+self.N] = init_value[i]
for i in range(self.N-1,0,-1):
self.tree[i] = self.func(self.tree[i << 1],self.tree[i << 1 | 1])
def set_val(self,i,x): # i番目(0-index)の値をxに変更
i += self.N
self.tree[i] = x
i >>= 1
while i:
self.tree[i] = self.func(self.tree[i << 1],self.tree[i << 1 | 1])
i >>= 1
def fold(self,L,R): # [L,R)の区間取得
L += self.N
R += self.N
vL = self.unit
vR = self.unit
while L < R:
if L & 1:
vL = self.func(vL,self.tree[L])
L += 1
if R & 1:
R -= 1
vR = self.func(self.tree[R],vR)
L >>= 1
R >>= 1
return self.func(vL,vR)
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
N,K = MI()
ST = SegTree(300001,max,0)
# dp[i][j] = A1~Ai を用いて、末尾が j になり条件を満たす数列の長さの最大値
# dp[i][j] = 1+max(dp[i-1][Ai-K],…,dp[i-1][Ai+K]) if j == Ai else dp[i-1][j]
# この dp をセグメントツリーにのせて考える
for i in range(N):
a = I()
ST.set_val(a,1+ST.fold(max(0,a-K),min(300000,a+K)+1))
print(ST.fold(0,300001))
```
| 7,289 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
Submitted Solution:
```
#import sys
#import numpy as np
import math
#from fractions import Fraction
import itertools
from collections import deque
from collections import Counter
import heapq
from fractions import gcd
#input=sys.stdin.readline
#import bisect
from fractions import gcd
n,k=map(int,input().split())
inf = 0
m=300001
num_min =2**(m-1).bit_length()
dat=[inf]*(2*num_min-1)
#初期化
#親のノード(n-1)//2
#子のノード2n+1,2n+2
def segfunc(x,y):
return max(x,y)
def update(i,x):
i+=num_min-1
dat[i]=x
while i>0:
i=(i-1)//2
dat[i]=segfunc(dat[2*i+1],dat[2*i+2])
def query(a,b): #半開区間、[a,b)の最小値
if b<=a:
return inf
res=inf
a += num_min-1
b += num_min-2
while b-a>1:
if a&1==0:
res = segfunc(res,dat[a])
if b&1==1:
res = segfunc(res,dat[b])
b-=1
a=a//2
b=(b-1)//2
if a==b:
res = segfunc(res,dat[a])
else:
res=segfunc(segfunc(res,dat[a]),dat[b])
return res
ans=0
for i in range(n):
x=int(input())
l=max(0,x-k)
r=min(300000,x+k)
tmp=query(l,r+1)+1
ans=max(tmp,ans)
update(x,tmp)
print(ans)
```
Yes
| 7,290 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
Submitted Solution:
```
import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
# from itertools import permutations,combinations
def data(): return sys.stdin.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var): sys.stdout.write('\n'.join(map(str, var)) + '\n')
def out(var): sys.stdout.write(str(var) + '\n')
from decimal import Decimal
# from fractions import Fraction
# sys.setrecursionlimit(100000)
mod = 998244353
INF=float('inf')
def construct_sum(segtree,a,n,func=max):
for i in range(n):
segtree[n + i] = a[i]
for i in range(n - 1, 0, -1):
segtree[i] = func(segtree[2 * i], segtree[2 * i + 1])
def update(pos, x, func=max):
pos += n-1
segtree[pos] = x
while (pos>1):
pos>>=1
segtree[pos] = func(segtree[2 * pos], segtree[2 * pos + 1])
def get(l, r, func=max):
l += n-1
r += n-1
s = 0
while (l <= r):
if l & 1:
s = func(segtree[l],s)
l+=1
if (r+1) & 1:
s = func(segtree[r],s)
r-=1
l >>= 1
r >>= 1
return s
n,k=mdata()
a=[int(data()) for i in range(n)]
n=max(a)+1
segtree = [0]*(2*n)
construct_sum(segtree,[0]*n,n)
ans=0
for i in a:
a1=get(max(i-k+1,1),min(i+k+1,n))+1
update(i+1,a1)
ans=max(ans,a1)
out(ans)
```
Yes
| 7,291 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
Submitted Solution:
```
import typing
class SegTree:
def __init__(self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]):
self._op = op
self._e = e
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = self._ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
p += self._size
self._d[p] = x
for i in range(1, self._log + 1):
self._update(p >> i)
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
sml = self._e
smr = self._e
left += self._size
right += self._size
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _ceil_pow2(self, n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
N, K = map(int, input().split())
A = list(int(input()) for _ in range(N))
max_A = max(A)
seg = SegTree(max, -1, [0]*(max_A+1))
for v in A:
l = max(0, v-K)
r = min(max_A, v+K)
seg.set(v, seg.prod(l, r+1)+1)
print(seg.all_prod())
```
Yes
| 7,292 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
Submitted Solution:
```
class SegTree:
X_unit = 0
X_f = max
def __init__(self, N):
self.N = N
self.X = [self.X_unit] * (N + N)
def build(self, seq):
for i, x in enumerate(seq, self.N):
self.X[i] = x
for i in range(self.N - 1, 0, -1):
self.X[i] = self.X_f(self.X[i << 1], self.X[i << 1 | 1])
def set_val(self, i, x):
i += self.N
self.X[i] = x
while i > 1:
i >>= 1
self.X[i] = self.X_f(self.X[i << 1], self.X[i << 1 | 1])
def fold(self, L, R):
L += self.N
R += self.N
vL = self.X_unit
vR = self.X_unit
while L < R:
if L & 1:
vL = self.X_f(vL, self.X[L])
L += 1
if R & 1:
R -= 1
vR = self.X_f(self.X[R], vR)
L >>= 1
R >>= 1
return self.X_f(vL, vR)
lim = 4*10**5
n,k = map(int,input().split())
seg = SegTree(lim)
# a = [0]*n
# seg.build(a)
for i in range(n):
a = int(input())
seg.set_val(a,seg.fold(max(0,a-k),min(lim,a+k+1)) + 1)
print(seg.fold(0,lim))
```
Yes
| 7,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
Submitted Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().strip().split(" "))
def li(): return list(mi())
def solve():
n, k = mi()
stack = []
for i in range(n):
z = ii()
if not stack:
stack.append(z)
else:
d = abs(stack[-1] - z)
if d <= k:
stack.append(z)
return len(stack)
def main():
# pass
print(solve())
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
```
No
| 7,294 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
Submitted Solution:
```
class SegmentTree:
_op = None
_e = None
_size = None
_offset = None
_data = None
def __init__(self, size, op, e):
self._op = op
self._e = e
self._size = size
t = 1
while t < size:
t *= 2
self._offset = t - 1
self._data = [0] * (t * 2 - 1)
def build(self, iterable):
op = self._op
data = self._data
data[self._offset:self._offset + self._size] = iterable
for i in range(self._offset - 1, -1, -1):
data[i] = op(data[i * 2 + 1], data[i * 2 + 2])
def update(self, index, value):
op = self._op
data = self._data
i = self._offset + index
data[i] = value
while i >= 1:
i = (i - 1) // 2
data[i] = op(data[i * 2 + 1], data[i * 2 + 2])
def query(self, start, stop):
def iter_segments(data, l, r):
while l < r:
if l & 1 == 0:
yield data[l]
if r & 1 == 0:
yield data[r - 1]
l = l // 2
r = (r - 1) // 2
op = self._op
it = iter_segments(self._data, start + self._offset,
stop + self._offset)
result = self._e
for v in it:
result = op(result, v)
return result
N, K, *A = map(int, open(0).read().split())
st = SegmentTree(300000 + 1, max, 0)
for a in A:
st.update(a, st.query(max(a - K, 0), min(a + K + 1, 300000 + 1)) + 1)
print(st.query(0, 300000 + 1))
```
No
| 7,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
Submitted Solution:
```
import typing
def _ceil_pow2(n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
def _bsf(n: int) -> int:
x = 0
while n % 2 == 0:
x += 1
n //= 2
return x
class SegTree:
def __init__(self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = _ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
p += self._size
self._d[p] = x
for i in range(1, self._log + 1):
self._update(p >> i)
def get(self, p: int) -> typing.Any:
assert 0 <= p < self._n
return self._d[p + self._size]
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
sml = self._e
smr = self._e
left += self._size
right += self._size
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def max_right(self, left: int,
f: typing.Callable[[typing.Any], bool]) -> int:
assert 0 <= left <= self._n
assert f(self._e)
if left == self._n:
return self._n
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
n, k, *A = map(int, open(0).read().split())
m = 303030
segtree = SegTree(op=max, e=0, v=m)
for a in A:
l, r = max(1, a-k), min(m, a+k+1)
segtree.set(a, segtree.prod(l, r)+1)
print(segtree.all_prod())
```
No
| 7,296 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7
Submitted Solution:
```
from math import ceil, log2
import sys
z=sys.stdin.readline
class SegTree:
ide_ele = 0
def __init__(self, init_val):
n = len(init_val)
self.num = 2**ceil(log2(n))
self.seg = [self.ide_ele] * (2 * self.num - 1)
def segfunc(self, x, y):
return max(x, y)
def update(self, k, x):
k += self.num - 1
self.seg[k] = x
while k:
k = (k - 1) // 2
self.seg[k] = self.segfunc(self.seg[k * 2 + 1], self.seg[k * 2 + 2])
def query(self, a, b, k, l, r):
if r <= a or b <= l:
return self.ide_ele
if a <= l and r <= b:
return self.seg[k]
else:
vl = self.query(a, b, k*2+1, l, (l+r)//2)
vr = self.query(a, b, k*2+2, (l+r)//2, r)
return self.segfunc(vl, vr)
n, k = map(int, z().split())
a = [int(z()) for _ in range(n)]
M=300001
st = SegTree([0]*M)
res = 0
for i in a:
min_a = max(i-k, 0)
max_a = min(i+k, M)
s = st.query(min_a, max_a+1, 0, 0, st.num)
st.update(i, max(s, 0)+1)
res = max(res, max(s, 0) + 1)
print(res)
```
No
| 7,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Snuke came up with a game that uses a number sequence, as follows:
* Prepare a sequence of length M consisting of integers between 0 and 2^N-1 (inclusive): a = a_1, a_2, \ldots, a_M.
* Snuke first does the operation below as many times as he likes:
* Choose a positive integer d, and for each i (1 \leq i \leq M), in binary, set the d-th least significant bit of a_i to 0. (Here the least significant bit is considered the 1-st least significant bit.)
* After Snuke finishes doing operations, Takahashi tries to sort a in ascending order by doing the operation below some number of times. Here a is said to be in ascending order when a_i \leq a_{i + 1} for all i (1 \leq i \leq M - 1).
* Choose two adjacent elements of a: a_i and a_{i + 1}. If, in binary, these numbers differ in exactly one bit, swap a_i and a_{i + 1}.
There are 2^{NM} different sequences of length M consisting of integers between 0 and 2^N-1 that can be used in the game.
How many among them have the following property: if used in the game, there is always a way for Takahashi to sort the sequence in ascending order regardless of Snuke's operations? Find the count modulo (10^9 + 7).
Constraints
* All values in input are integers.
* 1 \leq N \leq 5000
* 2 \leq M \leq 5000
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number, modulo (10^9 + 7), of sequences with the property: if used in the game, there is always a way for Takahashi to sort the sequence in ascending order regardless of Snuke's operations.
Examples
Input
2 5
Output
352
Input
2020 530
Output
823277409
Submitted Solution:
```
input()
print(1)
```
No
| 7,298 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Snuke came up with a game that uses a number sequence, as follows:
* Prepare a sequence of length M consisting of integers between 0 and 2^N-1 (inclusive): a = a_1, a_2, \ldots, a_M.
* Snuke first does the operation below as many times as he likes:
* Choose a positive integer d, and for each i (1 \leq i \leq M), in binary, set the d-th least significant bit of a_i to 0. (Here the least significant bit is considered the 1-st least significant bit.)
* After Snuke finishes doing operations, Takahashi tries to sort a in ascending order by doing the operation below some number of times. Here a is said to be in ascending order when a_i \leq a_{i + 1} for all i (1 \leq i \leq M - 1).
* Choose two adjacent elements of a: a_i and a_{i + 1}. If, in binary, these numbers differ in exactly one bit, swap a_i and a_{i + 1}.
There are 2^{NM} different sequences of length M consisting of integers between 0 and 2^N-1 that can be used in the game.
How many among them have the following property: if used in the game, there is always a way for Takahashi to sort the sequence in ascending order regardless of Snuke's operations? Find the count modulo (10^9 + 7).
Constraints
* All values in input are integers.
* 1 \leq N \leq 5000
* 2 \leq M \leq 5000
Input
Input is given from Standard Input in the following format:
N M
Output
Print the number, modulo (10^9 + 7), of sequences with the property: if used in the game, there is always a way for Takahashi to sort the sequence in ascending order regardless of Snuke's operations.
Examples
Input
2 5
Output
352
Input
2020 530
Output
823277409
Submitted Solution:
```
class comb():
F = [1, 1]
Fi = [1, 1]
I = [0, 1]
def __init__(self, num, mod):
self.MOD = mod
for i in range(2, num + 1):
self.F.append((self.F[-1] * i) % mod)
self.I.append(mod - self.I[mod % i] * (mod // i) % mod)
self.Fi.append(self.Fi[-1] * self.I[i] % mod)
def com(self, n, k):
if n < k: return 0
if n < 0 or k < 0: return 0
return self.F[n] * (self.Fi[k] * self.Fi[n - k] % self.MOD) % self.MOD
M, N = list(map(int, input().split()))
MOD = 10 ** 9 + 7
DP = [[[0] * 2 for i in range(M + 1)] for _ in range(N)]
com = comb(M + 1, MOD)
L = [0] * (M + 1)
for i in range(M + 1):
L[i] = com.com(M, i)
for i in range(M + 1):
DP[0][i][0] = 1
for i in range(1, N):
for j in range(M + 1):
if j != 0:
DP[i][j][0] += (DP[i - 1][j - 1][0] + DP[i - 1][j - 1][1]) * L[j - 1] % MOD
DP[i][j][0] += DP[i - 1][j][0] * L[j] % MOD
DP[i][j][0] %= MOD
if j != M:
DP[i][j][1] += (DP[i - 1][j + 1][0]) * L[j + 1] % MOD
DP[i][j][1] += DP[i - 1][j][1] * L[j] % MOD
ans = 0
for i in range(M + 1):
ans = (ans + DP[-1][i][0] + DP[-1][i][1]) % MOD
print(ans)
```
No
| 7,299 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.