lang
stringclasses 1
value | prompt
stringlengths 1.38k
11.3k
| eval_prompt
stringlengths 37
8.09k
| ground_truth
stringlengths 1
328
| unit_tests
stringclasses 145
values | task_id
stringlengths 23
25
| split
stringclasses 2
values |
|---|---|---|---|---|---|---|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a rooted tree of $$$2^n - 1$$$ vertices. Every vertex of this tree has either $$$0$$$ children, or $$$2$$$ children. All leaves of this tree have the same distance from the root, and for every non-leaf vertex, one of its children is the left one, and the other child is the right one. Formally, you are given a perfect binary tree.The vertices of the tree are numbered in the following order: the root has index $$$1$$$; if a vertex has index $$$x$$$, then its left child has index $$$2x$$$, and its right child has index $$$2x+1$$$. Every vertex of the tree has a letter written on it, either A or B. Let's define the character on the vertex $$$x$$$ as $$$s_x$$$.Let the preorder string of some vertex $$$x$$$ be defined in the following way: if the vertex $$$x$$$ is a leaf, then the preorder string of $$$x$$$ be consisting of only one character $$$s_x$$$; otherwise, the preorder string of $$$x$$$ is $$$s_x + f(l_x) + f(r_x)$$$, where $$$+$$$ operator defines concatenation of strings, $$$f(l_x)$$$ is the preorder string of the left child of $$$x$$$, and $$$f(r_x)$$$ is the preorder string of the right child of $$$x$$$. The preorder string of the tree is the preorder string of its root.Now, for the problem itself...You have to calculate the number of different strings that can be obtained as the preorder string of the given tree, if you are allowed to perform the following operation any number of times before constructing the preorder string of the tree: choose any non-leaf vertex $$$x$$$, and swap its children (so, the left child becomes the right one, and vice versa).
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 18$$$). The second line contains a sequence of $$$2^n-1$$$ characters $$$s_1, s_2, \dots, s_{2^n-1}$$$. Each character is either A or B. The characters are not separated by spaces or anything else.
Output Specification: Print one integer β the number of different strings that can be obtained as the preorder string of the given tree, if you can apply any number of operations described in the statement. Since it can be very large, print it modulo $$$998244353$$$.
Code:
def dfs(tree,i,h):
if i>=2**(h-1)-1:
return [tree[i],1]
ls,li=dfs(tree,i*2+1,h)
rs,ri=dfs(tree,i*2+2,h)
res=li*ri
if ls!=rs:
res*=2
if ls>rs:
return [tree[i]+rs+ls,res]
else:
# TODO: Your code here
h=int(input())
tree=input()
print(dfs(tree,0,h)[1]%998244353 )
|
def dfs(tree,i,h):
if i>=2**(h-1)-1:
return [tree[i],1]
ls,li=dfs(tree,i*2+1,h)
rs,ri=dfs(tree,i*2+2,h)
res=li*ri
if ls!=rs:
res*=2
if ls>rs:
return [tree[i]+rs+ls,res]
else:
{{completion}}
h=int(input())
tree=input()
print(dfs(tree,0,h)[1]%998244353 )
|
return [tree[i]+ls+rs,res]
|
[{"input": "4\nBAAAAAAAABBABAB", "output": ["16"]}, {"input": "2\nBAA", "output": ["1"]}, {"input": "2\nABA", "output": ["2"]}, {"input": "2\nAAB", "output": ["2"]}, {"input": "2\nAAA", "output": ["1"]}]
|
block_completion_001706
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a rooted tree of $$$2^n - 1$$$ vertices. Every vertex of this tree has either $$$0$$$ children, or $$$2$$$ children. All leaves of this tree have the same distance from the root, and for every non-leaf vertex, one of its children is the left one, and the other child is the right one. Formally, you are given a perfect binary tree.The vertices of the tree are numbered in the following order: the root has index $$$1$$$; if a vertex has index $$$x$$$, then its left child has index $$$2x$$$, and its right child has index $$$2x+1$$$. Every vertex of the tree has a letter written on it, either A or B. Let's define the character on the vertex $$$x$$$ as $$$s_x$$$.Let the preorder string of some vertex $$$x$$$ be defined in the following way: if the vertex $$$x$$$ is a leaf, then the preorder string of $$$x$$$ be consisting of only one character $$$s_x$$$; otherwise, the preorder string of $$$x$$$ is $$$s_x + f(l_x) + f(r_x)$$$, where $$$+$$$ operator defines concatenation of strings, $$$f(l_x)$$$ is the preorder string of the left child of $$$x$$$, and $$$f(r_x)$$$ is the preorder string of the right child of $$$x$$$. The preorder string of the tree is the preorder string of its root.Now, for the problem itself...You have to calculate the number of different strings that can be obtained as the preorder string of the given tree, if you are allowed to perform the following operation any number of times before constructing the preorder string of the tree: choose any non-leaf vertex $$$x$$$, and swap its children (so, the left child becomes the right one, and vice versa).
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 18$$$). The second line contains a sequence of $$$2^n-1$$$ characters $$$s_1, s_2, \dots, s_{2^n-1}$$$. Each character is either A or B. The characters are not separated by spaces or anything else.
Output Specification: Print one integer β the number of different strings that can be obtained as the preorder string of the given tree, if you can apply any number of operations described in the statement. Since it can be very large, print it modulo $$$998244353$$$.
Code:
import sys
N = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
# print(N, s)
m = 1 << N
mod = 998244353
def dfs(i):
if i >= m: return (1, '')
ln, ls = dfs(i * 2)
rn, rs = dfs(i * 2 + 1)
ln = ln % mod
rn = rn % mod
if ls < rs:
return ln * rn * 2, ls + s[i - 1] + rs
elif ls > rs:
# TODO: Your code here
else:
return ln * rn, ls + s[i - 1] + rs
n, _ = dfs(1)
print(n % mod)
|
import sys
N = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
# print(N, s)
m = 1 << N
mod = 998244353
def dfs(i):
if i >= m: return (1, '')
ln, ls = dfs(i * 2)
rn, rs = dfs(i * 2 + 1)
ln = ln % mod
rn = rn % mod
if ls < rs:
return ln * rn * 2, ls + s[i - 1] + rs
elif ls > rs:
{{completion}}
else:
return ln * rn, ls + s[i - 1] + rs
n, _ = dfs(1)
print(n % mod)
|
return ln * rn * 2, rs + s[i - 1] + ls
|
[{"input": "4\nBAAAAAAAABBABAB", "output": ["16"]}, {"input": "2\nBAA", "output": ["1"]}, {"input": "2\nABA", "output": ["2"]}, {"input": "2\nAAB", "output": ["2"]}, {"input": "2\nAAA", "output": ["1"]}]
|
block_completion_001707
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a rooted tree of $$$2^n - 1$$$ vertices. Every vertex of this tree has either $$$0$$$ children, or $$$2$$$ children. All leaves of this tree have the same distance from the root, and for every non-leaf vertex, one of its children is the left one, and the other child is the right one. Formally, you are given a perfect binary tree.The vertices of the tree are numbered in the following order: the root has index $$$1$$$; if a vertex has index $$$x$$$, then its left child has index $$$2x$$$, and its right child has index $$$2x+1$$$. Every vertex of the tree has a letter written on it, either A or B. Let's define the character on the vertex $$$x$$$ as $$$s_x$$$.Let the preorder string of some vertex $$$x$$$ be defined in the following way: if the vertex $$$x$$$ is a leaf, then the preorder string of $$$x$$$ be consisting of only one character $$$s_x$$$; otherwise, the preorder string of $$$x$$$ is $$$s_x + f(l_x) + f(r_x)$$$, where $$$+$$$ operator defines concatenation of strings, $$$f(l_x)$$$ is the preorder string of the left child of $$$x$$$, and $$$f(r_x)$$$ is the preorder string of the right child of $$$x$$$. The preorder string of the tree is the preorder string of its root.Now, for the problem itself...You have to calculate the number of different strings that can be obtained as the preorder string of the given tree, if you are allowed to perform the following operation any number of times before constructing the preorder string of the tree: choose any non-leaf vertex $$$x$$$, and swap its children (so, the left child becomes the right one, and vice versa).
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 18$$$). The second line contains a sequence of $$$2^n-1$$$ characters $$$s_1, s_2, \dots, s_{2^n-1}$$$. Each character is either A or B. The characters are not separated by spaces or anything else.
Output Specification: Print one integer β the number of different strings that can be obtained as the preorder string of the given tree, if you can apply any number of operations described in the statement. Since it can be very large, print it modulo $$$998244353$$$.
Code:
import sys
N = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
# print(N, s)
m = 1 << N
mod = 998244353
def dfs(i):
if i >= m: return (1, '')
ln, ls = dfs(i * 2)
rn, rs = dfs(i * 2 + 1)
ln = ln % mod
rn = rn % mod
if ls < rs:
return ln * rn * 2, ls + s[i - 1] + rs
elif ls > rs:
return ln * rn * 2, rs + s[i - 1] + ls
else:
# TODO: Your code here
n, _ = dfs(1)
print(n % mod)
|
import sys
N = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
# print(N, s)
m = 1 << N
mod = 998244353
def dfs(i):
if i >= m: return (1, '')
ln, ls = dfs(i * 2)
rn, rs = dfs(i * 2 + 1)
ln = ln % mod
rn = rn % mod
if ls < rs:
return ln * rn * 2, ls + s[i - 1] + rs
elif ls > rs:
return ln * rn * 2, rs + s[i - 1] + ls
else:
{{completion}}
n, _ = dfs(1)
print(n % mod)
|
return ln * rn, ls + s[i - 1] + rs
|
[{"input": "4\nBAAAAAAAABBABAB", "output": ["16"]}, {"input": "2\nBAA", "output": ["1"]}, {"input": "2\nABA", "output": ["2"]}, {"input": "2\nAAB", "output": ["2"]}, {"input": "2\nAAA", "output": ["1"]}]
|
block_completion_001708
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a rooted tree of $$$2^n - 1$$$ vertices. Every vertex of this tree has either $$$0$$$ children, or $$$2$$$ children. All leaves of this tree have the same distance from the root, and for every non-leaf vertex, one of its children is the left one, and the other child is the right one. Formally, you are given a perfect binary tree.The vertices of the tree are numbered in the following order: the root has index $$$1$$$; if a vertex has index $$$x$$$, then its left child has index $$$2x$$$, and its right child has index $$$2x+1$$$. Every vertex of the tree has a letter written on it, either A or B. Let's define the character on the vertex $$$x$$$ as $$$s_x$$$.Let the preorder string of some vertex $$$x$$$ be defined in the following way: if the vertex $$$x$$$ is a leaf, then the preorder string of $$$x$$$ be consisting of only one character $$$s_x$$$; otherwise, the preorder string of $$$x$$$ is $$$s_x + f(l_x) + f(r_x)$$$, where $$$+$$$ operator defines concatenation of strings, $$$f(l_x)$$$ is the preorder string of the left child of $$$x$$$, and $$$f(r_x)$$$ is the preorder string of the right child of $$$x$$$. The preorder string of the tree is the preorder string of its root.Now, for the problem itself...You have to calculate the number of different strings that can be obtained as the preorder string of the given tree, if you are allowed to perform the following operation any number of times before constructing the preorder string of the tree: choose any non-leaf vertex $$$x$$$, and swap its children (so, the left child becomes the right one, and vice versa).
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 18$$$). The second line contains a sequence of $$$2^n-1$$$ characters $$$s_1, s_2, \dots, s_{2^n-1}$$$. Each character is either A or B. The characters are not separated by spaces or anything else.
Output Specification: Print one integer β the number of different strings that can be obtained as the preorder string of the given tree, if you can apply any number of operations described in the statement. Since it can be very large, print it modulo $$$998244353$$$.
Code:
# trans rights
N = int(input())
N = 2 ** N
S = input()
U = [0] * N
cnt = 0
for i in range(N - 2, -1, -1):
a = 2 * i + 1
b = 2 * i + 2
if b >= N:
# TODO: Your code here
if U[a] != U[b]:
cnt += 1
U[i] = ord(S[i]) + 331 * min(U[a], U[b]) + 3331 * max(U[a], U[b]) + min(U[a], U[b]) ** 2
U[i] %= 2 ** 104
print(pow(2, cnt, 998244353))
|
# trans rights
N = int(input())
N = 2 ** N
S = input()
U = [0] * N
cnt = 0
for i in range(N - 2, -1, -1):
a = 2 * i + 1
b = 2 * i + 2
if b >= N:
{{completion}}
if U[a] != U[b]:
cnt += 1
U[i] = ord(S[i]) + 331 * min(U[a], U[b]) + 3331 * max(U[a], U[b]) + min(U[a], U[b]) ** 2
U[i] %= 2 ** 104
print(pow(2, cnt, 998244353))
|
U[i] = ord(S[i])
continue
|
[{"input": "4\nBAAAAAAAABBABAB", "output": ["16"]}, {"input": "2\nBAA", "output": ["1"]}, {"input": "2\nABA", "output": ["2"]}, {"input": "2\nAAB", "output": ["2"]}, {"input": "2\nAAA", "output": ["1"]}]
|
block_completion_001709
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a rooted tree of $$$2^n - 1$$$ vertices. Every vertex of this tree has either $$$0$$$ children, or $$$2$$$ children. All leaves of this tree have the same distance from the root, and for every non-leaf vertex, one of its children is the left one, and the other child is the right one. Formally, you are given a perfect binary tree.The vertices of the tree are numbered in the following order: the root has index $$$1$$$; if a vertex has index $$$x$$$, then its left child has index $$$2x$$$, and its right child has index $$$2x+1$$$. Every vertex of the tree has a letter written on it, either A or B. Let's define the character on the vertex $$$x$$$ as $$$s_x$$$.Let the preorder string of some vertex $$$x$$$ be defined in the following way: if the vertex $$$x$$$ is a leaf, then the preorder string of $$$x$$$ be consisting of only one character $$$s_x$$$; otherwise, the preorder string of $$$x$$$ is $$$s_x + f(l_x) + f(r_x)$$$, where $$$+$$$ operator defines concatenation of strings, $$$f(l_x)$$$ is the preorder string of the left child of $$$x$$$, and $$$f(r_x)$$$ is the preorder string of the right child of $$$x$$$. The preorder string of the tree is the preorder string of its root.Now, for the problem itself...You have to calculate the number of different strings that can be obtained as the preorder string of the given tree, if you are allowed to perform the following operation any number of times before constructing the preorder string of the tree: choose any non-leaf vertex $$$x$$$, and swap its children (so, the left child becomes the right one, and vice versa).
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 18$$$). The second line contains a sequence of $$$2^n-1$$$ characters $$$s_1, s_2, \dots, s_{2^n-1}$$$. Each character is either A or B. The characters are not separated by spaces or anything else.
Output Specification: Print one integer β the number of different strings that can be obtained as the preorder string of the given tree, if you can apply any number of operations described in the statement. Since it can be very large, print it modulo $$$998244353$$$.
Code:
# trans rights
N = int(input())
N = 2 ** N
S = input()
U = [0] * N
cnt = 0
for i in range(N - 2, -1, -1):
a = 2 * i + 1
b = 2 * i + 2
if b >= N:
U[i] = ord(S[i])
continue
if U[a] != U[b]:
# TODO: Your code here
U[i] = ord(S[i]) + 331 * min(U[a], U[b]) + 3331 * max(U[a], U[b]) + min(U[a], U[b]) ** 2
U[i] %= 2 ** 104
print(pow(2, cnt, 998244353))
|
# trans rights
N = int(input())
N = 2 ** N
S = input()
U = [0] * N
cnt = 0
for i in range(N - 2, -1, -1):
a = 2 * i + 1
b = 2 * i + 2
if b >= N:
U[i] = ord(S[i])
continue
if U[a] != U[b]:
{{completion}}
U[i] = ord(S[i]) + 331 * min(U[a], U[b]) + 3331 * max(U[a], U[b]) + min(U[a], U[b]) ** 2
U[i] %= 2 ** 104
print(pow(2, cnt, 998244353))
|
cnt += 1
|
[{"input": "4\nBAAAAAAAABBABAB", "output": ["16"]}, {"input": "2\nBAA", "output": ["1"]}, {"input": "2\nABA", "output": ["2"]}, {"input": "2\nAAB", "output": ["2"]}, {"input": "2\nAAA", "output": ["1"]}]
|
block_completion_001710
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array $$$a$$$ of $$$n$$$ integers $$$a_1, a_2, a_3, \ldots, a_n$$$.You have to answer $$$q$$$ independent queries, each consisting of two integers $$$l$$$ and $$$r$$$. Consider the subarray $$$a[l:r]$$$ $$$=$$$ $$$[a_l, a_{l+1}, \ldots, a_r]$$$. You can apply the following operation to the subarray any number of times (possibly zero)- Choose two integers $$$L$$$, $$$R$$$ such that $$$l \le L \le R \le r$$$ and $$$R - L + 1$$$ is odd. Replace each element in the subarray from $$$L$$$ to $$$R$$$ with the XOR of the elements in the subarray $$$[L, R]$$$. The answer to the query is the minimum number of operations required to make all elements of the subarray $$$a[l:r]$$$ equal to $$$0$$$ or $$$-1$$$ if it is impossible to make all of them equal to $$$0$$$. You can find more details about XOR operation here.
Input Specification: The first line contains two integers $$$n$$$ and $$$q$$$ $$$(1 \le n, q \le 2 \cdot 10^5)$$$ Β β the length of the array $$$a$$$ and the number of queries. The next line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ $$$(0 \le a_i \lt 2^{30})$$$ Β β the elements of the array $$$a$$$. The $$$i$$$-th of the next $$$q$$$ lines contains two integers $$$l_i$$$ and $$$r_i$$$ $$$(1 \le l_i \le r_i \le n)$$$ Β β the description of the $$$i$$$-th query.
Output Specification: For each query, output a single integer Β β the answer to that query.
Notes: NoteIn the first query, $$$l = 3, r = 4$$$, subarray = $$$[3, 3]$$$. We can apply operation only to the subarrays of length $$$1$$$, which won't change the array; hence it is impossible to make all elements equal to $$$0$$$.In the second query, $$$l = 4, r = 6$$$, subarray = $$$[3, 1, 2]$$$. We can choose the whole subarray $$$(L = 4, R = 6)$$$ and replace all elements by their XOR $$$(3 \oplus 1 \oplus 2) = 0$$$, making the subarray $$$[0, 0, 0]$$$.In the fifth query, $$$l = 1, r = 6$$$, subarray = $$$[3, 0, 3, 3, 1, 2]$$$. We can make the operations as follows: Choose $$$L = 4, R = 6$$$, making the subarray $$$[3, 0, 3, 0, 0, 0]$$$. Choose $$$L = 1, R = 5$$$, making the subarray $$$[0, 0, 0, 0, 0, 0]$$$.
Code:
import sys;I=sys.stdin.readline;R,P,G=lambda:map(int,I().split()),print,range
n,q=R();n+=1;a=[0]+[*R()];p,s,last,oe=[0]*n,[0]*n,[0]*n,[{},{}]
for i in G(1,n):
p[i]=a[i]^p[i-1]
if a[i]==0:s[i]=s[i-1]+1
d=oe[i&1]
if p[i] in d:last[i]=d[p[i]]
oe[i&1][p[i-1]]=i
for _ in G(q):
l,r=R()
if s[r]>=r-l+1:P(0)
elif p[l-1]^p[r] or r-l<2:# TODO: Your code here
elif (r-l)&1==0 or a[l]==0 or a[r]==0:P(1)
elif last[r]>l:P(2)
else:P(-1)
|
import sys;I=sys.stdin.readline;R,P,G=lambda:map(int,I().split()),print,range
n,q=R();n+=1;a=[0]+[*R()];p,s,last,oe=[0]*n,[0]*n,[0]*n,[{},{}]
for i in G(1,n):
p[i]=a[i]^p[i-1]
if a[i]==0:s[i]=s[i-1]+1
d=oe[i&1]
if p[i] in d:last[i]=d[p[i]]
oe[i&1][p[i-1]]=i
for _ in G(q):
l,r=R()
if s[r]>=r-l+1:P(0)
elif p[l-1]^p[r] or r-l<2:{{completion}}
elif (r-l)&1==0 or a[l]==0 or a[r]==0:P(1)
elif last[r]>l:P(2)
else:P(-1)
|
P(-1)
|
[{"input": "7 6\n3 0 3 3 1 2 3\n3 4\n4 6\n3 7\n5 6\n1 6\n2 2", "output": ["-1\n1\n1\n-1\n2\n0"]}]
|
block_completion_001804
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array $$$a$$$ of $$$n$$$ integers $$$a_1, a_2, a_3, \ldots, a_n$$$.You have to answer $$$q$$$ independent queries, each consisting of two integers $$$l$$$ and $$$r$$$. Consider the subarray $$$a[l:r]$$$ $$$=$$$ $$$[a_l, a_{l+1}, \ldots, a_r]$$$. You can apply the following operation to the subarray any number of times (possibly zero)- Choose two integers $$$L$$$, $$$R$$$ such that $$$l \le L \le R \le r$$$ and $$$R - L + 1$$$ is odd. Replace each element in the subarray from $$$L$$$ to $$$R$$$ with the XOR of the elements in the subarray $$$[L, R]$$$. The answer to the query is the minimum number of operations required to make all elements of the subarray $$$a[l:r]$$$ equal to $$$0$$$ or $$$-1$$$ if it is impossible to make all of them equal to $$$0$$$. You can find more details about XOR operation here.
Input Specification: The first line contains two integers $$$n$$$ and $$$q$$$ $$$(1 \le n, q \le 2 \cdot 10^5)$$$ Β β the length of the array $$$a$$$ and the number of queries. The next line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ $$$(0 \le a_i \lt 2^{30})$$$ Β β the elements of the array $$$a$$$. The $$$i$$$-th of the next $$$q$$$ lines contains two integers $$$l_i$$$ and $$$r_i$$$ $$$(1 \le l_i \le r_i \le n)$$$ Β β the description of the $$$i$$$-th query.
Output Specification: For each query, output a single integer Β β the answer to that query.
Notes: NoteIn the first query, $$$l = 3, r = 4$$$, subarray = $$$[3, 3]$$$. We can apply operation only to the subarrays of length $$$1$$$, which won't change the array; hence it is impossible to make all elements equal to $$$0$$$.In the second query, $$$l = 4, r = 6$$$, subarray = $$$[3, 1, 2]$$$. We can choose the whole subarray $$$(L = 4, R = 6)$$$ and replace all elements by their XOR $$$(3 \oplus 1 \oplus 2) = 0$$$, making the subarray $$$[0, 0, 0]$$$.In the fifth query, $$$l = 1, r = 6$$$, subarray = $$$[3, 0, 3, 3, 1, 2]$$$. We can make the operations as follows: Choose $$$L = 4, R = 6$$$, making the subarray $$$[3, 0, 3, 0, 0, 0]$$$. Choose $$$L = 1, R = 5$$$, making the subarray $$$[0, 0, 0, 0, 0, 0]$$$.
Code:
import sys;I=sys.stdin.readline;R,P,G=lambda:map(int,I().split()),print,range
n,q=R();n+=1;a=[0]+[*R()];p,s,last,oe=[0]*n,[0]*n,[0]*n,[{},{}]
for i in G(1,n):
p[i]=a[i]^p[i-1]
if a[i]==0:s[i]=s[i-1]+1
d=oe[i&1]
if p[i] in d:last[i]=d[p[i]]
oe[i&1][p[i-1]]=i
for _ in G(q):
l,r=R()
if s[r]>=r-l+1:P(0)
elif p[l-1]^p[r] or r-l<2:P(-1)
elif (r-l)&1==0 or a[l]==0 or a[r]==0:# TODO: Your code here
elif last[r]>l:P(2)
else:P(-1)
|
import sys;I=sys.stdin.readline;R,P,G=lambda:map(int,I().split()),print,range
n,q=R();n+=1;a=[0]+[*R()];p,s,last,oe=[0]*n,[0]*n,[0]*n,[{},{}]
for i in G(1,n):
p[i]=a[i]^p[i-1]
if a[i]==0:s[i]=s[i-1]+1
d=oe[i&1]
if p[i] in d:last[i]=d[p[i]]
oe[i&1][p[i-1]]=i
for _ in G(q):
l,r=R()
if s[r]>=r-l+1:P(0)
elif p[l-1]^p[r] or r-l<2:P(-1)
elif (r-l)&1==0 or a[l]==0 or a[r]==0:{{completion}}
elif last[r]>l:P(2)
else:P(-1)
|
P(1)
|
[{"input": "7 6\n3 0 3 3 1 2 3\n3 4\n4 6\n3 7\n5 6\n1 6\n2 2", "output": ["-1\n1\n1\n-1\n2\n0"]}]
|
block_completion_001805
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array $$$a$$$ of $$$n$$$ integers $$$a_1, a_2, a_3, \ldots, a_n$$$.You have to answer $$$q$$$ independent queries, each consisting of two integers $$$l$$$ and $$$r$$$. Consider the subarray $$$a[l:r]$$$ $$$=$$$ $$$[a_l, a_{l+1}, \ldots, a_r]$$$. You can apply the following operation to the subarray any number of times (possibly zero)- Choose two integers $$$L$$$, $$$R$$$ such that $$$l \le L \le R \le r$$$ and $$$R - L + 1$$$ is odd. Replace each element in the subarray from $$$L$$$ to $$$R$$$ with the XOR of the elements in the subarray $$$[L, R]$$$. The answer to the query is the minimum number of operations required to make all elements of the subarray $$$a[l:r]$$$ equal to $$$0$$$ or $$$-1$$$ if it is impossible to make all of them equal to $$$0$$$. You can find more details about XOR operation here.
Input Specification: The first line contains two integers $$$n$$$ and $$$q$$$ $$$(1 \le n, q \le 2 \cdot 10^5)$$$ Β β the length of the array $$$a$$$ and the number of queries. The next line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ $$$(0 \le a_i \lt 2^{30})$$$ Β β the elements of the array $$$a$$$. The $$$i$$$-th of the next $$$q$$$ lines contains two integers $$$l_i$$$ and $$$r_i$$$ $$$(1 \le l_i \le r_i \le n)$$$ Β β the description of the $$$i$$$-th query.
Output Specification: For each query, output a single integer Β β the answer to that query.
Notes: NoteIn the first query, $$$l = 3, r = 4$$$, subarray = $$$[3, 3]$$$. We can apply operation only to the subarrays of length $$$1$$$, which won't change the array; hence it is impossible to make all elements equal to $$$0$$$.In the second query, $$$l = 4, r = 6$$$, subarray = $$$[3, 1, 2]$$$. We can choose the whole subarray $$$(L = 4, R = 6)$$$ and replace all elements by their XOR $$$(3 \oplus 1 \oplus 2) = 0$$$, making the subarray $$$[0, 0, 0]$$$.In the fifth query, $$$l = 1, r = 6$$$, subarray = $$$[3, 0, 3, 3, 1, 2]$$$. We can make the operations as follows: Choose $$$L = 4, R = 6$$$, making the subarray $$$[3, 0, 3, 0, 0, 0]$$$. Choose $$$L = 1, R = 5$$$, making the subarray $$$[0, 0, 0, 0, 0, 0]$$$.
Code:
import sys
n, q = [int(i) for i in sys.stdin.readline().split()]
a = [int(i) for i in sys.stdin.readline().split()]
cur = 0
odd = {}
even = {}
last = [-1]*(n+1)
pxor = [0]*(n+1)
psum = [0]*(n+1)
for i, num in enumerate(a):
pxor[i+1] = pxor[i] ^ num
psum[i+1] = psum[i] + num
cur = pxor[i+1]
if i&1 == 0:
if cur in odd:
last[i+1] = odd[cur]
even[cur] = i + 1
else:
if cur in even:
last[i+1] = even[cur]
odd[cur] = i + 1
for _ in range(q):
l, r = [int(i) for i in sys.stdin.readline().split()]
if pxor[l-1] != pxor[r]:
print("-1")
elif psum[l-1] == psum[r]:
print("0")
else:
if (r-l)%2==0:
print("1")
elif a[l-1]==0 or a[r-1]==0:
# TODO: Your code here
elif last[r] >= l:
print("2")
else:
print("-1")
|
import sys
n, q = [int(i) for i in sys.stdin.readline().split()]
a = [int(i) for i in sys.stdin.readline().split()]
cur = 0
odd = {}
even = {}
last = [-1]*(n+1)
pxor = [0]*(n+1)
psum = [0]*(n+1)
for i, num in enumerate(a):
pxor[i+1] = pxor[i] ^ num
psum[i+1] = psum[i] + num
cur = pxor[i+1]
if i&1 == 0:
if cur in odd:
last[i+1] = odd[cur]
even[cur] = i + 1
else:
if cur in even:
last[i+1] = even[cur]
odd[cur] = i + 1
for _ in range(q):
l, r = [int(i) for i in sys.stdin.readline().split()]
if pxor[l-1] != pxor[r]:
print("-1")
elif psum[l-1] == psum[r]:
print("0")
else:
if (r-l)%2==0:
print("1")
elif a[l-1]==0 or a[r-1]==0:
{{completion}}
elif last[r] >= l:
print("2")
else:
print("-1")
|
print("1")
|
[{"input": "7 6\n3 0 3 3 1 2 3\n3 4\n4 6\n3 7\n5 6\n1 6\n2 2", "output": ["-1\n1\n1\n-1\n2\n0"]}]
|
block_completion_001806
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array $$$a$$$ of $$$n$$$ integers $$$a_1, a_2, a_3, \ldots, a_n$$$.You have to answer $$$q$$$ independent queries, each consisting of two integers $$$l$$$ and $$$r$$$. Consider the subarray $$$a[l:r]$$$ $$$=$$$ $$$[a_l, a_{l+1}, \ldots, a_r]$$$. You can apply the following operation to the subarray any number of times (possibly zero)- Choose two integers $$$L$$$, $$$R$$$ such that $$$l \le L \le R \le r$$$ and $$$R - L + 1$$$ is odd. Replace each element in the subarray from $$$L$$$ to $$$R$$$ with the XOR of the elements in the subarray $$$[L, R]$$$. The answer to the query is the minimum number of operations required to make all elements of the subarray $$$a[l:r]$$$ equal to $$$0$$$ or $$$-1$$$ if it is impossible to make all of them equal to $$$0$$$. You can find more details about XOR operation here.
Input Specification: The first line contains two integers $$$n$$$ and $$$q$$$ $$$(1 \le n, q \le 2 \cdot 10^5)$$$ Β β the length of the array $$$a$$$ and the number of queries. The next line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ $$$(0 \le a_i \lt 2^{30})$$$ Β β the elements of the array $$$a$$$. The $$$i$$$-th of the next $$$q$$$ lines contains two integers $$$l_i$$$ and $$$r_i$$$ $$$(1 \le l_i \le r_i \le n)$$$ Β β the description of the $$$i$$$-th query.
Output Specification: For each query, output a single integer Β β the answer to that query.
Notes: NoteIn the first query, $$$l = 3, r = 4$$$, subarray = $$$[3, 3]$$$. We can apply operation only to the subarrays of length $$$1$$$, which won't change the array; hence it is impossible to make all elements equal to $$$0$$$.In the second query, $$$l = 4, r = 6$$$, subarray = $$$[3, 1, 2]$$$. We can choose the whole subarray $$$(L = 4, R = 6)$$$ and replace all elements by their XOR $$$(3 \oplus 1 \oplus 2) = 0$$$, making the subarray $$$[0, 0, 0]$$$.In the fifth query, $$$l = 1, r = 6$$$, subarray = $$$[3, 0, 3, 3, 1, 2]$$$. We can make the operations as follows: Choose $$$L = 4, R = 6$$$, making the subarray $$$[3, 0, 3, 0, 0, 0]$$$. Choose $$$L = 1, R = 5$$$, making the subarray $$$[0, 0, 0, 0, 0, 0]$$$.
Code:
import sys
n, q = [int(i) for i in sys.stdin.readline().split()]
a = [int(i) for i in sys.stdin.readline().split()]
cur = 0
odd = {}
even = {}
last = [-1]*(n+1)
pxor = [0]*(n+1)
psum = [0]*(n+1)
for i, num in enumerate(a):
pxor[i+1] = pxor[i] ^ num
psum[i+1] = psum[i] + num
cur = pxor[i+1]
if i&1 == 0:
if cur in odd:
last[i+1] = odd[cur]
even[cur] = i + 1
else:
if cur in even:
last[i+1] = even[cur]
odd[cur] = i + 1
for _ in range(q):
l, r = [int(i) for i in sys.stdin.readline().split()]
if pxor[l-1] != pxor[r]:
print("-1")
elif psum[l-1] == psum[r]:
print("0")
else:
if (r-l)%2==0:
print("1")
elif a[l-1]==0 or a[r-1]==0:
print("1")
elif last[r] >= l:
# TODO: Your code here
else:
print("-1")
|
import sys
n, q = [int(i) for i in sys.stdin.readline().split()]
a = [int(i) for i in sys.stdin.readline().split()]
cur = 0
odd = {}
even = {}
last = [-1]*(n+1)
pxor = [0]*(n+1)
psum = [0]*(n+1)
for i, num in enumerate(a):
pxor[i+1] = pxor[i] ^ num
psum[i+1] = psum[i] + num
cur = pxor[i+1]
if i&1 == 0:
if cur in odd:
last[i+1] = odd[cur]
even[cur] = i + 1
else:
if cur in even:
last[i+1] = even[cur]
odd[cur] = i + 1
for _ in range(q):
l, r = [int(i) for i in sys.stdin.readline().split()]
if pxor[l-1] != pxor[r]:
print("-1")
elif psum[l-1] == psum[r]:
print("0")
else:
if (r-l)%2==0:
print("1")
elif a[l-1]==0 or a[r-1]==0:
print("1")
elif last[r] >= l:
{{completion}}
else:
print("-1")
|
print("2")
|
[{"input": "7 6\n3 0 3 3 1 2 3\n3 4\n4 6\n3 7\n5 6\n1 6\n2 2", "output": ["-1\n1\n1\n-1\n2\n0"]}]
|
block_completion_001807
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array $$$a$$$ of $$$n$$$ integers $$$a_1, a_2, a_3, \ldots, a_n$$$.You have to answer $$$q$$$ independent queries, each consisting of two integers $$$l$$$ and $$$r$$$. Consider the subarray $$$a[l:r]$$$ $$$=$$$ $$$[a_l, a_{l+1}, \ldots, a_r]$$$. You can apply the following operation to the subarray any number of times (possibly zero)- Choose two integers $$$L$$$, $$$R$$$ such that $$$l \le L \le R \le r$$$ and $$$R - L + 1$$$ is odd. Replace each element in the subarray from $$$L$$$ to $$$R$$$ with the XOR of the elements in the subarray $$$[L, R]$$$. The answer to the query is the minimum number of operations required to make all elements of the subarray $$$a[l:r]$$$ equal to $$$0$$$ or $$$-1$$$ if it is impossible to make all of them equal to $$$0$$$. You can find more details about XOR operation here.
Input Specification: The first line contains two integers $$$n$$$ and $$$q$$$ $$$(1 \le n, q \le 2 \cdot 10^5)$$$ Β β the length of the array $$$a$$$ and the number of queries. The next line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ $$$(0 \le a_i \lt 2^{30})$$$ Β β the elements of the array $$$a$$$. The $$$i$$$-th of the next $$$q$$$ lines contains two integers $$$l_i$$$ and $$$r_i$$$ $$$(1 \le l_i \le r_i \le n)$$$ Β β the description of the $$$i$$$-th query.
Output Specification: For each query, output a single integer Β β the answer to that query.
Notes: NoteIn the first query, $$$l = 3, r = 4$$$, subarray = $$$[3, 3]$$$. We can apply operation only to the subarrays of length $$$1$$$, which won't change the array; hence it is impossible to make all elements equal to $$$0$$$.In the second query, $$$l = 4, r = 6$$$, subarray = $$$[3, 1, 2]$$$. We can choose the whole subarray $$$(L = 4, R = 6)$$$ and replace all elements by their XOR $$$(3 \oplus 1 \oplus 2) = 0$$$, making the subarray $$$[0, 0, 0]$$$.In the fifth query, $$$l = 1, r = 6$$$, subarray = $$$[3, 0, 3, 3, 1, 2]$$$. We can make the operations as follows: Choose $$$L = 4, R = 6$$$, making the subarray $$$[3, 0, 3, 0, 0, 0]$$$. Choose $$$L = 1, R = 5$$$, making the subarray $$$[0, 0, 0, 0, 0, 0]$$$.
Code:
import sys
input = sys.stdin.readline
n,q = map(int,input().split())
a = [0] + list(map(int,input().split()))
cml = a[::1]
for i in range(1, n+1):
a[i] ^= a[i-1]
cml[i] += cml[i-1]
qs = [list(map(int,input().split())) for i in range(q)]
from collections import defaultdict
d = defaultdict(list)
dd = defaultdict(list)
cnt = defaultdict(int)
ord = [0]*(n+1)
for i in range(n+1):
dd[a[i]].append(i % 2)
cnt[a[i]] += 1
ord[i] = cnt[a[i]]
for k,v in dd.items():
dd[k] = [0] + v
for i in range(len(v)+1):
if i == 0: continue
else:
dd[k][i] += dd[k][i-1]
for l,r in qs:
if a[r] != a[l-1]:
print(-1)
else:
if cml[r] - cml[l-1] == 0:
print(0)
elif (r-l) % 2 == 0 or a[l] == a[l-1] or a[r] == a[r-1]:
print(1)
else:
ll = ord[l-1]-1
rr = ord[r]
tot = dd[a[r]][rr] - dd[a[r]][ll]
if tot == rr-ll or tot == 0:
print(-1)
else:
# TODO: Your code here
|
import sys
input = sys.stdin.readline
n,q = map(int,input().split())
a = [0] + list(map(int,input().split()))
cml = a[::1]
for i in range(1, n+1):
a[i] ^= a[i-1]
cml[i] += cml[i-1]
qs = [list(map(int,input().split())) for i in range(q)]
from collections import defaultdict
d = defaultdict(list)
dd = defaultdict(list)
cnt = defaultdict(int)
ord = [0]*(n+1)
for i in range(n+1):
dd[a[i]].append(i % 2)
cnt[a[i]] += 1
ord[i] = cnt[a[i]]
for k,v in dd.items():
dd[k] = [0] + v
for i in range(len(v)+1):
if i == 0: continue
else:
dd[k][i] += dd[k][i-1]
for l,r in qs:
if a[r] != a[l-1]:
print(-1)
else:
if cml[r] - cml[l-1] == 0:
print(0)
elif (r-l) % 2 == 0 or a[l] == a[l-1] or a[r] == a[r-1]:
print(1)
else:
ll = ord[l-1]-1
rr = ord[r]
tot = dd[a[r]][rr] - dd[a[r]][ll]
if tot == rr-ll or tot == 0:
print(-1)
else:
{{completion}}
|
print(2)
|
[{"input": "7 6\n3 0 3 3 1 2 3\n3 4\n4 6\n3 7\n5 6\n1 6\n2 2", "output": ["-1\n1\n1\n-1\n2\n0"]}]
|
block_completion_001808
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array $$$a$$$ of $$$n$$$ integers $$$a_1, a_2, a_3, \ldots, a_n$$$.You have to answer $$$q$$$ independent queries, each consisting of two integers $$$l$$$ and $$$r$$$. Consider the subarray $$$a[l:r]$$$ $$$=$$$ $$$[a_l, a_{l+1}, \ldots, a_r]$$$. You can apply the following operation to the subarray any number of times (possibly zero)- Choose two integers $$$L$$$, $$$R$$$ such that $$$l \le L \le R \le r$$$ and $$$R - L + 1$$$ is odd. Replace each element in the subarray from $$$L$$$ to $$$R$$$ with the XOR of the elements in the subarray $$$[L, R]$$$. The answer to the query is the minimum number of operations required to make all elements of the subarray $$$a[l:r]$$$ equal to $$$0$$$ or $$$-1$$$ if it is impossible to make all of them equal to $$$0$$$. You can find more details about XOR operation here.
Input Specification: The first line contains two integers $$$n$$$ and $$$q$$$ $$$(1 \le n, q \le 2 \cdot 10^5)$$$ Β β the length of the array $$$a$$$ and the number of queries. The next line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ $$$(0 \le a_i \lt 2^{30})$$$ Β β the elements of the array $$$a$$$. The $$$i$$$-th of the next $$$q$$$ lines contains two integers $$$l_i$$$ and $$$r_i$$$ $$$(1 \le l_i \le r_i \le n)$$$ Β β the description of the $$$i$$$-th query.
Output Specification: For each query, output a single integer Β β the answer to that query.
Notes: NoteIn the first query, $$$l = 3, r = 4$$$, subarray = $$$[3, 3]$$$. We can apply operation only to the subarrays of length $$$1$$$, which won't change the array; hence it is impossible to make all elements equal to $$$0$$$.In the second query, $$$l = 4, r = 6$$$, subarray = $$$[3, 1, 2]$$$. We can choose the whole subarray $$$(L = 4, R = 6)$$$ and replace all elements by their XOR $$$(3 \oplus 1 \oplus 2) = 0$$$, making the subarray $$$[0, 0, 0]$$$.In the fifth query, $$$l = 1, r = 6$$$, subarray = $$$[3, 0, 3, 3, 1, 2]$$$. We can make the operations as follows: Choose $$$L = 4, R = 6$$$, making the subarray $$$[3, 0, 3, 0, 0, 0]$$$. Choose $$$L = 1, R = 5$$$, making the subarray $$$[0, 0, 0, 0, 0, 0]$$$.
Code:
import sys
def input():
return sys.stdin.readline().strip()
n, q = map(int, input().split())
a = list(map(int, input().split()))
b, s = [0], [0]
nx = [n+5] * (n + 1)
d = {0: [0]}
for i, e in enumerate(a):
bx = b[-1]^e
sx = s[-1] + e
b.append(bx)
s.append(sx)
if bx in d.keys():
if (i + 1 - d[bx][-1]) % 2 == 0:
d[bx].append(i + 1)
else:
for x in d[bx]:
nx[x] = i + 1
d[bx] = [i + 1]
else:
d[bx] = [i + 1]
# print(nx)
for i in range(q):
l, r = map(int, input().split())
if b[r] != b[l-1]:
sys.stdout.write("-1\n")
else:
if s[r] - s[l-1] == 0:
sys.stdout.write("0\n")
elif (r - l + 1) % 2:
sys.stdout.write("1\n")
else:
if a[l - 1]*a[r - 1] == 0:
sys.stdout.write("1\n")
elif nx[l-1] <= r:
# TODO: Your code here
else:
sys.stdout.write("-1\n")
|
import sys
def input():
return sys.stdin.readline().strip()
n, q = map(int, input().split())
a = list(map(int, input().split()))
b, s = [0], [0]
nx = [n+5] * (n + 1)
d = {0: [0]}
for i, e in enumerate(a):
bx = b[-1]^e
sx = s[-1] + e
b.append(bx)
s.append(sx)
if bx in d.keys():
if (i + 1 - d[bx][-1]) % 2 == 0:
d[bx].append(i + 1)
else:
for x in d[bx]:
nx[x] = i + 1
d[bx] = [i + 1]
else:
d[bx] = [i + 1]
# print(nx)
for i in range(q):
l, r = map(int, input().split())
if b[r] != b[l-1]:
sys.stdout.write("-1\n")
else:
if s[r] - s[l-1] == 0:
sys.stdout.write("0\n")
elif (r - l + 1) % 2:
sys.stdout.write("1\n")
else:
if a[l - 1]*a[r - 1] == 0:
sys.stdout.write("1\n")
elif nx[l-1] <= r:
{{completion}}
else:
sys.stdout.write("-1\n")
|
sys.stdout.write("2\n")
|
[{"input": "7 6\n3 0 3 3 1 2 3\n3 4\n4 6\n3 7\n5 6\n1 6\n2 2", "output": ["-1\n1\n1\n-1\n2\n0"]}]
|
block_completion_001809
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array $$$a$$$ of $$$n$$$ integers $$$a_1, a_2, a_3, \ldots, a_n$$$.You have to answer $$$q$$$ independent queries, each consisting of two integers $$$l$$$ and $$$r$$$. Consider the subarray $$$a[l:r]$$$ $$$=$$$ $$$[a_l, a_{l+1}, \ldots, a_r]$$$. You can apply the following operation to the subarray any number of times (possibly zero)- Choose two integers $$$L$$$, $$$R$$$ such that $$$l \le L \le R \le r$$$ and $$$R - L + 1$$$ is odd. Replace each element in the subarray from $$$L$$$ to $$$R$$$ with the XOR of the elements in the subarray $$$[L, R]$$$. The answer to the query is the minimum number of operations required to make all elements of the subarray $$$a[l:r]$$$ equal to $$$0$$$ or $$$-1$$$ if it is impossible to make all of them equal to $$$0$$$. You can find more details about XOR operation here.
Input Specification: The first line contains two integers $$$n$$$ and $$$q$$$ $$$(1 \le n, q \le 2 \cdot 10^5)$$$ Β β the length of the array $$$a$$$ and the number of queries. The next line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ $$$(0 \le a_i \lt 2^{30})$$$ Β β the elements of the array $$$a$$$. The $$$i$$$-th of the next $$$q$$$ lines contains two integers $$$l_i$$$ and $$$r_i$$$ $$$(1 \le l_i \le r_i \le n)$$$ Β β the description of the $$$i$$$-th query.
Output Specification: For each query, output a single integer Β β the answer to that query.
Notes: NoteIn the first query, $$$l = 3, r = 4$$$, subarray = $$$[3, 3]$$$. We can apply operation only to the subarrays of length $$$1$$$, which won't change the array; hence it is impossible to make all elements equal to $$$0$$$.In the second query, $$$l = 4, r = 6$$$, subarray = $$$[3, 1, 2]$$$. We can choose the whole subarray $$$(L = 4, R = 6)$$$ and replace all elements by their XOR $$$(3 \oplus 1 \oplus 2) = 0$$$, making the subarray $$$[0, 0, 0]$$$.In the fifth query, $$$l = 1, r = 6$$$, subarray = $$$[3, 0, 3, 3, 1, 2]$$$. We can make the operations as follows: Choose $$$L = 4, R = 6$$$, making the subarray $$$[3, 0, 3, 0, 0, 0]$$$. Choose $$$L = 1, R = 5$$$, making the subarray $$$[0, 0, 0, 0, 0, 0]$$$.
Code:
import sys
def input():
return sys.stdin.readline().strip()
n, q = map(int, input().split())
a = list(map(int, input().split()))
b, s = [0], [0]
nx = [n+5] * (n + 1)
d = {0: [0]}
for i, e in enumerate(a):
bx = b[-1]^e
sx = s[-1] + e
b.append(bx)
s.append(sx)
if bx in d.keys():
if (i + 1 - d[bx][-1]) % 2 == 0:
d[bx].append(i + 1)
else:
for x in d[bx]:
nx[x] = i + 1
d[bx] = [i + 1]
else:
d[bx] = [i + 1]
# print(nx)
for i in range(q):
l, r = map(int, input().split())
if b[r] != b[l-1]:
sys.stdout.write("-1\n")
else:
if s[r] - s[l-1] == 0:
sys.stdout.write("0\n")
elif (r - l + 1) % 2:
sys.stdout.write("1\n")
else:
if a[l - 1]*a[r - 1] == 0:
sys.stdout.write("1\n")
elif nx[l-1] <= r:
sys.stdout.write("2\n")
else:
# TODO: Your code here
|
import sys
def input():
return sys.stdin.readline().strip()
n, q = map(int, input().split())
a = list(map(int, input().split()))
b, s = [0], [0]
nx = [n+5] * (n + 1)
d = {0: [0]}
for i, e in enumerate(a):
bx = b[-1]^e
sx = s[-1] + e
b.append(bx)
s.append(sx)
if bx in d.keys():
if (i + 1 - d[bx][-1]) % 2 == 0:
d[bx].append(i + 1)
else:
for x in d[bx]:
nx[x] = i + 1
d[bx] = [i + 1]
else:
d[bx] = [i + 1]
# print(nx)
for i in range(q):
l, r = map(int, input().split())
if b[r] != b[l-1]:
sys.stdout.write("-1\n")
else:
if s[r] - s[l-1] == 0:
sys.stdout.write("0\n")
elif (r - l + 1) % 2:
sys.stdout.write("1\n")
else:
if a[l - 1]*a[r - 1] == 0:
sys.stdout.write("1\n")
elif nx[l-1] <= r:
sys.stdout.write("2\n")
else:
{{completion}}
|
sys.stdout.write("-1\n")
|
[{"input": "7 6\n3 0 3 3 1 2 3\n3 4\n4 6\n3 7\n5 6\n1 6\n2 2", "output": ["-1\n1\n1\n-1\n2\n0"]}]
|
block_completion_001810
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an array $$$a$$$ of $$$n$$$ integers $$$a_1, a_2, a_3, \ldots, a_n$$$.You have to answer $$$q$$$ independent queries, each consisting of two integers $$$l$$$ and $$$r$$$. Consider the subarray $$$a[l:r]$$$ $$$=$$$ $$$[a_l, a_{l+1}, \ldots, a_r]$$$. You can apply the following operation to the subarray any number of times (possibly zero)- Choose two integers $$$L$$$, $$$R$$$ such that $$$l \le L \le R \le r$$$ and $$$R - L + 1$$$ is odd. Replace each element in the subarray from $$$L$$$ to $$$R$$$ with the XOR of the elements in the subarray $$$[L, R]$$$. The answer to the query is the minimum number of operations required to make all elements of the subarray $$$a[l:r]$$$ equal to $$$0$$$ or $$$-1$$$ if it is impossible to make all of them equal to $$$0$$$. You can find more details about XOR operation here.
Input Specification: The first line contains two integers $$$n$$$ and $$$q$$$ $$$(1 \le n, q \le 2 \cdot 10^5)$$$ Β β the length of the array $$$a$$$ and the number of queries. The next line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ $$$(0 \le a_i \lt 2^{30})$$$ Β β the elements of the array $$$a$$$. The $$$i$$$-th of the next $$$q$$$ lines contains two integers $$$l_i$$$ and $$$r_i$$$ $$$(1 \le l_i \le r_i \le n)$$$ Β β the description of the $$$i$$$-th query.
Output Specification: For each query, output a single integer Β β the answer to that query.
Notes: NoteIn the first query, $$$l = 3, r = 4$$$, subarray = $$$[3, 3]$$$. We can apply operation only to the subarrays of length $$$1$$$, which won't change the array; hence it is impossible to make all elements equal to $$$0$$$.In the second query, $$$l = 4, r = 6$$$, subarray = $$$[3, 1, 2]$$$. We can choose the whole subarray $$$(L = 4, R = 6)$$$ and replace all elements by their XOR $$$(3 \oplus 1 \oplus 2) = 0$$$, making the subarray $$$[0, 0, 0]$$$.In the fifth query, $$$l = 1, r = 6$$$, subarray = $$$[3, 0, 3, 3, 1, 2]$$$. We can make the operations as follows: Choose $$$L = 4, R = 6$$$, making the subarray $$$[3, 0, 3, 0, 0, 0]$$$. Choose $$$L = 1, R = 5$$$, making the subarray $$$[0, 0, 0, 0, 0, 0]$$$.
Code:
import collections
import sys
input = sys.stdin.readline
def sol(arr, n, m, q):
xor = [0]
curr = 0
for i in arr:
curr ^= i
xor.append(curr)
pre = [0]
curr = 0
for i in arr:
curr += i
pre.append(curr)
qd = collections.defaultdict(list)
for i in range(m):
qd[q[i][1]].append((q[i][0], i))
res = [-1] * m
last = [collections.defaultdict(int), collections.defaultdict(int)]
for r in range(1, n + 1):
last[r & 1][xor[r]] = r
for l, i in qd[r]:
if xor[r] ^ xor[l - 1] != 0:
res[i] = (-1)
elif pre[r] == pre[l - 1]:
res[i] = (0)
elif (r - l) & 1 and arr[l - 1] and arr[r - 1]:
if last[(r & 1) ^ 1][xor[r]] >= l:
res[i] = (2)
else:
# TODO: Your code here
else:
res[i] = (1)
for i in res:
print(i)
n, m = list(map(int,input().split()))
arr = list(map(int,input().split()))
q = []
for i in range(m):
q.append(list(map(int,input().split())))
(sol(arr, n, m, q))
|
import collections
import sys
input = sys.stdin.readline
def sol(arr, n, m, q):
xor = [0]
curr = 0
for i in arr:
curr ^= i
xor.append(curr)
pre = [0]
curr = 0
for i in arr:
curr += i
pre.append(curr)
qd = collections.defaultdict(list)
for i in range(m):
qd[q[i][1]].append((q[i][0], i))
res = [-1] * m
last = [collections.defaultdict(int), collections.defaultdict(int)]
for r in range(1, n + 1):
last[r & 1][xor[r]] = r
for l, i in qd[r]:
if xor[r] ^ xor[l - 1] != 0:
res[i] = (-1)
elif pre[r] == pre[l - 1]:
res[i] = (0)
elif (r - l) & 1 and arr[l - 1] and arr[r - 1]:
if last[(r & 1) ^ 1][xor[r]] >= l:
res[i] = (2)
else:
{{completion}}
else:
res[i] = (1)
for i in res:
print(i)
n, m = list(map(int,input().split()))
arr = list(map(int,input().split()))
q = []
for i in range(m):
q.append(list(map(int,input().split())))
(sol(arr, n, m, q))
|
res[i] = (-1)
|
[{"input": "7 6\n3 0 3 3 1 2 3\n3 4\n4 6\n3 7\n5 6\n1 6\n2 2", "output": ["-1\n1\n1\n-1\n2\n0"]}]
|
block_completion_001811
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$n$$$.Let's define $$$s(n)$$$ as the string "BAN" concatenated $$$n$$$ times. For example, $$$s(1)$$$ = "BAN", $$$s(3)$$$ = "BANBANBAN". Note that the length of the string $$$s(n)$$$ is equal to $$$3n$$$.Consider $$$s(n)$$$. You can perform the following operation on $$$s(n)$$$ any number of times (possibly zero): Select any two distinct indices $$$i$$$ and $$$j$$$ $$$(1 \leq i, j \leq 3n, i \ne j)$$$. Then, swap $$$s(n)_i$$$ and $$$s(n)_j$$$. You want the string "BAN" to not appear in $$$s(n)$$$ as a subsequence. What's the smallest number of operations you have to do to achieve this? Also, find one such shortest sequence of operations.A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 100)$$$ Β β the number of test cases. The description of the test cases follows. The only line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$.
Output Specification: For each test case, in the first line output $$$m$$$ ($$$0 \le m \le 10^5$$$)Β β the minimum number of operations required. It's guaranteed that the objective is always achievable in at most $$$10^5$$$ operations under the constraints of the problem. Then, output $$$m$$$ lines. The $$$k$$$-th of these lines should contain two integers $$$i_k$$$, $$$j_k$$$ $$$(1\leq i_k, j_k \leq 3n, i_k \ne j_k)$$$ denoting that you want to swap characters at indices $$$i_k$$$ and $$$j_k$$$ at the $$$k$$$-th operation. After all $$$m$$$ operations, "BAN" must not appear in $$$s(n)$$$ as a subsequence. If there are multiple possible answers, output any.
Notes: NoteIn the first testcase, $$$s(1) = $$$ "BAN", we can swap $$$s(1)_1$$$ and $$$s(1)_2$$$, converting $$$s(1)$$$ to "ABN", which does not contain "BAN" as a subsequence.In the second testcase, $$$s(2) = $$$ "BANBAN", we can swap $$$s(2)_2$$$ and $$$s(2)_6$$$, converting $$$s(2)$$$ to "BNNBAA", which does not contain "BAN" as a subsequence.
Code:
for t in range(int(input())):
n = int(input())
if n == 1:
# TODO: Your code here
i = 2
j = 3*n
ans = []
while i<j:
ans.append((i,j))
i += 3
j -= 3
print(len(ans))
for i in ans:
print(i[0],i[1])
|
for t in range(int(input())):
n = int(input())
if n == 1:
{{completion}}
i = 2
j = 3*n
ans = []
while i<j:
ans.append((i,j))
i += 3
j -= 3
print(len(ans))
for i in ans:
print(i[0],i[1])
|
print("1\n1 2")
continue
|
[{"input": "2\n1\n2", "output": ["1\n1 2\n1\n2 6"]}]
|
block_completion_001826
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$n$$$.Let's define $$$s(n)$$$ as the string "BAN" concatenated $$$n$$$ times. For example, $$$s(1)$$$ = "BAN", $$$s(3)$$$ = "BANBANBAN". Note that the length of the string $$$s(n)$$$ is equal to $$$3n$$$.Consider $$$s(n)$$$. You can perform the following operation on $$$s(n)$$$ any number of times (possibly zero): Select any two distinct indices $$$i$$$ and $$$j$$$ $$$(1 \leq i, j \leq 3n, i \ne j)$$$. Then, swap $$$s(n)_i$$$ and $$$s(n)_j$$$. You want the string "BAN" to not appear in $$$s(n)$$$ as a subsequence. What's the smallest number of operations you have to do to achieve this? Also, find one such shortest sequence of operations.A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 100)$$$ Β β the number of test cases. The description of the test cases follows. The only line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$.
Output Specification: For each test case, in the first line output $$$m$$$ ($$$0 \le m \le 10^5$$$)Β β the minimum number of operations required. It's guaranteed that the objective is always achievable in at most $$$10^5$$$ operations under the constraints of the problem. Then, output $$$m$$$ lines. The $$$k$$$-th of these lines should contain two integers $$$i_k$$$, $$$j_k$$$ $$$(1\leq i_k, j_k \leq 3n, i_k \ne j_k)$$$ denoting that you want to swap characters at indices $$$i_k$$$ and $$$j_k$$$ at the $$$k$$$-th operation. After all $$$m$$$ operations, "BAN" must not appear in $$$s(n)$$$ as a subsequence. If there are multiple possible answers, output any.
Notes: NoteIn the first testcase, $$$s(1) = $$$ "BAN", we can swap $$$s(1)_1$$$ and $$$s(1)_2$$$, converting $$$s(1)$$$ to "ABN", which does not contain "BAN" as a subsequence.In the second testcase, $$$s(2) = $$$ "BANBAN", we can swap $$$s(2)_2$$$ and $$$s(2)_6$$$, converting $$$s(2)$$$ to "BNNBAA", which does not contain "BAN" as a subsequence.
Code:
for t in range(int(input())):
n = int(input())
if n == 1:
print("1\n1 2")
continue
i = 2
j = 3*n
ans = []
while i<j:
# TODO: Your code here
print(len(ans))
for i in ans:
print(i[0],i[1])
|
for t in range(int(input())):
n = int(input())
if n == 1:
print("1\n1 2")
continue
i = 2
j = 3*n
ans = []
while i<j:
{{completion}}
print(len(ans))
for i in ans:
print(i[0],i[1])
|
ans.append((i,j))
i += 3
j -= 3
|
[{"input": "2\n1\n2", "output": ["1\n1 2\n1\n2 6"]}]
|
block_completion_001827
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$n$$$.Let's define $$$s(n)$$$ as the string "BAN" concatenated $$$n$$$ times. For example, $$$s(1)$$$ = "BAN", $$$s(3)$$$ = "BANBANBAN". Note that the length of the string $$$s(n)$$$ is equal to $$$3n$$$.Consider $$$s(n)$$$. You can perform the following operation on $$$s(n)$$$ any number of times (possibly zero): Select any two distinct indices $$$i$$$ and $$$j$$$ $$$(1 \leq i, j \leq 3n, i \ne j)$$$. Then, swap $$$s(n)_i$$$ and $$$s(n)_j$$$. You want the string "BAN" to not appear in $$$s(n)$$$ as a subsequence. What's the smallest number of operations you have to do to achieve this? Also, find one such shortest sequence of operations.A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 100)$$$ Β β the number of test cases. The description of the test cases follows. The only line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$.
Output Specification: For each test case, in the first line output $$$m$$$ ($$$0 \le m \le 10^5$$$)Β β the minimum number of operations required. It's guaranteed that the objective is always achievable in at most $$$10^5$$$ operations under the constraints of the problem. Then, output $$$m$$$ lines. The $$$k$$$-th of these lines should contain two integers $$$i_k$$$, $$$j_k$$$ $$$(1\leq i_k, j_k \leq 3n, i_k \ne j_k)$$$ denoting that you want to swap characters at indices $$$i_k$$$ and $$$j_k$$$ at the $$$k$$$-th operation. After all $$$m$$$ operations, "BAN" must not appear in $$$s(n)$$$ as a subsequence. If there are multiple possible answers, output any.
Notes: NoteIn the first testcase, $$$s(1) = $$$ "BAN", we can swap $$$s(1)_1$$$ and $$$s(1)_2$$$, converting $$$s(1)$$$ to "ABN", which does not contain "BAN" as a subsequence.In the second testcase, $$$s(2) = $$$ "BANBAN", we can swap $$$s(2)_2$$$ and $$$s(2)_6$$$, converting $$$s(2)$$$ to "BNNBAA", which does not contain "BAN" as a subsequence.
Code:
t = int(input())
for i in range(t):
n = int(input())
if n == 1:
print(1)
print(1,2)
elif n%2 :
print(int((n+1)/2))
for e in range(2, int((3 * n + 1)/2) + 1, 3):
# TODO: Your code here
else :
print(int(n/2))
for e in range(2, int((3 * n + 1)/2) + 1, 3):
print(e,e + int(3*n/2) + 1)
|
t = int(input())
for i in range(t):
n = int(input())
if n == 1:
print(1)
print(1,2)
elif n%2 :
print(int((n+1)/2))
for e in range(2, int((3 * n + 1)/2) + 1, 3):
{{completion}}
else :
print(int(n/2))
for e in range(2, int((3 * n + 1)/2) + 1, 3):
print(e,e + int(3*n/2) + 1)
|
print(e,e + int((3*n)/2))
|
[{"input": "2\n1\n2", "output": ["1\n1 2\n1\n2 6"]}]
|
block_completion_001828
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$n$$$.Let's define $$$s(n)$$$ as the string "BAN" concatenated $$$n$$$ times. For example, $$$s(1)$$$ = "BAN", $$$s(3)$$$ = "BANBANBAN". Note that the length of the string $$$s(n)$$$ is equal to $$$3n$$$.Consider $$$s(n)$$$. You can perform the following operation on $$$s(n)$$$ any number of times (possibly zero): Select any two distinct indices $$$i$$$ and $$$j$$$ $$$(1 \leq i, j \leq 3n, i \ne j)$$$. Then, swap $$$s(n)_i$$$ and $$$s(n)_j$$$. You want the string "BAN" to not appear in $$$s(n)$$$ as a subsequence. What's the smallest number of operations you have to do to achieve this? Also, find one such shortest sequence of operations.A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 100)$$$ Β β the number of test cases. The description of the test cases follows. The only line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$.
Output Specification: For each test case, in the first line output $$$m$$$ ($$$0 \le m \le 10^5$$$)Β β the minimum number of operations required. It's guaranteed that the objective is always achievable in at most $$$10^5$$$ operations under the constraints of the problem. Then, output $$$m$$$ lines. The $$$k$$$-th of these lines should contain two integers $$$i_k$$$, $$$j_k$$$ $$$(1\leq i_k, j_k \leq 3n, i_k \ne j_k)$$$ denoting that you want to swap characters at indices $$$i_k$$$ and $$$j_k$$$ at the $$$k$$$-th operation. After all $$$m$$$ operations, "BAN" must not appear in $$$s(n)$$$ as a subsequence. If there are multiple possible answers, output any.
Notes: NoteIn the first testcase, $$$s(1) = $$$ "BAN", we can swap $$$s(1)_1$$$ and $$$s(1)_2$$$, converting $$$s(1)$$$ to "ABN", which does not contain "BAN" as a subsequence.In the second testcase, $$$s(2) = $$$ "BANBAN", we can swap $$$s(2)_2$$$ and $$$s(2)_6$$$, converting $$$s(2)$$$ to "BNNBAA", which does not contain "BAN" as a subsequence.
Code:
t = int(input())
for i in range(t):
n = int(input())
if n == 1:
print(1)
print(1,2)
elif n%2 :
print(int((n+1)/2))
for e in range(2, int((3 * n + 1)/2) + 1, 3):
print(e,e + int((3*n)/2))
else :
print(int(n/2))
for e in range(2, int((3 * n + 1)/2) + 1, 3):
# TODO: Your code here
|
t = int(input())
for i in range(t):
n = int(input())
if n == 1:
print(1)
print(1,2)
elif n%2 :
print(int((n+1)/2))
for e in range(2, int((3 * n + 1)/2) + 1, 3):
print(e,e + int((3*n)/2))
else :
print(int(n/2))
for e in range(2, int((3 * n + 1)/2) + 1, 3):
{{completion}}
|
print(e,e + int(3*n/2) + 1)
|
[{"input": "2\n1\n2", "output": ["1\n1 2\n1\n2 6"]}]
|
block_completion_001829
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$n$$$.Let's define $$$s(n)$$$ as the string "BAN" concatenated $$$n$$$ times. For example, $$$s(1)$$$ = "BAN", $$$s(3)$$$ = "BANBANBAN". Note that the length of the string $$$s(n)$$$ is equal to $$$3n$$$.Consider $$$s(n)$$$. You can perform the following operation on $$$s(n)$$$ any number of times (possibly zero): Select any two distinct indices $$$i$$$ and $$$j$$$ $$$(1 \leq i, j \leq 3n, i \ne j)$$$. Then, swap $$$s(n)_i$$$ and $$$s(n)_j$$$. You want the string "BAN" to not appear in $$$s(n)$$$ as a subsequence. What's the smallest number of operations you have to do to achieve this? Also, find one such shortest sequence of operations.A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 100)$$$ Β β the number of test cases. The description of the test cases follows. The only line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$.
Output Specification: For each test case, in the first line output $$$m$$$ ($$$0 \le m \le 10^5$$$)Β β the minimum number of operations required. It's guaranteed that the objective is always achievable in at most $$$10^5$$$ operations under the constraints of the problem. Then, output $$$m$$$ lines. The $$$k$$$-th of these lines should contain two integers $$$i_k$$$, $$$j_k$$$ $$$(1\leq i_k, j_k \leq 3n, i_k \ne j_k)$$$ denoting that you want to swap characters at indices $$$i_k$$$ and $$$j_k$$$ at the $$$k$$$-th operation. After all $$$m$$$ operations, "BAN" must not appear in $$$s(n)$$$ as a subsequence. If there are multiple possible answers, output any.
Notes: NoteIn the first testcase, $$$s(1) = $$$ "BAN", we can swap $$$s(1)_1$$$ and $$$s(1)_2$$$, converting $$$s(1)$$$ to "ABN", which does not contain "BAN" as a subsequence.In the second testcase, $$$s(2) = $$$ "BANBAN", we can swap $$$s(2)_2$$$ and $$$s(2)_6$$$, converting $$$s(2)$$$ to "BNNBAA", which does not contain "BAN" as a subsequence.
Code:
import math
for _ in [0]*int(input()):
n=int(input())
if n==1:
print("1")
print("1 2")
elif n==2:
print("1")
print("2 6")
else:
d=math.ceil(n/2)
print(d)
i=1
j=3*n
for _ in range(d):
# TODO: Your code here
|
import math
for _ in [0]*int(input()):
n=int(input())
if n==1:
print("1")
print("1 2")
elif n==2:
print("1")
print("2 6")
else:
d=math.ceil(n/2)
print(d)
i=1
j=3*n
for _ in range(d):
{{completion}}
|
print(str(i)+" "+str(j))
i+=3
j-=3
|
[{"input": "2\n1\n2", "output": ["1\n1 2\n1\n2 6"]}]
|
block_completion_001830
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$n$$$.Let's define $$$s(n)$$$ as the string "BAN" concatenated $$$n$$$ times. For example, $$$s(1)$$$ = "BAN", $$$s(3)$$$ = "BANBANBAN". Note that the length of the string $$$s(n)$$$ is equal to $$$3n$$$.Consider $$$s(n)$$$. You can perform the following operation on $$$s(n)$$$ any number of times (possibly zero): Select any two distinct indices $$$i$$$ and $$$j$$$ $$$(1 \leq i, j \leq 3n, i \ne j)$$$. Then, swap $$$s(n)_i$$$ and $$$s(n)_j$$$. You want the string "BAN" to not appear in $$$s(n)$$$ as a subsequence. What's the smallest number of operations you have to do to achieve this? Also, find one such shortest sequence of operations.A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 100)$$$ Β β the number of test cases. The description of the test cases follows. The only line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$.
Output Specification: For each test case, in the first line output $$$m$$$ ($$$0 \le m \le 10^5$$$)Β β the minimum number of operations required. It's guaranteed that the objective is always achievable in at most $$$10^5$$$ operations under the constraints of the problem. Then, output $$$m$$$ lines. The $$$k$$$-th of these lines should contain two integers $$$i_k$$$, $$$j_k$$$ $$$(1\leq i_k, j_k \leq 3n, i_k \ne j_k)$$$ denoting that you want to swap characters at indices $$$i_k$$$ and $$$j_k$$$ at the $$$k$$$-th operation. After all $$$m$$$ operations, "BAN" must not appear in $$$s(n)$$$ as a subsequence. If there are multiple possible answers, output any.
Notes: NoteIn the first testcase, $$$s(1) = $$$ "BAN", we can swap $$$s(1)_1$$$ and $$$s(1)_2$$$, converting $$$s(1)$$$ to "ABN", which does not contain "BAN" as a subsequence.In the second testcase, $$$s(2) = $$$ "BANBAN", we can swap $$$s(2)_2$$$ and $$$s(2)_6$$$, converting $$$s(2)$$$ to "BNNBAA", which does not contain "BAN" as a subsequence.
Code:
from sys import stdin
t = int(stdin.readline().strip())
for i in range(t):
n = int(stdin.readline().strip())
b = list('ban'*n)
if n==1:
print(1)
print(1, 2)
else:
z = n*3-1
print(n//2+n%2)
for i3 in range(n//2+n%2):
for i2 in range(n*3):
if b[i2]=='a':
# TODO: Your code here
|
from sys import stdin
t = int(stdin.readline().strip())
for i in range(t):
n = int(stdin.readline().strip())
b = list('ban'*n)
if n==1:
print(1)
print(1, 2)
else:
z = n*3-1
print(n//2+n%2)
for i3 in range(n//2+n%2):
for i2 in range(n*3):
if b[i2]=='a':
{{completion}}
|
c = b[z]
b[z] = 'a'
b[i2] = c
print(min(i2+1, z+1), max(i2+1, z+1))
z-=3
break
|
[{"input": "2\n1\n2", "output": ["1\n1 2\n1\n2 6"]}]
|
block_completion_001831
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$n$$$.Let's define $$$s(n)$$$ as the string "BAN" concatenated $$$n$$$ times. For example, $$$s(1)$$$ = "BAN", $$$s(3)$$$ = "BANBANBAN". Note that the length of the string $$$s(n)$$$ is equal to $$$3n$$$.Consider $$$s(n)$$$. You can perform the following operation on $$$s(n)$$$ any number of times (possibly zero): Select any two distinct indices $$$i$$$ and $$$j$$$ $$$(1 \leq i, j \leq 3n, i \ne j)$$$. Then, swap $$$s(n)_i$$$ and $$$s(n)_j$$$. You want the string "BAN" to not appear in $$$s(n)$$$ as a subsequence. What's the smallest number of operations you have to do to achieve this? Also, find one such shortest sequence of operations.A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 100)$$$ Β β the number of test cases. The description of the test cases follows. The only line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$.
Output Specification: For each test case, in the first line output $$$m$$$ ($$$0 \le m \le 10^5$$$)Β β the minimum number of operations required. It's guaranteed that the objective is always achievable in at most $$$10^5$$$ operations under the constraints of the problem. Then, output $$$m$$$ lines. The $$$k$$$-th of these lines should contain two integers $$$i_k$$$, $$$j_k$$$ $$$(1\leq i_k, j_k \leq 3n, i_k \ne j_k)$$$ denoting that you want to swap characters at indices $$$i_k$$$ and $$$j_k$$$ at the $$$k$$$-th operation. After all $$$m$$$ operations, "BAN" must not appear in $$$s(n)$$$ as a subsequence. If there are multiple possible answers, output any.
Notes: NoteIn the first testcase, $$$s(1) = $$$ "BAN", we can swap $$$s(1)_1$$$ and $$$s(1)_2$$$, converting $$$s(1)$$$ to "ABN", which does not contain "BAN" as a subsequence.In the second testcase, $$$s(2) = $$$ "BANBAN", we can swap $$$s(2)_2$$$ and $$$s(2)_6$$$, converting $$$s(2)$$$ to "BNNBAA", which does not contain "BAN" as a subsequence.
Code:
# get testcase input
t = int(input())
result = ""
while t:
t -= 1
n = int(input())
aux = int(n/2 if n%2==0 else n/2+1)
if n == 1:
# TODO: Your code here
result += str(aux) + "\n"
for i in range(aux):
result += str(2+3*i) + ' ' + str(3+3*(n-i-1)) + "\n"
print(result[:-1])
|
# get testcase input
t = int(input())
result = ""
while t:
t -= 1
n = int(input())
aux = int(n/2 if n%2==0 else n/2+1)
if n == 1:
{{completion}}
result += str(aux) + "\n"
for i in range(aux):
result += str(2+3*i) + ' ' + str(3+3*(n-i-1)) + "\n"
print(result[:-1])
|
result += "1\n1 2\n"
continue
|
[{"input": "2\n1\n2", "output": ["1\n1 2\n1\n2 6"]}]
|
block_completion_001832
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$n$$$.Let's define $$$s(n)$$$ as the string "BAN" concatenated $$$n$$$ times. For example, $$$s(1)$$$ = "BAN", $$$s(3)$$$ = "BANBANBAN". Note that the length of the string $$$s(n)$$$ is equal to $$$3n$$$.Consider $$$s(n)$$$. You can perform the following operation on $$$s(n)$$$ any number of times (possibly zero): Select any two distinct indices $$$i$$$ and $$$j$$$ $$$(1 \leq i, j \leq 3n, i \ne j)$$$. Then, swap $$$s(n)_i$$$ and $$$s(n)_j$$$. You want the string "BAN" to not appear in $$$s(n)$$$ as a subsequence. What's the smallest number of operations you have to do to achieve this? Also, find one such shortest sequence of operations.A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 100)$$$ Β β the number of test cases. The description of the test cases follows. The only line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$.
Output Specification: For each test case, in the first line output $$$m$$$ ($$$0 \le m \le 10^5$$$)Β β the minimum number of operations required. It's guaranteed that the objective is always achievable in at most $$$10^5$$$ operations under the constraints of the problem. Then, output $$$m$$$ lines. The $$$k$$$-th of these lines should contain two integers $$$i_k$$$, $$$j_k$$$ $$$(1\leq i_k, j_k \leq 3n, i_k \ne j_k)$$$ denoting that you want to swap characters at indices $$$i_k$$$ and $$$j_k$$$ at the $$$k$$$-th operation. After all $$$m$$$ operations, "BAN" must not appear in $$$s(n)$$$ as a subsequence. If there are multiple possible answers, output any.
Notes: NoteIn the first testcase, $$$s(1) = $$$ "BAN", we can swap $$$s(1)_1$$$ and $$$s(1)_2$$$, converting $$$s(1)$$$ to "ABN", which does not contain "BAN" as a subsequence.In the second testcase, $$$s(2) = $$$ "BANBAN", we can swap $$$s(2)_2$$$ and $$$s(2)_6$$$, converting $$$s(2)$$$ to "BNNBAA", which does not contain "BAN" as a subsequence.
Code:
# get testcase input
t = int(input())
result = ""
while t:
t -= 1
n = int(input())
aux = int(n/2 if n%2==0 else n/2+1)
if n == 1:
result += "1\n1 2\n"
continue
result += str(aux) + "\n"
for i in range(aux):
# TODO: Your code here
print(result[:-1])
|
# get testcase input
t = int(input())
result = ""
while t:
t -= 1
n = int(input())
aux = int(n/2 if n%2==0 else n/2+1)
if n == 1:
result += "1\n1 2\n"
continue
result += str(aux) + "\n"
for i in range(aux):
{{completion}}
print(result[:-1])
|
result += str(2+3*i) + ' ' + str(3+3*(n-i-1)) + "\n"
|
[{"input": "2\n1\n2", "output": ["1\n1 2\n1\n2 6"]}]
|
block_completion_001833
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$n$$$.Let's define $$$s(n)$$$ as the string "BAN" concatenated $$$n$$$ times. For example, $$$s(1)$$$ = "BAN", $$$s(3)$$$ = "BANBANBAN". Note that the length of the string $$$s(n)$$$ is equal to $$$3n$$$.Consider $$$s(n)$$$. You can perform the following operation on $$$s(n)$$$ any number of times (possibly zero): Select any two distinct indices $$$i$$$ and $$$j$$$ $$$(1 \leq i, j \leq 3n, i \ne j)$$$. Then, swap $$$s(n)_i$$$ and $$$s(n)_j$$$. You want the string "BAN" to not appear in $$$s(n)$$$ as a subsequence. What's the smallest number of operations you have to do to achieve this? Also, find one such shortest sequence of operations.A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 100)$$$ Β β the number of test cases. The description of the test cases follows. The only line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$.
Output Specification: For each test case, in the first line output $$$m$$$ ($$$0 \le m \le 10^5$$$)Β β the minimum number of operations required. It's guaranteed that the objective is always achievable in at most $$$10^5$$$ operations under the constraints of the problem. Then, output $$$m$$$ lines. The $$$k$$$-th of these lines should contain two integers $$$i_k$$$, $$$j_k$$$ $$$(1\leq i_k, j_k \leq 3n, i_k \ne j_k)$$$ denoting that you want to swap characters at indices $$$i_k$$$ and $$$j_k$$$ at the $$$k$$$-th operation. After all $$$m$$$ operations, "BAN" must not appear in $$$s(n)$$$ as a subsequence. If there are multiple possible answers, output any.
Notes: NoteIn the first testcase, $$$s(1) = $$$ "BAN", we can swap $$$s(1)_1$$$ and $$$s(1)_2$$$, converting $$$s(1)$$$ to "ABN", which does not contain "BAN" as a subsequence.In the second testcase, $$$s(2) = $$$ "BANBAN", we can swap $$$s(2)_2$$$ and $$$s(2)_6$$$, converting $$$s(2)$$$ to "BNNBAA", which does not contain "BAN" as a subsequence.
Code:
w=int(input())
for i in range(w):
p=int(input())
if p%2==0:
t=p//2
print(t)
for k in range(t):
print((k*3)+2,((p*3)-(k*3)))
else:
if p==1:
print(1)
print(1,2)
else:
t=p//2+1
print(t)
print(1,2)
for k in range(t-1):
# TODO: Your code here
|
w=int(input())
for i in range(w):
p=int(input())
if p%2==0:
t=p//2
print(t)
for k in range(t):
print((k*3)+2,((p*3)-(k*3)))
else:
if p==1:
print(1)
print(1,2)
else:
t=p//2+1
print(t)
print(1,2)
for k in range(t-1):
{{completion}}
|
print((k*3)+1+4,((p*3)-(k*3)))
|
[{"input": "2\n1\n2", "output": ["1\n1 2\n1\n2 6"]}]
|
block_completion_001834
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$n$$$.Let's define $$$s(n)$$$ as the string "BAN" concatenated $$$n$$$ times. For example, $$$s(1)$$$ = "BAN", $$$s(3)$$$ = "BANBANBAN". Note that the length of the string $$$s(n)$$$ is equal to $$$3n$$$.Consider $$$s(n)$$$. You can perform the following operation on $$$s(n)$$$ any number of times (possibly zero): Select any two distinct indices $$$i$$$ and $$$j$$$ $$$(1 \leq i, j \leq 3n, i \ne j)$$$. Then, swap $$$s(n)_i$$$ and $$$s(n)_j$$$. You want the string "BAN" to not appear in $$$s(n)$$$ as a subsequence. What's the smallest number of operations you have to do to achieve this? Also, find one such shortest sequence of operations.A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 100)$$$ Β β the number of test cases. The description of the test cases follows. The only line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$.
Output Specification: For each test case, in the first line output $$$m$$$ ($$$0 \le m \le 10^5$$$)Β β the minimum number of operations required. It's guaranteed that the objective is always achievable in at most $$$10^5$$$ operations under the constraints of the problem. Then, output $$$m$$$ lines. The $$$k$$$-th of these lines should contain two integers $$$i_k$$$, $$$j_k$$$ $$$(1\leq i_k, j_k \leq 3n, i_k \ne j_k)$$$ denoting that you want to swap characters at indices $$$i_k$$$ and $$$j_k$$$ at the $$$k$$$-th operation. After all $$$m$$$ operations, "BAN" must not appear in $$$s(n)$$$ as a subsequence. If there are multiple possible answers, output any.
Notes: NoteIn the first testcase, $$$s(1) = $$$ "BAN", we can swap $$$s(1)_1$$$ and $$$s(1)_2$$$, converting $$$s(1)$$$ to "ABN", which does not contain "BAN" as a subsequence.In the second testcase, $$$s(2) = $$$ "BANBAN", we can swap $$$s(2)_2$$$ and $$$s(2)_6$$$, converting $$$s(2)$$$ to "BNNBAA", which does not contain "BAN" as a subsequence.
Code:
def ban(n):
if n == 1:
# TODO: Your code here
x = 0
lt = []
i = 2
j = 3 * n
while i < j:
lt.append([i, j])
x += 1
i += 3
j -= 3
return [x, lt]
OUTPUT = []
for _ in range(int(input())):
N = int(input())
OUTPUT.append(ban(N))
for _ in OUTPUT:
print(_[0])
for i in _[1]:
print(*i)
|
def ban(n):
if n == 1:
{{completion}}
x = 0
lt = []
i = 2
j = 3 * n
while i < j:
lt.append([i, j])
x += 1
i += 3
j -= 3
return [x, lt]
OUTPUT = []
for _ in range(int(input())):
N = int(input())
OUTPUT.append(ban(N))
for _ in OUTPUT:
print(_[0])
for i in _[1]:
print(*i)
|
return [1, [[1, 2]]]
|
[{"input": "2\n1\n2", "output": ["1\n1 2\n1\n2 6"]}]
|
block_completion_001835
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$n$$$.Let's define $$$s(n)$$$ as the string "BAN" concatenated $$$n$$$ times. For example, $$$s(1)$$$ = "BAN", $$$s(3)$$$ = "BANBANBAN". Note that the length of the string $$$s(n)$$$ is equal to $$$3n$$$.Consider $$$s(n)$$$. You can perform the following operation on $$$s(n)$$$ any number of times (possibly zero): Select any two distinct indices $$$i$$$ and $$$j$$$ $$$(1 \leq i, j \leq 3n, i \ne j)$$$. Then, swap $$$s(n)_i$$$ and $$$s(n)_j$$$. You want the string "BAN" to not appear in $$$s(n)$$$ as a subsequence. What's the smallest number of operations you have to do to achieve this? Also, find one such shortest sequence of operations.A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 100)$$$ Β β the number of test cases. The description of the test cases follows. The only line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$.
Output Specification: For each test case, in the first line output $$$m$$$ ($$$0 \le m \le 10^5$$$)Β β the minimum number of operations required. It's guaranteed that the objective is always achievable in at most $$$10^5$$$ operations under the constraints of the problem. Then, output $$$m$$$ lines. The $$$k$$$-th of these lines should contain two integers $$$i_k$$$, $$$j_k$$$ $$$(1\leq i_k, j_k \leq 3n, i_k \ne j_k)$$$ denoting that you want to swap characters at indices $$$i_k$$$ and $$$j_k$$$ at the $$$k$$$-th operation. After all $$$m$$$ operations, "BAN" must not appear in $$$s(n)$$$ as a subsequence. If there are multiple possible answers, output any.
Notes: NoteIn the first testcase, $$$s(1) = $$$ "BAN", we can swap $$$s(1)_1$$$ and $$$s(1)_2$$$, converting $$$s(1)$$$ to "ABN", which does not contain "BAN" as a subsequence.In the second testcase, $$$s(2) = $$$ "BANBAN", we can swap $$$s(2)_2$$$ and $$$s(2)_6$$$, converting $$$s(2)$$$ to "BNNBAA", which does not contain "BAN" as a subsequence.
Code:
def ban(n):
if n == 1:
return [1, [[1, 2]]]
x = 0
lt = []
i = 2
j = 3 * n
while i < j:
# TODO: Your code here
return [x, lt]
OUTPUT = []
for _ in range(int(input())):
N = int(input())
OUTPUT.append(ban(N))
for _ in OUTPUT:
print(_[0])
for i in _[1]:
print(*i)
|
def ban(n):
if n == 1:
return [1, [[1, 2]]]
x = 0
lt = []
i = 2
j = 3 * n
while i < j:
{{completion}}
return [x, lt]
OUTPUT = []
for _ in range(int(input())):
N = int(input())
OUTPUT.append(ban(N))
for _ in OUTPUT:
print(_[0])
for i in _[1]:
print(*i)
|
lt.append([i, j])
x += 1
i += 3
j -= 3
|
[{"input": "2\n1\n2", "output": ["1\n1 2\n1\n2 6"]}]
|
block_completion_001836
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$n$$$.Let's define $$$s(n)$$$ as the string "BAN" concatenated $$$n$$$ times. For example, $$$s(1)$$$ = "BAN", $$$s(3)$$$ = "BANBANBAN". Note that the length of the string $$$s(n)$$$ is equal to $$$3n$$$.Consider $$$s(n)$$$. You can perform the following operation on $$$s(n)$$$ any number of times (possibly zero): Select any two distinct indices $$$i$$$ and $$$j$$$ $$$(1 \leq i, j \leq 3n, i \ne j)$$$. Then, swap $$$s(n)_i$$$ and $$$s(n)_j$$$. You want the string "BAN" to not appear in $$$s(n)$$$ as a subsequence. What's the smallest number of operations you have to do to achieve this? Also, find one such shortest sequence of operations.A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 100)$$$ Β β the number of test cases. The description of the test cases follows. The only line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$.
Output Specification: For each test case, in the first line output $$$m$$$ ($$$0 \le m \le 10^5$$$)Β β the minimum number of operations required. It's guaranteed that the objective is always achievable in at most $$$10^5$$$ operations under the constraints of the problem. Then, output $$$m$$$ lines. The $$$k$$$-th of these lines should contain two integers $$$i_k$$$, $$$j_k$$$ $$$(1\leq i_k, j_k \leq 3n, i_k \ne j_k)$$$ denoting that you want to swap characters at indices $$$i_k$$$ and $$$j_k$$$ at the $$$k$$$-th operation. After all $$$m$$$ operations, "BAN" must not appear in $$$s(n)$$$ as a subsequence. If there are multiple possible answers, output any.
Notes: NoteIn the first testcase, $$$s(1) = $$$ "BAN", we can swap $$$s(1)_1$$$ and $$$s(1)_2$$$, converting $$$s(1)$$$ to "ABN", which does not contain "BAN" as a subsequence.In the second testcase, $$$s(2) = $$$ "BANBAN", we can swap $$$s(2)_2$$$ and $$$s(2)_6$$$, converting $$$s(2)$$$ to "BNNBAA", which does not contain "BAN" as a subsequence.
Code:
for t in range(int(input())):
n = int(input())
if n == 1:
print(1)
print("1 2")
elif n == 2:
print(1)
print("2 6")
else:
if n % 2 == 0:
print(n // 2)
for k in range((n // 2)):
ans = (3 * k) + 1
print(ans, (3 * n) - ans + 1)
else:
print(n // 2 + 1)
for k in range((n // 2) + 1):
# TODO: Your code here
|
for t in range(int(input())):
n = int(input())
if n == 1:
print(1)
print("1 2")
elif n == 2:
print(1)
print("2 6")
else:
if n % 2 == 0:
print(n // 2)
for k in range((n // 2)):
ans = (3 * k) + 1
print(ans, (3 * n) - ans + 1)
else:
print(n // 2 + 1)
for k in range((n // 2) + 1):
{{completion}}
|
ans = (3 * k) + 1
print(ans, (3 * n) - ans + 1)
|
[{"input": "2\n1\n2", "output": ["1\n1 2\n1\n2 6"]}]
|
block_completion_001837
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$n$$$.Let's define $$$s(n)$$$ as the string "BAN" concatenated $$$n$$$ times. For example, $$$s(1)$$$ = "BAN", $$$s(3)$$$ = "BANBANBAN". Note that the length of the string $$$s(n)$$$ is equal to $$$3n$$$.Consider $$$s(n)$$$. You can perform the following operation on $$$s(n)$$$ any number of times (possibly zero): Select any two distinct indices $$$i$$$ and $$$j$$$ $$$(1 \leq i, j \leq 3n, i \ne j)$$$. Then, swap $$$s(n)_i$$$ and $$$s(n)_j$$$. You want the string "BAN" to not appear in $$$s(n)$$$ as a subsequence. What's the smallest number of operations you have to do to achieve this? Also, find one such shortest sequence of operations.A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 100)$$$ Β β the number of test cases. The description of the test cases follows. The only line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$.
Output Specification: For each test case, in the first line output $$$m$$$ ($$$0 \le m \le 10^5$$$)Β β the minimum number of operations required. It's guaranteed that the objective is always achievable in at most $$$10^5$$$ operations under the constraints of the problem. Then, output $$$m$$$ lines. The $$$k$$$-th of these lines should contain two integers $$$i_k$$$, $$$j_k$$$ $$$(1\leq i_k, j_k \leq 3n, i_k \ne j_k)$$$ denoting that you want to swap characters at indices $$$i_k$$$ and $$$j_k$$$ at the $$$k$$$-th operation. After all $$$m$$$ operations, "BAN" must not appear in $$$s(n)$$$ as a subsequence. If there are multiple possible answers, output any.
Notes: NoteIn the first testcase, $$$s(1) = $$$ "BAN", we can swap $$$s(1)_1$$$ and $$$s(1)_2$$$, converting $$$s(1)$$$ to "ABN", which does not contain "BAN" as a subsequence.In the second testcase, $$$s(2) = $$$ "BANBAN", we can swap $$$s(2)_2$$$ and $$$s(2)_6$$$, converting $$$s(2)$$$ to "BNNBAA", which does not contain "BAN" as a subsequence.
Code:
n = int(input())
for i in range(n):
k = int(input())
if k == 1:
ans = max(1, k - 1)
print(ans)
print(1, 2)
else:
t = []
p = [0, 1, 2] * k
x, y = 0, len(p) - 1
while x < y:
while x < y and p[x] != 1: # TODO: Your code here
while x < y and p[y] != 2: y -= 1
if x >= y:
break
t.append([x + 1, y + 1])
p[x], p[y] = p[y], p[x]
print(len(t))
for x, y, in t:
print(x, y)
|
n = int(input())
for i in range(n):
k = int(input())
if k == 1:
ans = max(1, k - 1)
print(ans)
print(1, 2)
else:
t = []
p = [0, 1, 2] * k
x, y = 0, len(p) - 1
while x < y:
while x < y and p[x] != 1: {{completion}}
while x < y and p[y] != 2: y -= 1
if x >= y:
break
t.append([x + 1, y + 1])
p[x], p[y] = p[y], p[x]
print(len(t))
for x, y, in t:
print(x, y)
|
x += 1
|
[{"input": "2\n1\n2", "output": ["1\n1 2\n1\n2 6"]}]
|
block_completion_001838
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given an integer $$$n$$$.Let's define $$$s(n)$$$ as the string "BAN" concatenated $$$n$$$ times. For example, $$$s(1)$$$ = "BAN", $$$s(3)$$$ = "BANBANBAN". Note that the length of the string $$$s(n)$$$ is equal to $$$3n$$$.Consider $$$s(n)$$$. You can perform the following operation on $$$s(n)$$$ any number of times (possibly zero): Select any two distinct indices $$$i$$$ and $$$j$$$ $$$(1 \leq i, j \leq 3n, i \ne j)$$$. Then, swap $$$s(n)_i$$$ and $$$s(n)_j$$$. You want the string "BAN" to not appear in $$$s(n)$$$ as a subsequence. What's the smallest number of operations you have to do to achieve this? Also, find one such shortest sequence of operations.A string $$$a$$$ is a subsequence of a string $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by deletion of several (possibly, zero or all) characters.
Input Specification: The input consists of multiple test cases. The first line contains a single integer $$$t$$$ $$$(1 \leq t \leq 100)$$$ Β β the number of test cases. The description of the test cases follows. The only line of each test case contains a single integer $$$n$$$ $$$(1 \leq n \leq 100)$$$.
Output Specification: For each test case, in the first line output $$$m$$$ ($$$0 \le m \le 10^5$$$)Β β the minimum number of operations required. It's guaranteed that the objective is always achievable in at most $$$10^5$$$ operations under the constraints of the problem. Then, output $$$m$$$ lines. The $$$k$$$-th of these lines should contain two integers $$$i_k$$$, $$$j_k$$$ $$$(1\leq i_k, j_k \leq 3n, i_k \ne j_k)$$$ denoting that you want to swap characters at indices $$$i_k$$$ and $$$j_k$$$ at the $$$k$$$-th operation. After all $$$m$$$ operations, "BAN" must not appear in $$$s(n)$$$ as a subsequence. If there are multiple possible answers, output any.
Notes: NoteIn the first testcase, $$$s(1) = $$$ "BAN", we can swap $$$s(1)_1$$$ and $$$s(1)_2$$$, converting $$$s(1)$$$ to "ABN", which does not contain "BAN" as a subsequence.In the second testcase, $$$s(2) = $$$ "BANBAN", we can swap $$$s(2)_2$$$ and $$$s(2)_6$$$, converting $$$s(2)$$$ to "BNNBAA", which does not contain "BAN" as a subsequence.
Code:
n = int(input())
for i in range(n):
k = int(input())
if k == 1:
ans = max(1, k - 1)
print(ans)
print(1, 2)
else:
t = []
p = [0, 1, 2] * k
x, y = 0, len(p) - 1
while x < y:
while x < y and p[x] != 1: x += 1
while x < y and p[y] != 2: # TODO: Your code here
if x >= y:
break
t.append([x + 1, y + 1])
p[x], p[y] = p[y], p[x]
print(len(t))
for x, y, in t:
print(x, y)
|
n = int(input())
for i in range(n):
k = int(input())
if k == 1:
ans = max(1, k - 1)
print(ans)
print(1, 2)
else:
t = []
p = [0, 1, 2] * k
x, y = 0, len(p) - 1
while x < y:
while x < y and p[x] != 1: x += 1
while x < y and p[y] != 2: {{completion}}
if x >= y:
break
t.append([x + 1, y + 1])
p[x], p[y] = p[y], p[x]
print(len(t))
for x, y, in t:
print(x, y)
|
y -= 1
|
[{"input": "2\n1\n2", "output": ["1\n1 2\n1\n2 6"]}]
|
block_completion_001839
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a tree, consisting of $$$n$$$ vertices. Each edge has an integer value written on it.Let $$$f(v, u)$$$ be the number of values that appear exactly once on the edges of a simple path between vertices $$$v$$$ and $$$u$$$.Calculate the sum of $$$f(v, u)$$$ over all pairs of vertices $$$v$$$ and $$$u$$$ such that $$$1 \le v < u \le n$$$.
Input Specification: The first line contains a single integer $$$n$$$ ($$$2 \le n \le 5 \cdot 10^5$$$)Β β the number of vertices in the tree. Each of the next $$$n-1$$$ lines contains three integers $$$v, u$$$ and $$$x$$$ ($$$1 \le v, u, x \le n$$$)Β β the description of an edge: the vertices it connects and the value written on it. The given edges form a tree.
Output Specification: Print a single integerΒ β the sum of $$$f(v, u)$$$ over all pairs of vertices $$$v$$$ and $$$u$$$ such that $$$v < u$$$.
Code:
input = __import__('sys').stdin.readline
n = int(input())
adj = [[] for _ in range(n)]
for _ in range(n-1):
u, v, x = map(lambda x: int(x)-1, input().split())
adj[u].append((v, x))
adj[v].append((u, x))
TRAVERSE = 0
UPDATE_DP = 1
prev_node_stack = [[0] for _ in range(n)]
prev_node = [0]*n
sz = [1]*n
dp_root = [0]*n
dp_remove = [0]*n
stack = [(TRAVERSE, (0, -1, 0))]
while len(stack) > 0:
state, param = stack.pop()
if state == TRAVERSE:
u, par, i = param
if i < len(adj[u]) and adj[u][i][0] == par:
i += 1
if i < len(adj[u]):
v, x = adj[u][i]
stack.append((TRAVERSE, (u, par, i+1)))
stack.append((UPDATE_DP, (v, u, x)))
stack.append((TRAVERSE, (v, u, 0)))
prev_node_stack[x].append(v)
if state == UPDATE_DP:
v, u, x = param
prev_node_stack[x].pop()
sz[u] += sz[v]
prev_node[v] = prev_node_stack[x][-1]
if prev_node[v] == 0:
dp_root[x] += sz[v]
else:
# TODO: Your code here
# print('prev_node', prev_node)
# print('dp_root', dp_root)
# print('dp_remove', dp_remove)
ans = sum((sz[v] - dp_remove[v]) * (sz[prev_node[v]] - (dp_root[x] if prev_node[v] == 0 else dp_remove[prev_node[v]]))
for u in range(n) for v, x in adj[u] if sz[u] > sz[v])
print(ans)
|
input = __import__('sys').stdin.readline
n = int(input())
adj = [[] for _ in range(n)]
for _ in range(n-1):
u, v, x = map(lambda x: int(x)-1, input().split())
adj[u].append((v, x))
adj[v].append((u, x))
TRAVERSE = 0
UPDATE_DP = 1
prev_node_stack = [[0] for _ in range(n)]
prev_node = [0]*n
sz = [1]*n
dp_root = [0]*n
dp_remove = [0]*n
stack = [(TRAVERSE, (0, -1, 0))]
while len(stack) > 0:
state, param = stack.pop()
if state == TRAVERSE:
u, par, i = param
if i < len(adj[u]) and adj[u][i][0] == par:
i += 1
if i < len(adj[u]):
v, x = adj[u][i]
stack.append((TRAVERSE, (u, par, i+1)))
stack.append((UPDATE_DP, (v, u, x)))
stack.append((TRAVERSE, (v, u, 0)))
prev_node_stack[x].append(v)
if state == UPDATE_DP:
v, u, x = param
prev_node_stack[x].pop()
sz[u] += sz[v]
prev_node[v] = prev_node_stack[x][-1]
if prev_node[v] == 0:
dp_root[x] += sz[v]
else:
{{completion}}
# print('prev_node', prev_node)
# print('dp_root', dp_root)
# print('dp_remove', dp_remove)
ans = sum((sz[v] - dp_remove[v]) * (sz[prev_node[v]] - (dp_root[x] if prev_node[v] == 0 else dp_remove[prev_node[v]]))
for u in range(n) for v, x in adj[u] if sz[u] > sz[v])
print(ans)
|
dp_remove[prev_node[v]] += sz[v]
|
[{"input": "3\n1 2 1\n1 3 2", "output": ["4"]}, {"input": "3\n1 2 2\n1 3 2", "output": ["2"]}, {"input": "5\n1 4 4\n1 2 3\n3 4 4\n4 5 5", "output": ["14"]}, {"input": "2\n2 1 1", "output": ["1"]}, {"input": "10\n10 2 3\n3 8 8\n4 8 9\n5 8 5\n3 10 7\n7 8 2\n5 6 6\n9 3 4\n1 6 3", "output": ["120"]}]
|
block_completion_001918
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a tree, consisting of $$$n$$$ vertices. Each edge has an integer value written on it.Let $$$f(v, u)$$$ be the number of values that appear exactly once on the edges of a simple path between vertices $$$v$$$ and $$$u$$$.Calculate the sum of $$$f(v, u)$$$ over all pairs of vertices $$$v$$$ and $$$u$$$ such that $$$1 \le v < u \le n$$$.
Input Specification: The first line contains a single integer $$$n$$$ ($$$2 \le n \le 5 \cdot 10^5$$$)Β β the number of vertices in the tree. Each of the next $$$n-1$$$ lines contains three integers $$$v, u$$$ and $$$x$$$ ($$$1 \le v, u, x \le n$$$)Β β the description of an edge: the vertices it connects and the value written on it. The given edges form a tree.
Output Specification: Print a single integerΒ β the sum of $$$f(v, u)$$$ over all pairs of vertices $$$v$$$ and $$$u$$$ such that $$$v < u$$$.
Code:
import sys
input=sys.stdin.readline #ζεεε
₯εγ―γγγͺοΌοΌ
n=int(input())
root=[[] for i in range(n+3)]
col=dict()
e=[]
from _collections import defaultdict
for i in range(n-1):
a,b,x=map(int,input().split())
root[a].append(b)
root[b].append(a)
col[a,b]=x
col[b,a]=x
e.append((a,b,x))
p=[0]*(n+2)
num=[0]*(n+3)
omomi=defaultdict(int)
nextp=[10**10]*(n+2)
nextc=[1]*(n+1)
ch=[]
def dfs(n,G,s):
seen = [0] * (n + 1) # ε ΄εγ«γγ£γ¦γ―ε€γ«εΊγ
ind = [0] * (n + 1) ##
search=[s]
while search:
now=search[-1]
seen[now]=1
if len(G[now])>ind[now]:
next=G[now][ind[now]]
ind[now]+=1
if seen[next]>0:continue
p[next]=now
c=col[now,next]
nextp[next]=nextc[c]
tmp = nextc[c]
nextc[c]=next
ch.append((c,tmp))
search.append(next)
else:
x=now
num[x]=1
for y in root[x]:
if y==p[x]:continue
num[x]+=num[y]
if x>1:
c=col[x,p[x]]
omomi[x,c]+=num[x]
omomi[nextp[x],c]-=num[x]
else:
for c in range(1,n+1):
# TODO: Your code here
if ch:
c,tmp=ch.pop()
nextc[c]=tmp
search.pop()
#############################
dfs(n,root,1)
ans=0
for a,b,c in e:
if num[a]>num[b]:
a,b=b,a
ans+=omomi[a,c]*omomi[nextp[a],c]
print(ans)
|
import sys
input=sys.stdin.readline #ζεεε
₯εγ―γγγͺοΌοΌ
n=int(input())
root=[[] for i in range(n+3)]
col=dict()
e=[]
from _collections import defaultdict
for i in range(n-1):
a,b,x=map(int,input().split())
root[a].append(b)
root[b].append(a)
col[a,b]=x
col[b,a]=x
e.append((a,b,x))
p=[0]*(n+2)
num=[0]*(n+3)
omomi=defaultdict(int)
nextp=[10**10]*(n+2)
nextc=[1]*(n+1)
ch=[]
def dfs(n,G,s):
seen = [0] * (n + 1) # ε ΄εγ«γγ£γ¦γ―ε€γ«εΊγ
ind = [0] * (n + 1) ##
search=[s]
while search:
now=search[-1]
seen[now]=1
if len(G[now])>ind[now]:
next=G[now][ind[now]]
ind[now]+=1
if seen[next]>0:continue
p[next]=now
c=col[now,next]
nextp[next]=nextc[c]
tmp = nextc[c]
nextc[c]=next
ch.append((c,tmp))
search.append(next)
else:
x=now
num[x]=1
for y in root[x]:
if y==p[x]:continue
num[x]+=num[y]
if x>1:
c=col[x,p[x]]
omomi[x,c]+=num[x]
omomi[nextp[x],c]-=num[x]
else:
for c in range(1,n+1):
{{completion}}
if ch:
c,tmp=ch.pop()
nextc[c]=tmp
search.pop()
#############################
dfs(n,root,1)
ans=0
for a,b,c in e:
if num[a]>num[b]:
a,b=b,a
ans+=omomi[a,c]*omomi[nextp[a],c]
print(ans)
|
omomi[x,c]+=num[x]
|
[{"input": "3\n1 2 1\n1 3 2", "output": ["4"]}, {"input": "3\n1 2 2\n1 3 2", "output": ["2"]}, {"input": "5\n1 4 4\n1 2 3\n3 4 4\n4 5 5", "output": ["14"]}, {"input": "2\n2 1 1", "output": ["1"]}, {"input": "10\n10 2 3\n3 8 8\n4 8 9\n5 8 5\n3 10 7\n7 8 2\n5 6 6\n9 3 4\n1 6 3", "output": ["120"]}]
|
block_completion_001919
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a tree, consisting of $$$n$$$ vertices. Each edge has an integer value written on it.Let $$$f(v, u)$$$ be the number of values that appear exactly once on the edges of a simple path between vertices $$$v$$$ and $$$u$$$.Calculate the sum of $$$f(v, u)$$$ over all pairs of vertices $$$v$$$ and $$$u$$$ such that $$$1 \le v < u \le n$$$.
Input Specification: The first line contains a single integer $$$n$$$ ($$$2 \le n \le 5 \cdot 10^5$$$)Β β the number of vertices in the tree. Each of the next $$$n-1$$$ lines contains three integers $$$v, u$$$ and $$$x$$$ ($$$1 \le v, u, x \le n$$$)Β β the description of an edge: the vertices it connects and the value written on it. The given edges form a tree.
Output Specification: Print a single integerΒ β the sum of $$$f(v, u)$$$ over all pairs of vertices $$$v$$$ and $$$u$$$ such that $$$v < u$$$.
Code:
##########################
def tree_search(n,G,s,func1,func2,func3):
seen = [0] * (n + 1) # ε ΄εγ«γγ£γ¦γ―ε€γ«εΊγ
ind = [0] * (n + 1) ##
search=[s]
while search:
now=search[-1]
if seen[now]==0 and func1!=0:func1(now)
seen[now]=1
if len(G[now])>ind[now]:
next=G[now][ind[now]]
ind[now]+=1
if seen[next]>0:continue
if func2!=0:func2(now,next)
search.append(next)
else:
if func3!=0:# TODO: Your code here
search.pop()
#############################
import sys
input=sys.stdin.readline #ζεεε
₯εγ―γγγͺοΌοΌ
n=int(input())
root=[[] for i in range(n+3)]
col=dict()
e=[]
from _collections import defaultdict
for i in range(n-1):
a,b,x=map(int,input().split())
root[a].append(b)
root[b].append(a)
col[a,b]=x
col[b,a]=x
e.append((a,b,x))
def cnb(n):
return n*(n-1)//2
p=[0]*(n+2)
num=[0]*(n+3)
dp=[defaultdict(int) for i in range(n+3)]
omomi=defaultdict(int)
def f2(x,y):
p[y]=x
def f3(x):
num[x]=1
for y in root[x]:
if y==p[x]:continue
num[x]+=num[y]
for y in root[x]:
if y==p[x]:continue
if len(dp[x])<len(dp[y]):
res=dp[y]
for ke in dp[x]:res[ke]+=dp[x][ke]
else:
res = dp[x]
for ke in dp[y]: res[ke] += dp[y][ke]
dp[x] = res
if x>1:
c=col[x,p[x]]
omomi[x,c]=num[x]-dp[x][c]
dp[x][c]=num[x]
else:
for c in range(1,n+1):
omomi[1,c]=num[1]-dp[1][c]
tree_search(n,root,1,0,f2,f3)
nextp=[10**10]*(n+2)
nextc=[1]*(n+1)
ch=[]
def dfs(n,G,s):
seen = [0] * (n + 1) # ε ΄εγ«γγ£γ¦γ―ε€γ«εΊγ
ind = [0] * (n + 1) ##
search=[s]
while search:
now=search[-1]
seen[now]=1
if len(G[now])>ind[now]:
next=G[now][ind[now]]
ind[now]+=1
if seen[next]>0:continue
c=col[now,next]
nextp[next]=nextc[c]
tmp = nextc[c]
nextc[c]=next
ch.append((c,tmp))
search.append(next)
else:
if ch:
c,tmp=ch.pop()
nextc[c]=tmp
search.pop()
#############################
dfs(n,root,1)
ans=0
for a,b,c in e:
if num[a]>num[b]:
a,b=b,a
ans+=omomi[a,c]*omomi[nextp[a],c]
print(ans)
|
##########################
def tree_search(n,G,s,func1,func2,func3):
seen = [0] * (n + 1) # ε ΄εγ«γγ£γ¦γ―ε€γ«εΊγ
ind = [0] * (n + 1) ##
search=[s]
while search:
now=search[-1]
if seen[now]==0 and func1!=0:func1(now)
seen[now]=1
if len(G[now])>ind[now]:
next=G[now][ind[now]]
ind[now]+=1
if seen[next]>0:continue
if func2!=0:func2(now,next)
search.append(next)
else:
if func3!=0:{{completion}}
search.pop()
#############################
import sys
input=sys.stdin.readline #ζεεε
₯εγ―γγγͺοΌοΌ
n=int(input())
root=[[] for i in range(n+3)]
col=dict()
e=[]
from _collections import defaultdict
for i in range(n-1):
a,b,x=map(int,input().split())
root[a].append(b)
root[b].append(a)
col[a,b]=x
col[b,a]=x
e.append((a,b,x))
def cnb(n):
return n*(n-1)//2
p=[0]*(n+2)
num=[0]*(n+3)
dp=[defaultdict(int) for i in range(n+3)]
omomi=defaultdict(int)
def f2(x,y):
p[y]=x
def f3(x):
num[x]=1
for y in root[x]:
if y==p[x]:continue
num[x]+=num[y]
for y in root[x]:
if y==p[x]:continue
if len(dp[x])<len(dp[y]):
res=dp[y]
for ke in dp[x]:res[ke]+=dp[x][ke]
else:
res = dp[x]
for ke in dp[y]: res[ke] += dp[y][ke]
dp[x] = res
if x>1:
c=col[x,p[x]]
omomi[x,c]=num[x]-dp[x][c]
dp[x][c]=num[x]
else:
for c in range(1,n+1):
omomi[1,c]=num[1]-dp[1][c]
tree_search(n,root,1,0,f2,f3)
nextp=[10**10]*(n+2)
nextc=[1]*(n+1)
ch=[]
def dfs(n,G,s):
seen = [0] * (n + 1) # ε ΄εγ«γγ£γ¦γ―ε€γ«εΊγ
ind = [0] * (n + 1) ##
search=[s]
while search:
now=search[-1]
seen[now]=1
if len(G[now])>ind[now]:
next=G[now][ind[now]]
ind[now]+=1
if seen[next]>0:continue
c=col[now,next]
nextp[next]=nextc[c]
tmp = nextc[c]
nextc[c]=next
ch.append((c,tmp))
search.append(next)
else:
if ch:
c,tmp=ch.pop()
nextc[c]=tmp
search.pop()
#############################
dfs(n,root,1)
ans=0
for a,b,c in e:
if num[a]>num[b]:
a,b=b,a
ans+=omomi[a,c]*omomi[nextp[a],c]
print(ans)
|
func3(now)
|
[{"input": "3\n1 2 1\n1 3 2", "output": ["4"]}, {"input": "3\n1 2 2\n1 3 2", "output": ["2"]}, {"input": "5\n1 4 4\n1 2 3\n3 4 4\n4 5 5", "output": ["14"]}, {"input": "2\n2 1 1", "output": ["1"]}, {"input": "10\n10 2 3\n3 8 8\n4 8 9\n5 8 5\n3 10 7\n7 8 2\n5 6 6\n9 3 4\n1 6 3", "output": ["120"]}]
|
block_completion_001920
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a tree, consisting of $$$n$$$ vertices. Each edge has an integer value written on it.Let $$$f(v, u)$$$ be the number of values that appear exactly once on the edges of a simple path between vertices $$$v$$$ and $$$u$$$.Calculate the sum of $$$f(v, u)$$$ over all pairs of vertices $$$v$$$ and $$$u$$$ such that $$$1 \le v < u \le n$$$.
Input Specification: The first line contains a single integer $$$n$$$ ($$$2 \le n \le 5 \cdot 10^5$$$)Β β the number of vertices in the tree. Each of the next $$$n-1$$$ lines contains three integers $$$v, u$$$ and $$$x$$$ ($$$1 \le v, u, x \le n$$$)Β β the description of an edge: the vertices it connects and the value written on it. The given edges form a tree.
Output Specification: Print a single integerΒ β the sum of $$$f(v, u)$$$ over all pairs of vertices $$$v$$$ and $$$u$$$ such that $$$v < u$$$.
Code:
##########################
def tree_search(n,G,s,func1,func2,func3):
seen = [0] * (n + 1) # ε ΄εγ«γγ£γ¦γ―ε€γ«εΊγ
ind = [0] * (n + 1) ##
search=[s]
while search:
now=search[-1]
if seen[now]==0 and func1!=0:func1(now)
seen[now]=1
if len(G[now])>ind[now]:
next=G[now][ind[now]]
ind[now]+=1
if seen[next]>0:continue
if func2!=0:func2(now,next)
search.append(next)
else:
if func3!=0:func3(now)
search.pop()
#############################
import sys
input=sys.stdin.readline #ζεεε
₯εγ―γγγͺοΌοΌ
n=int(input())
root=[[] for i in range(n+3)]
col=dict()
e=[]
from _collections import defaultdict
for i in range(n-1):
a,b,x=map(int,input().split())
root[a].append(b)
root[b].append(a)
col[a,b]=x
col[b,a]=x
e.append((a,b,x))
def cnb(n):
return n*(n-1)//2
p=[0]*(n+2)
num=[0]*(n+3)
dp=[defaultdict(int) for i in range(n+3)]
omomi=defaultdict(int)
def f2(x,y):
p[y]=x
def f3(x):
num[x]=1
for y in root[x]:
if y==p[x]:continue
num[x]+=num[y]
for y in root[x]:
if y==p[x]:continue
if len(dp[x])<len(dp[y]):
res=dp[y]
for ke in dp[x]:res[ke]+=dp[x][ke]
else:
res = dp[x]
for ke in dp[y]: # TODO: Your code here
dp[x] = res
if x>1:
c=col[x,p[x]]
omomi[x,c]=num[x]-dp[x][c]
dp[x][c]=num[x]
else:
for c in range(1,n+1):
omomi[1,c]=num[1]-dp[1][c]
tree_search(n,root,1,0,f2,f3)
nextp=[10**10]*(n+2)
nextc=[1]*(n+1)
ch=[]
def dfs(n,G,s):
seen = [0] * (n + 1) # ε ΄εγ«γγ£γ¦γ―ε€γ«εΊγ
ind = [0] * (n + 1) ##
search=[s]
while search:
now=search[-1]
seen[now]=1
if len(G[now])>ind[now]:
next=G[now][ind[now]]
ind[now]+=1
if seen[next]>0:continue
c=col[now,next]
nextp[next]=nextc[c]
tmp = nextc[c]
nextc[c]=next
ch.append((c,tmp))
search.append(next)
else:
if ch:
c,tmp=ch.pop()
nextc[c]=tmp
search.pop()
#############################
dfs(n,root,1)
ans=0
for a,b,c in e:
if num[a]>num[b]:
a,b=b,a
ans+=omomi[a,c]*omomi[nextp[a],c]
print(ans)
|
##########################
def tree_search(n,G,s,func1,func2,func3):
seen = [0] * (n + 1) # ε ΄εγ«γγ£γ¦γ―ε€γ«εΊγ
ind = [0] * (n + 1) ##
search=[s]
while search:
now=search[-1]
if seen[now]==0 and func1!=0:func1(now)
seen[now]=1
if len(G[now])>ind[now]:
next=G[now][ind[now]]
ind[now]+=1
if seen[next]>0:continue
if func2!=0:func2(now,next)
search.append(next)
else:
if func3!=0:func3(now)
search.pop()
#############################
import sys
input=sys.stdin.readline #ζεεε
₯εγ―γγγͺοΌοΌ
n=int(input())
root=[[] for i in range(n+3)]
col=dict()
e=[]
from _collections import defaultdict
for i in range(n-1):
a,b,x=map(int,input().split())
root[a].append(b)
root[b].append(a)
col[a,b]=x
col[b,a]=x
e.append((a,b,x))
def cnb(n):
return n*(n-1)//2
p=[0]*(n+2)
num=[0]*(n+3)
dp=[defaultdict(int) for i in range(n+3)]
omomi=defaultdict(int)
def f2(x,y):
p[y]=x
def f3(x):
num[x]=1
for y in root[x]:
if y==p[x]:continue
num[x]+=num[y]
for y in root[x]:
if y==p[x]:continue
if len(dp[x])<len(dp[y]):
res=dp[y]
for ke in dp[x]:res[ke]+=dp[x][ke]
else:
res = dp[x]
for ke in dp[y]: {{completion}}
dp[x] = res
if x>1:
c=col[x,p[x]]
omomi[x,c]=num[x]-dp[x][c]
dp[x][c]=num[x]
else:
for c in range(1,n+1):
omomi[1,c]=num[1]-dp[1][c]
tree_search(n,root,1,0,f2,f3)
nextp=[10**10]*(n+2)
nextc=[1]*(n+1)
ch=[]
def dfs(n,G,s):
seen = [0] * (n + 1) # ε ΄εγ«γγ£γ¦γ―ε€γ«εΊγ
ind = [0] * (n + 1) ##
search=[s]
while search:
now=search[-1]
seen[now]=1
if len(G[now])>ind[now]:
next=G[now][ind[now]]
ind[now]+=1
if seen[next]>0:continue
c=col[now,next]
nextp[next]=nextc[c]
tmp = nextc[c]
nextc[c]=next
ch.append((c,tmp))
search.append(next)
else:
if ch:
c,tmp=ch.pop()
nextc[c]=tmp
search.pop()
#############################
dfs(n,root,1)
ans=0
for a,b,c in e:
if num[a]>num[b]:
a,b=b,a
ans+=omomi[a,c]*omomi[nextp[a],c]
print(ans)
|
res[ke] += dp[y][ke]
|
[{"input": "3\n1 2 1\n1 3 2", "output": ["4"]}, {"input": "3\n1 2 2\n1 3 2", "output": ["2"]}, {"input": "5\n1 4 4\n1 2 3\n3 4 4\n4 5 5", "output": ["14"]}, {"input": "2\n2 1 1", "output": ["1"]}, {"input": "10\n10 2 3\n3 8 8\n4 8 9\n5 8 5\n3 10 7\n7 8 2\n5 6 6\n9 3 4\n1 6 3", "output": ["120"]}]
|
block_completion_001921
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You found a map of a weirdly shaped labyrinth. The map is a grid, consisting of $$$n$$$ rows and $$$n$$$ columns. The rows of the grid are numbered from $$$1$$$ to $$$n$$$ from bottom to top. The columns of the grid are numbered from $$$1$$$ to $$$n$$$ from left to right.The labyrinth has $$$n$$$ layers. The first layer is the bottom left corner (cell $$$(1, 1)$$$). The second layer consists of all cells that are in the grid and adjacent to the first layer by a side or a corner. The third layer consists of all cells that are in the grid and adjacent to the second layer by a side or a corner. And so on. The labyrinth with $$$5$$$ layers, for example, is shaped as follows: The layers are separated from one another with walls. However, there are doors in these walls.Each layer (except for layer $$$n$$$) has exactly two doors to the next layer. One door is placed on the top wall of the layer and another door is placed on the right wall of the layer. For each layer from $$$1$$$ to $$$n-1$$$ you are given positions of these two doors. The doors can be passed in both directions: either from layer $$$i$$$ to layer $$$i+1$$$ or from layer $$$i+1$$$ to layer $$$i$$$.If you are standing in some cell, you can move to an adjacent by a side cell if a wall doesn't block your move (e.g. you can't move to a cell in another layer if there is no door between the cells).Now you have $$$m$$$ queries of sort: what's the minimum number of moves one has to make to go from cell $$$(x_1, y_1)$$$ to cell $$$(x_2, y_2)$$$.
Input Specification: The first line contains a single integer $$$n$$$ ($$$2 \le n \le 10^5$$$)Β β the number of layers in the labyrinth. The $$$i$$$-th of the next $$$n-1$$$ lines contains four integers $$$d_{1,x}, d_{1,y}, d_{2,x}$$$ and $$$d_{2,y}$$$ ($$$1 \le d_{1,x}, d_{1,y}, d_{2,x}, d_{2,y} \le n$$$)Β β the coordinates of the doors. Both cells are on the $$$i$$$-th layer. The first cell is adjacent to the top wall of the $$$i$$$-th layer by a sideΒ β that side is where the door is. The second cell is adjacent to the right wall of the $$$i$$$-th layer by a sideΒ β that side is where the door is. The next line contains a single integer $$$m$$$ ($$$1 \le m \le 2 \cdot 10^5$$$)Β β the number of queries. The $$$j$$$-th of the next $$$m$$$ lines contains four integers $$$x_1, y_1, x_2$$$ and $$$y_2$$$ ($$$1 \le x_1, y_1, x_2, y_2 \le n$$$)Β β the coordinates of the cells in the $$$j$$$-th query.
Output Specification: For each query, print a single integerΒ β the minimum number of moves one has to make to go from cell $$$(x_1, y_1)$$$ to cell $$$(x_2, y_2)$$$.
Notes: NoteHere is the map of the labyrinth from the second example. The doors are marked red.
Code:
import sys
input = sys.stdin.readline
N = int(input())
logN = (N - 2).bit_length()
door = []
for _ in range(N - 1):
_, a, b, _ = map(int, input().split())
door.append([a - 1, b - 1])
# door = [list(map(lambda x: int(x) - 1, input().split())) for _ in range(N - 1)]
dist = [[[-1] * 4 for _ in range(logN)] for _ in range(N - 2)]
'''
0: 0->0
1: 0->1
2: 1->0
3: 1->1
'''
for i in range(N - 2):
d1 = abs(i - door[i][1]) + abs(door[i][0] - i)
dist[i][0][0] = abs(door[i][0] - door[i + 1][0]) + 1
dist[i][0][3] = abs(door[i][1] - door[i + 1][1]) + 1
dist[i][0][1] = min(
abs(i + 1 - door[i + 1][1]) + abs(door[i][0] - (i + 1)) + 1,
d1 + dist[i][0][3]
)
dist[i][0][2] = min(
abs(door[i][1] - (i + 1)) + abs(i + 1 - door[i + 1][0]) + 1,
d1 + dist[i][0][0]
)
for j in range(1, logN):
k = 1 << (j - 1)
for i in range(N - 1 - (1 << j)):
for fr in range(2):
for to in range(2):
# TODO: Your code here
Q = int(input())
for _ in range(Q):
h1, w1, h2, w2 = map(lambda x: int(x) - 1, input().split())
l1 = max(h1, w1)
l2 = max(h2, w2)
if l1 == l2:
print(abs(h1 - h2) + abs(w1 - w2))
continue
if l1 > l2:
l1, l2 = l2, l1
h1, w1, h2, w2 = h2, w2, h1, w1
now = l1
l = l2 - l1 - 1
d0 = abs(h1 - now) + abs(w1 - door[now][0])
d1 = abs(h1 - door[now][1]) + abs(w1 - now)
for i in range(logN - 1, -1, -1):
if l >> i & 1:
d0, d1 = min(d0 + dist[now][i][0], d1 + dist[now][i][2]), min(d0 + dist[now][i][1], d1 + dist[now][i][3])
now += 1 << i
print(min(d0 + abs(now + 1 - h2) + abs(door[now][0] - w2), d1 + abs(door[now][1] - h2) + abs(now + 1 - w2)) + 1)
|
import sys
input = sys.stdin.readline
N = int(input())
logN = (N - 2).bit_length()
door = []
for _ in range(N - 1):
_, a, b, _ = map(int, input().split())
door.append([a - 1, b - 1])
# door = [list(map(lambda x: int(x) - 1, input().split())) for _ in range(N - 1)]
dist = [[[-1] * 4 for _ in range(logN)] for _ in range(N - 2)]
'''
0: 0->0
1: 0->1
2: 1->0
3: 1->1
'''
for i in range(N - 2):
d1 = abs(i - door[i][1]) + abs(door[i][0] - i)
dist[i][0][0] = abs(door[i][0] - door[i + 1][0]) + 1
dist[i][0][3] = abs(door[i][1] - door[i + 1][1]) + 1
dist[i][0][1] = min(
abs(i + 1 - door[i + 1][1]) + abs(door[i][0] - (i + 1)) + 1,
d1 + dist[i][0][3]
)
dist[i][0][2] = min(
abs(door[i][1] - (i + 1)) + abs(i + 1 - door[i + 1][0]) + 1,
d1 + dist[i][0][0]
)
for j in range(1, logN):
k = 1 << (j - 1)
for i in range(N - 1 - (1 << j)):
for fr in range(2):
for to in range(2):
{{completion}}
Q = int(input())
for _ in range(Q):
h1, w1, h2, w2 = map(lambda x: int(x) - 1, input().split())
l1 = max(h1, w1)
l2 = max(h2, w2)
if l1 == l2:
print(abs(h1 - h2) + abs(w1 - w2))
continue
if l1 > l2:
l1, l2 = l2, l1
h1, w1, h2, w2 = h2, w2, h1, w1
now = l1
l = l2 - l1 - 1
d0 = abs(h1 - now) + abs(w1 - door[now][0])
d1 = abs(h1 - door[now][1]) + abs(w1 - now)
for i in range(logN - 1, -1, -1):
if l >> i & 1:
d0, d1 = min(d0 + dist[now][i][0], d1 + dist[now][i][2]), min(d0 + dist[now][i][1], d1 + dist[now][i][3])
now += 1 << i
print(min(d0 + abs(now + 1 - h2) + abs(door[now][0] - w2), d1 + abs(door[now][1] - h2) + abs(now + 1 - w2)) + 1)
|
dist[i][j][fr << 1 | to] = min(
dist[i][j - 1][fr << 1] + dist[i + k][j - 1][to],
dist[i][j - 1][fr << 1 | 1] + dist[i + k][j - 1][2 | to]
)
|
[{"input": "2\n1 1 1 1\n10\n1 1 1 1\n1 1 1 2\n1 1 2 1\n1 1 2 2\n1 2 1 2\n1 2 2 1\n1 2 2 2\n2 1 2 1\n2 1 2 2\n2 2 2 2", "output": ["0\n1\n1\n2\n0\n2\n1\n0\n1\n0"]}, {"input": "4\n1 1 1 1\n2 1 2 2\n3 2 1 3\n5\n2 4 4 3\n4 4 3 3\n1 2 3 3\n2 2 4 4\n1 4 2 3", "output": ["3\n4\n3\n6\n2"]}]
|
block_completion_001953
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You found a map of a weirdly shaped labyrinth. The map is a grid, consisting of $$$n$$$ rows and $$$n$$$ columns. The rows of the grid are numbered from $$$1$$$ to $$$n$$$ from bottom to top. The columns of the grid are numbered from $$$1$$$ to $$$n$$$ from left to right.The labyrinth has $$$n$$$ layers. The first layer is the bottom left corner (cell $$$(1, 1)$$$). The second layer consists of all cells that are in the grid and adjacent to the first layer by a side or a corner. The third layer consists of all cells that are in the grid and adjacent to the second layer by a side or a corner. And so on. The labyrinth with $$$5$$$ layers, for example, is shaped as follows: The layers are separated from one another with walls. However, there are doors in these walls.Each layer (except for layer $$$n$$$) has exactly two doors to the next layer. One door is placed on the top wall of the layer and another door is placed on the right wall of the layer. For each layer from $$$1$$$ to $$$n-1$$$ you are given positions of these two doors. The doors can be passed in both directions: either from layer $$$i$$$ to layer $$$i+1$$$ or from layer $$$i+1$$$ to layer $$$i$$$.If you are standing in some cell, you can move to an adjacent by a side cell if a wall doesn't block your move (e.g. you can't move to a cell in another layer if there is no door between the cells).Now you have $$$m$$$ queries of sort: what's the minimum number of moves one has to make to go from cell $$$(x_1, y_1)$$$ to cell $$$(x_2, y_2)$$$.
Input Specification: The first line contains a single integer $$$n$$$ ($$$2 \le n \le 10^5$$$)Β β the number of layers in the labyrinth. The $$$i$$$-th of the next $$$n-1$$$ lines contains four integers $$$d_{1,x}, d_{1,y}, d_{2,x}$$$ and $$$d_{2,y}$$$ ($$$1 \le d_{1,x}, d_{1,y}, d_{2,x}, d_{2,y} \le n$$$)Β β the coordinates of the doors. Both cells are on the $$$i$$$-th layer. The first cell is adjacent to the top wall of the $$$i$$$-th layer by a sideΒ β that side is where the door is. The second cell is adjacent to the right wall of the $$$i$$$-th layer by a sideΒ β that side is where the door is. The next line contains a single integer $$$m$$$ ($$$1 \le m \le 2 \cdot 10^5$$$)Β β the number of queries. The $$$j$$$-th of the next $$$m$$$ lines contains four integers $$$x_1, y_1, x_2$$$ and $$$y_2$$$ ($$$1 \le x_1, y_1, x_2, y_2 \le n$$$)Β β the coordinates of the cells in the $$$j$$$-th query.
Output Specification: For each query, print a single integerΒ β the minimum number of moves one has to make to go from cell $$$(x_1, y_1)$$$ to cell $$$(x_2, y_2)$$$.
Notes: NoteHere is the map of the labyrinth from the second example. The doors are marked red.
Code:
input = __import__('sys').stdin.readline
def manhattan(A, B, dA=None, dB=None):
if dA is not None:
A = list(A)
A[0] += dA[0]
A[1] += dA[1]
if dB is not None:
B = list(B)
B[0] += dB[0]
B[1] += dB[1]
return abs(A[0] - B[0]) + abs(A[1] - B[1])
n = int(input())
a = []
for _ in range(n-1):
x1, y1, x2, y2 = map(lambda x: int(x)-1, input().split())
a.append((
(x1, y1),
(x2, y2),
))
a.append((
(a[-1][0][0] + 1, a[-1][0][1]),
(a[-1][1][0], a[-1][1][1] + 1),
))
jump = [
[
(
min(manhattan(a[i][0], a[i+1][0], dA=(1, 0)), manhattan(a[i][0], a[i][1]) + manhattan(a[i][1], a[i+1][0], dA=(0, 1))) + 1,
min(manhattan(a[i][0], a[i+1][1], dA=(1, 0)), manhattan(a[i][0], a[i][1]) + manhattan(a[i][1], a[i+1][1], dA=(0, 1))) + 1,
min(manhattan(a[i][1], a[i+1][0], dA=(0, 1)), manhattan(a[i][1], a[i][0]) + manhattan(a[i][0], a[i+1][0], dA=(1, 0))) + 1,
min(manhattan(a[i][1], a[i+1][1], dA=(0, 1)), manhattan(a[i][1], a[i][0]) + manhattan(a[i][0], a[i+1][1], dA=(1, 0))) + 1,
) for i in range(n-1)
]
]
def merge(A, B):
return (
min(A[0] + B[0], A[1] + B[2]),
min(A[0] + B[1], A[1] + B[3]),
min(A[2] + B[0], A[3] + B[2]),
min(A[2] + B[1], A[3] + B[3]),
)
# print(jump[0])
for j in range(20):
jump.append([
merge(jump[j][i], jump[j][i + (1 << j)]) for i in range(len(jump[j]) - (1 << j))
])
# print(jump[-1])
for _ in range(int(input())):
x1, y1, x2, y2 = map(lambda x: int(x)-1, input().split())
m1, m2 = max(x1, y1), max(x2, y2)
if m1 > m2:
m1, m2 = m2, m1
x1, x2 = x2, x1
y1, y2 = y2, y1
if m1 == m2:
print(manhattan((x1, y1), (x2, y2)))
continue
s = m1
sz = m2 - m1 - 1
dist = None
for i in range(20):
if (sz >> i) & 1 == 1:
if dist is None:
dist = jump[i][s]
else:
# TODO: Your code here
s += (1 << i)
if m1 + 1 == m2:
dist = (0, manhattan(a[m1][0], a[m1][1]), manhattan(a[m1][1], a[m1][0]), 0)
# print('dist', dist, a[m1], a[m2-1])
# print('>', manhattan((x1, y1), a[m1][0]), dist[0], manhattan(a[m2-1][0], (x2, y2), dA=(1, 0)))
# print('>', manhattan((x1, y1), a[m1][0]), dist[1], manhattan(a[m2-1][1], (x2, y2), dA=(0, 1)))
# print('>', manhattan((x1, y1), a[m1][1]), dist[2], manhattan(a[m2-1][0], (x2, y2), dA=(1, 0)))
# print('>', manhattan((x1, y1), a[m1][1]), dist[3], manhattan(a[m2-1][1], (x2, y2), dA=(0, 1)))
# print([
# manhattan((x1, y1), a[m1][0]) + dist[0] + manhattan(a[m2-1][0], (x2, y2), dA=(1, 0)) + 1,
# manhattan((x1, y1), a[m1][0]) + dist[1] + manhattan(a[m2-1][1], (x2, y2), dA=(0, 1)) + 1,
# manhattan((x1, y1), a[m1][1]) + dist[2] + manhattan(a[m2-1][0], (x2, y2), dA=(1, 0)) + 1,
# manhattan((x1, y1), a[m1][1]) + dist[3] + manhattan(a[m2-1][1], (x2, y2), dA=(0, 1)) + 1,
# ])
print(min(
manhattan((x1, y1), a[m1][0]) + dist[0] + manhattan(a[m2-1][0], (x2, y2), dA=(1, 0)) + 1,
manhattan((x1, y1), a[m1][0]) + dist[1] + manhattan(a[m2-1][1], (x2, y2), dA=(0, 1)) + 1,
manhattan((x1, y1), a[m1][1]) + dist[2] + manhattan(a[m2-1][0], (x2, y2), dA=(1, 0)) + 1,
manhattan((x1, y1), a[m1][1]) + dist[3] + manhattan(a[m2-1][1], (x2, y2), dA=(0, 1)) + 1,
))
|
input = __import__('sys').stdin.readline
def manhattan(A, B, dA=None, dB=None):
if dA is not None:
A = list(A)
A[0] += dA[0]
A[1] += dA[1]
if dB is not None:
B = list(B)
B[0] += dB[0]
B[1] += dB[1]
return abs(A[0] - B[0]) + abs(A[1] - B[1])
n = int(input())
a = []
for _ in range(n-1):
x1, y1, x2, y2 = map(lambda x: int(x)-1, input().split())
a.append((
(x1, y1),
(x2, y2),
))
a.append((
(a[-1][0][0] + 1, a[-1][0][1]),
(a[-1][1][0], a[-1][1][1] + 1),
))
jump = [
[
(
min(manhattan(a[i][0], a[i+1][0], dA=(1, 0)), manhattan(a[i][0], a[i][1]) + manhattan(a[i][1], a[i+1][0], dA=(0, 1))) + 1,
min(manhattan(a[i][0], a[i+1][1], dA=(1, 0)), manhattan(a[i][0], a[i][1]) + manhattan(a[i][1], a[i+1][1], dA=(0, 1))) + 1,
min(manhattan(a[i][1], a[i+1][0], dA=(0, 1)), manhattan(a[i][1], a[i][0]) + manhattan(a[i][0], a[i+1][0], dA=(1, 0))) + 1,
min(manhattan(a[i][1], a[i+1][1], dA=(0, 1)), manhattan(a[i][1], a[i][0]) + manhattan(a[i][0], a[i+1][1], dA=(1, 0))) + 1,
) for i in range(n-1)
]
]
def merge(A, B):
return (
min(A[0] + B[0], A[1] + B[2]),
min(A[0] + B[1], A[1] + B[3]),
min(A[2] + B[0], A[3] + B[2]),
min(A[2] + B[1], A[3] + B[3]),
)
# print(jump[0])
for j in range(20):
jump.append([
merge(jump[j][i], jump[j][i + (1 << j)]) for i in range(len(jump[j]) - (1 << j))
])
# print(jump[-1])
for _ in range(int(input())):
x1, y1, x2, y2 = map(lambda x: int(x)-1, input().split())
m1, m2 = max(x1, y1), max(x2, y2)
if m1 > m2:
m1, m2 = m2, m1
x1, x2 = x2, x1
y1, y2 = y2, y1
if m1 == m2:
print(manhattan((x1, y1), (x2, y2)))
continue
s = m1
sz = m2 - m1 - 1
dist = None
for i in range(20):
if (sz >> i) & 1 == 1:
if dist is None:
dist = jump[i][s]
else:
{{completion}}
s += (1 << i)
if m1 + 1 == m2:
dist = (0, manhattan(a[m1][0], a[m1][1]), manhattan(a[m1][1], a[m1][0]), 0)
# print('dist', dist, a[m1], a[m2-1])
# print('>', manhattan((x1, y1), a[m1][0]), dist[0], manhattan(a[m2-1][0], (x2, y2), dA=(1, 0)))
# print('>', manhattan((x1, y1), a[m1][0]), dist[1], manhattan(a[m2-1][1], (x2, y2), dA=(0, 1)))
# print('>', manhattan((x1, y1), a[m1][1]), dist[2], manhattan(a[m2-1][0], (x2, y2), dA=(1, 0)))
# print('>', manhattan((x1, y1), a[m1][1]), dist[3], manhattan(a[m2-1][1], (x2, y2), dA=(0, 1)))
# print([
# manhattan((x1, y1), a[m1][0]) + dist[0] + manhattan(a[m2-1][0], (x2, y2), dA=(1, 0)) + 1,
# manhattan((x1, y1), a[m1][0]) + dist[1] + manhattan(a[m2-1][1], (x2, y2), dA=(0, 1)) + 1,
# manhattan((x1, y1), a[m1][1]) + dist[2] + manhattan(a[m2-1][0], (x2, y2), dA=(1, 0)) + 1,
# manhattan((x1, y1), a[m1][1]) + dist[3] + manhattan(a[m2-1][1], (x2, y2), dA=(0, 1)) + 1,
# ])
print(min(
manhattan((x1, y1), a[m1][0]) + dist[0] + manhattan(a[m2-1][0], (x2, y2), dA=(1, 0)) + 1,
manhattan((x1, y1), a[m1][0]) + dist[1] + manhattan(a[m2-1][1], (x2, y2), dA=(0, 1)) + 1,
manhattan((x1, y1), a[m1][1]) + dist[2] + manhattan(a[m2-1][0], (x2, y2), dA=(1, 0)) + 1,
manhattan((x1, y1), a[m1][1]) + dist[3] + manhattan(a[m2-1][1], (x2, y2), dA=(0, 1)) + 1,
))
|
dist = merge(dist, jump[i][s])
|
[{"input": "2\n1 1 1 1\n10\n1 1 1 1\n1 1 1 2\n1 1 2 1\n1 1 2 2\n1 2 1 2\n1 2 2 1\n1 2 2 2\n2 1 2 1\n2 1 2 2\n2 2 2 2", "output": ["0\n1\n1\n2\n0\n2\n1\n0\n1\n0"]}, {"input": "4\n1 1 1 1\n2 1 2 2\n3 2 1 3\n5\n2 4 4 3\n4 4 3 3\n1 2 3 3\n2 2 4 4\n1 4 2 3", "output": ["3\n4\n3\n6\n2"]}]
|
block_completion_001954
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Consider an array $$$a$$$ of $$$n$$$ positive integers.You may perform the following operation: select two indices $$$l$$$ and $$$r$$$ ($$$1 \leq l \leq r \leq n$$$), then decrease all elements $$$a_l, a_{l + 1}, \dots, a_r$$$ by $$$1$$$. Let's call $$$f(a)$$$ the minimum number of operations needed to change array $$$a$$$ into an array of $$$n$$$ zeros.Determine if for all permutations$$$^\dagger$$$ $$$b$$$ of $$$a$$$, $$$f(a) \leq f(b)$$$ is true. $$$^\dagger$$$ An array $$$b$$$ is a permutation of an array $$$a$$$ if $$$b$$$ consists of the elements of $$$a$$$ in arbitrary order. For example, $$$[4,2,3,4]$$$ is a permutation of $$$[3,2,4,4]$$$ while $$$[1,2,2]$$$ is not a permutation of $$$[1,2,3]$$$.
Input Specification: The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^4$$$) β the number of test cases. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 10^5$$$) β the length of the array $$$a$$$. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 10^9$$$) β description of the array $$$a$$$. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print "YES" (without quotes) if for all permutations $$$b$$$ of $$$a$$$, $$$f(a) \leq f(b)$$$ is true, and "NO" (without quotes) otherwise. You can output "YES" and "NO" in any case (for example, strings "yEs", "yes" and "Yes" will be recognized as a positive response).
Notes: NoteIn the first test case, we can change all elements to $$$0$$$ in $$$5$$$ operations. It can be shown that no permutation of $$$[2, 3, 5, 4]$$$ requires less than $$$5$$$ operations to change all elements to $$$0$$$.In the third test case, we need $$$5$$$ operations to change all elements to $$$0$$$, while $$$[2, 3, 3, 1]$$$ only needs $$$3$$$ operations.
Code:
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
def isMountain(ar):
prefixInc = [False] * len(ar)
prefixInc[0] = 1
for i in range(1, len(ar)):
prefixInc[i] = prefixInc[i - 1] and ar[i - 1] <= ar[i]
suffixInc = [0] * len(ar)
suffixInc[-1] = 1
for i in range(len(ar) - 2, -1, -1):
suffixInc[i] = suffixInc[i + 1] and ar[i] >= ar[i + 1]
ans = prefixInc[-1] or suffixInc[0]
for i in range(len(ar)):
ans = ans or (prefixInc[i] and suffixInc[i])
return ans
testcase = True
def solve(testcase = 1):
N = nextInt()
A = getIntArray(N)
print("yes" if isMountain(A) else "no")
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
# TODO: Your code here
assert not tokens
|
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
def isMountain(ar):
prefixInc = [False] * len(ar)
prefixInc[0] = 1
for i in range(1, len(ar)):
prefixInc[i] = prefixInc[i - 1] and ar[i - 1] <= ar[i]
suffixInc = [0] * len(ar)
suffixInc[-1] = 1
for i in range(len(ar) - 2, -1, -1):
suffixInc[i] = suffixInc[i + 1] and ar[i] >= ar[i + 1]
ans = prefixInc[-1] or suffixInc[0]
for i in range(len(ar)):
ans = ans or (prefixInc[i] and suffixInc[i])
return ans
testcase = True
def solve(testcase = 1):
N = nextInt()
A = getIntArray(N)
print("yes" if isMountain(A) else "no")
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
{{completion}}
assert not tokens
|
solve(tc + 1)
|
[{"input": "3\n\n4\n\n2 3 5 4\n\n3\n\n1 2 3\n\n4\n\n3 1 3 2", "output": ["YES\nYES\nNO"]}]
|
block_completion_002035
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Consider an array $$$a$$$ of $$$n$$$ positive integers.You may perform the following operation: select two indices $$$l$$$ and $$$r$$$ ($$$1 \leq l \leq r \leq n$$$), then decrease all elements $$$a_l, a_{l + 1}, \dots, a_r$$$ by $$$1$$$. Let's call $$$f(a)$$$ the minimum number of operations needed to change array $$$a$$$ into an array of $$$n$$$ zeros.Determine if for all permutations$$$^\dagger$$$ $$$b$$$ of $$$a$$$, $$$f(a) \leq f(b)$$$ is true. $$$^\dagger$$$ An array $$$b$$$ is a permutation of an array $$$a$$$ if $$$b$$$ consists of the elements of $$$a$$$ in arbitrary order. For example, $$$[4,2,3,4]$$$ is a permutation of $$$[3,2,4,4]$$$ while $$$[1,2,2]$$$ is not a permutation of $$$[1,2,3]$$$.
Input Specification: The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^4$$$) β the number of test cases. The first line of each test case contains a single integer $$$n$$$ ($$$1 \leq n \leq 10^5$$$) β the length of the array $$$a$$$. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 10^9$$$) β description of the array $$$a$$$. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print "YES" (without quotes) if for all permutations $$$b$$$ of $$$a$$$, $$$f(a) \leq f(b)$$$ is true, and "NO" (without quotes) otherwise. You can output "YES" and "NO" in any case (for example, strings "yEs", "yes" and "Yes" will be recognized as a positive response).
Notes: NoteIn the first test case, we can change all elements to $$$0$$$ in $$$5$$$ operations. It can be shown that no permutation of $$$[2, 3, 5, 4]$$$ requires less than $$$5$$$ operations to change all elements to $$$0$$$.In the third test case, we need $$$5$$$ operations to change all elements to $$$0$$$, while $$$[2, 3, 3, 1]$$$ only needs $$$3$$$ operations.
Code:
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
def isMountain(ar):
prefixInc = [False] * len(ar)
prefixInc[0] = 1
for i in range(1, len(ar)):
# TODO: Your code here
suffixInc = [0] * len(ar)
suffixInc[-1] = 1
for i in range(len(ar) - 2, -1, -1):
suffixInc[i] = suffixInc[i + 1] and ar[i] >= ar[i + 1]
ans = prefixInc[-1] or suffixInc[0]
for i in range(len(ar)):
ans = ans or (prefixInc[i] and suffixInc[i])
return ans
testcase = True
def solve(testcase = 1):
N = nextInt()
A = getIntArray(N)
print("yes" if isMountain(A) else "no")
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
def isMountain(ar):
prefixInc = [False] * len(ar)
prefixInc[0] = 1
for i in range(1, len(ar)):
{{completion}}
suffixInc = [0] * len(ar)
suffixInc[-1] = 1
for i in range(len(ar) - 2, -1, -1):
suffixInc[i] = suffixInc[i + 1] and ar[i] >= ar[i + 1]
ans = prefixInc[-1] or suffixInc[0]
for i in range(len(ar)):
ans = ans or (prefixInc[i] and suffixInc[i])
return ans
testcase = True
def solve(testcase = 1):
N = nextInt()
A = getIntArray(N)
print("yes" if isMountain(A) else "no")
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
prefixInc[i] = prefixInc[i - 1] and ar[i - 1] <= ar[i]
|
[{"input": "3\n\n4\n\n2 3 5 4\n\n3\n\n1 2 3\n\n4\n\n3 1 3 2", "output": ["YES\nYES\nNO"]}]
|
block_completion_002036
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are living on an infinite plane with the Cartesian coordinate system on it. In one move you can go to any of the four adjacent points (left, right, up, down).More formally, if you are standing at the point $$$(x, y)$$$, you can: go left, and move to $$$(x - 1, y)$$$, or go right, and move to $$$(x + 1, y)$$$, or go up, and move to $$$(x, y + 1)$$$, or go down, and move to $$$(x, y - 1)$$$. There are $$$n$$$ boxes on this plane. The $$$i$$$-th box has coordinates $$$(x_i,y_i)$$$. It is guaranteed that the boxes are either on the $$$x$$$-axis or the $$$y$$$-axis. That is, either $$$x_i=0$$$ or $$$y_i=0$$$.You can collect a box if you and the box are at the same point. Find the minimum number of moves you have to perform to collect all of these boxes if you have to start and finish at the point $$$(0,0)$$$.
Input Specification: The first line contains a single integer $$$t$$$ ($$$1 \le t \le 100$$$) β the number of test cases. The first line of each test case contains a single integer $$$n$$$ ($$$1 \le n \le 100$$$) β the number of boxes. The $$$i$$$-th line of the following $$$n$$$ lines contains two integers $$$x_i$$$ and $$$y_i$$$ ($$$-100 \le x_i, y_i \le 100$$$) β the coordinate of the $$$i$$$-th box. It is guaranteed that either $$$x_i=0$$$ or $$$y_i=0$$$. Do note that the sum of $$$n$$$ over all test cases is not bounded.
Output Specification: For each test case output a single integer β the minimum number of moves required.
Notes: NoteIn the first test case, a possible sequence of moves that uses the minimum number of moves required is shown below. $$$$$$(0,0) \to (1,0) \to (1,1) \to (1, 2) \to (0,2) \to (-1,2) \to (-1,1) \to (-1,0) \to (-1,-1) \to (-1,-2) \to (0,-2) \to (0,-1) \to (0,0)$$$$$$ In the second test case, a possible sequence of moves that uses the minimum number of moves required is shown below. $$$$$$(0,0) \to (0,1) \to (0,2) \to (-1, 2) \to (-2,2) \to (-3,2) \to (-3,1) \to (-3,0) \to (-3,-1) \to (-2,-1) \to (-1,-1) \to (0,-1) \to (0,0)$$$$$$ In the third test case, we can collect all boxes without making any moves.
Code:
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N = nextInt()
P = [getIntArray(2) for i in range(N)] + [[0, 0]]
minX = abs(min(p[0] for p in P))
maxX = abs(max(p[0] for p in P))
minY = abs(min(p[1] for p in P))
maxY = abs(max(p[1] for p in P))
print(minX + minY + maxX + maxY << 1)
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
# TODO: Your code here
assert not tokens
|
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N = nextInt()
P = [getIntArray(2) for i in range(N)] + [[0, 0]]
minX = abs(min(p[0] for p in P))
maxX = abs(max(p[0] for p in P))
minY = abs(min(p[1] for p in P))
maxY = abs(max(p[1] for p in P))
print(minX + minY + maxX + maxY << 1)
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
{{completion}}
assert not tokens
|
solve(tc + 1)
|
[{"input": "3\n\n4\n\n0 -2\n\n1 0\n\n-1 0\n\n0 2\n\n3\n\n0 2\n\n-3 0\n\n0 -1\n\n1\n\n0 0", "output": ["12\n12\n0"]}]
|
block_completion_002068
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: My orzlers, we can optimize this problem from $$$O(S^3)$$$ to $$$O\left(T^\frac{5}{9}\right)$$$!β Spyofgame, founder of Orzlim religionA long time ago, Spyofgame invented the famous array $$$a$$$ ($$$1$$$-indexed) of length $$$n$$$ that contains information about the world and life. After that, he decided to convert it into the matrix $$$b$$$ ($$$0$$$-indexed) of size $$$(n + 1) \times (n + 1)$$$ which contains information about the world, life and beyond.Spyofgame converted $$$a$$$ into $$$b$$$ with the following rules. $$$b_{i,0} = 0$$$ if $$$0 \leq i \leq n$$$; $$$b_{0,i} = a_{i}$$$ if $$$1 \leq i \leq n$$$; $$$b_{i,j} = b_{i,j-1} \oplus b_{i-1,j}$$$ if $$$1 \leq i, j \leq n$$$. Here $$$\oplus$$$ denotes the bitwise XOR operation.Today, archaeologists have discovered the famous matrix $$$b$$$. However, many elements of the matrix has been lost. They only know the values of $$$b_{i,n}$$$ for $$$1 \leq i \leq n$$$ (note that these are some elements of the last column, not the last row).The archaeologists want to know what a possible array of $$$a$$$ is. Can you help them reconstruct any array that could be $$$a$$$?
Input Specification: The first line contains a single integer $$$n$$$ ($$$1 \leq n \leq 5 \cdot 10^5$$$). The second line contains $$$n$$$ integers $$$b_{1,n}, b_{2,n}, \ldots, b_{n,n}$$$ ($$$0 \leq b_{i,n} < 2^{30}$$$).
Output Specification: If some array $$$a$$$ is consistent with the information, print a line containing $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$. If there are multiple solutions, output any. If such an array does not exist, output $$$-1$$$ instead.
Notes: NoteIf we let $$$a = [1,2,3]$$$, then $$$b$$$ will be: $$$\bf{0}$$$$$$\bf{1}$$$$$$\bf{2}$$$$$$\bf{3}$$$$$$\bf{0}$$$$$$1$$$$$$3$$$$$$0$$$$$$\bf{0}$$$$$$1$$$$$$2$$$$$$2$$$$$$\bf{0}$$$$$$1$$$$$$3$$$$$$1$$$ The values of $$$b_{1,n}, b_{2,n}, \ldots, b_{n,n}$$$ generated are $$$[0,2,1]$$$ which is consistent with what the archaeologists have discovered.
Code:
a=[*map(int,[*open(0)][1].split())]
for k in 0,1:
for i in range(19):
z=1<<i
for j in range(len(a)):
if j&z:# TODO: Your code here
print(*reversed(a))
|
a=[*map(int,[*open(0)][1].split())]
for k in 0,1:
for i in range(19):
z=1<<i
for j in range(len(a)):
if j&z:{{completion}}
print(*reversed(a))
|
a[j-k*z]^=a[j+k*z-z]
|
[{"input": "3\n0 2 1", "output": ["1 2 3"]}, {"input": "1\n199633", "output": ["199633"]}, {"input": "10\n346484077 532933626 858787727 369947090 299437981 416813461 865836801 141384800 157794568 691345607", "output": ["725081944 922153789 481174947 427448285 516570428 509717938 855104873 280317429 281091129 1050390365"]}]
|
block_completion_002116
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: My orzlers, we can optimize this problem from $$$O(S^3)$$$ to $$$O\left(T^\frac{5}{9}\right)$$$!β Spyofgame, founder of Orzlim religionA long time ago, Spyofgame invented the famous array $$$a$$$ ($$$1$$$-indexed) of length $$$n$$$ that contains information about the world and life. After that, he decided to convert it into the matrix $$$b$$$ ($$$0$$$-indexed) of size $$$(n + 1) \times (n + 1)$$$ which contains information about the world, life and beyond.Spyofgame converted $$$a$$$ into $$$b$$$ with the following rules. $$$b_{i,0} = 0$$$ if $$$0 \leq i \leq n$$$; $$$b_{0,i} = a_{i}$$$ if $$$1 \leq i \leq n$$$; $$$b_{i,j} = b_{i,j-1} \oplus b_{i-1,j}$$$ if $$$1 \leq i, j \leq n$$$. Here $$$\oplus$$$ denotes the bitwise XOR operation.Today, archaeologists have discovered the famous matrix $$$b$$$. However, many elements of the matrix has been lost. They only know the values of $$$b_{i,n}$$$ for $$$1 \leq i \leq n$$$ (note that these are some elements of the last column, not the last row).The archaeologists want to know what a possible array of $$$a$$$ is. Can you help them reconstruct any array that could be $$$a$$$?
Input Specification: The first line contains a single integer $$$n$$$ ($$$1 \leq n \leq 5 \cdot 10^5$$$). The second line contains $$$n$$$ integers $$$b_{1,n}, b_{2,n}, \ldots, b_{n,n}$$$ ($$$0 \leq b_{i,n} < 2^{30}$$$).
Output Specification: If some array $$$a$$$ is consistent with the information, print a line containing $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$. If there are multiple solutions, output any. If such an array does not exist, output $$$-1$$$ instead.
Notes: NoteIf we let $$$a = [1,2,3]$$$, then $$$b$$$ will be: $$$\bf{0}$$$$$$\bf{1}$$$$$$\bf{2}$$$$$$\bf{3}$$$$$$\bf{0}$$$$$$1$$$$$$3$$$$$$0$$$$$$\bf{0}$$$$$$1$$$$$$2$$$$$$2$$$$$$\bf{0}$$$$$$1$$$$$$3$$$$$$1$$$ The values of $$$b_{1,n}, b_{2,n}, \ldots, b_{n,n}$$$ generated are $$$[0,2,1]$$$ which is consistent with what the archaeologists have discovered.
Code:
a=[*map(int,[*open(0)][1].split())]
n=len(a)
for k in 0,1:
for i in range(19):
for j in range(n):
l=j^1<<i
if k^(l<j)and l<n:
# TODO: Your code here
print(*reversed(a))
|
a=[*map(int,[*open(0)][1].split())]
n=len(a)
for k in 0,1:
for i in range(19):
for j in range(n):
l=j^1<<i
if k^(l<j)and l<n:
{{completion}}
print(*reversed(a))
|
a[j]^=a[l]
|
[{"input": "3\n0 2 1", "output": ["1 2 3"]}, {"input": "1\n199633", "output": ["199633"]}, {"input": "10\n346484077 532933626 858787727 369947090 299437981 416813461 865836801 141384800 157794568 691345607", "output": ["725081944 922153789 481174947 427448285 516570428 509717938 855104873 280317429 281091129 1050390365"]}]
|
block_completion_002117
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a string $$$s$$$ consisting of $$$n$$$ characters. Each character of $$$s$$$ is either 0 or 1.A substring of $$$s$$$ is a contiguous subsequence of its characters.You have to choose two substrings of $$$s$$$ (possibly intersecting, possibly the same, possibly non-intersecting β just any two substrings). After choosing them, you calculate the value of the chosen pair of substrings as follows: let $$$s_1$$$ be the first substring, $$$s_2$$$ be the second chosen substring, and $$$f(s_i)$$$ be the integer such that $$$s_i$$$ is its binary representation (for example, if $$$s_i$$$ is 11010, $$$f(s_i) = 26$$$); the value is the bitwise OR of $$$f(s_1)$$$ and $$$f(s_2)$$$. Calculate the maximum possible value you can get, and print it in binary representation without leading zeroes.
Input Specification: The first line contains one integer $$$n$$$ β the number of characters in $$$s$$$. The second line contains $$$s$$$ itself, consisting of exactly $$$n$$$ characters 0 and/or 1. All non-example tests in this problem are generated randomly: every character of $$$s$$$ is chosen independently of other characters; for each character, the probability of it being 1 is exactly $$$\frac{1}{2}$$$. This problem has exactly $$$40$$$ tests. Tests from $$$1$$$ to $$$3$$$ are the examples; tests from $$$4$$$ to $$$40$$$ are generated randomly. In tests from $$$4$$$ to $$$10$$$, $$$n = 5$$$; in tests from $$$11$$$ to $$$20$$$, $$$n = 1000$$$; in tests from $$$21$$$ to $$$40$$$, $$$n = 10^6$$$. Hacks are forbidden in this problem.
Output Specification: Print the maximum possible value you can get in binary representation without leading zeroes.
Notes: NoteIn the first example, you can choose the substrings 11010 and 101. $$$f(s_1) = 26$$$, $$$f(s_2) = 5$$$, their bitwise OR is $$$31$$$, and the binary representation of $$$31$$$ is 11111.In the second example, you can choose the substrings 1110010 and 11100.
Code:
input()
n = int(input(), 2)
m = n
for i in range(30):
# TODO: Your code here
print(bin(n)[2:])
|
input()
n = int(input(), 2)
m = n
for i in range(30):
{{completion}}
print(bin(n)[2:])
|
n = max(n, m | m >> i)
|
[{"input": "5\n11010", "output": ["11111"]}, {"input": "7\n1110010", "output": ["1111110"]}, {"input": "4\n0000", "output": ["0"]}]
|
block_completion_002155
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a string $$$s$$$ consisting of $$$n$$$ characters. Each character of $$$s$$$ is either 0 or 1.A substring of $$$s$$$ is a contiguous subsequence of its characters.You have to choose two substrings of $$$s$$$ (possibly intersecting, possibly the same, possibly non-intersecting β just any two substrings). After choosing them, you calculate the value of the chosen pair of substrings as follows: let $$$s_1$$$ be the first substring, $$$s_2$$$ be the second chosen substring, and $$$f(s_i)$$$ be the integer such that $$$s_i$$$ is its binary representation (for example, if $$$s_i$$$ is 11010, $$$f(s_i) = 26$$$); the value is the bitwise OR of $$$f(s_1)$$$ and $$$f(s_2)$$$. Calculate the maximum possible value you can get, and print it in binary representation without leading zeroes.
Input Specification: The first line contains one integer $$$n$$$ β the number of characters in $$$s$$$. The second line contains $$$s$$$ itself, consisting of exactly $$$n$$$ characters 0 and/or 1. All non-example tests in this problem are generated randomly: every character of $$$s$$$ is chosen independently of other characters; for each character, the probability of it being 1 is exactly $$$\frac{1}{2}$$$. This problem has exactly $$$40$$$ tests. Tests from $$$1$$$ to $$$3$$$ are the examples; tests from $$$4$$$ to $$$40$$$ are generated randomly. In tests from $$$4$$$ to $$$10$$$, $$$n = 5$$$; in tests from $$$11$$$ to $$$20$$$, $$$n = 1000$$$; in tests from $$$21$$$ to $$$40$$$, $$$n = 10^6$$$. Hacks are forbidden in this problem.
Output Specification: Print the maximum possible value you can get in binary representation without leading zeroes.
Notes: NoteIn the first example, you can choose the substrings 11010 and 101. $$$f(s_1) = 26$$$, $$$f(s_2) = 5$$$, their bitwise OR is $$$31$$$, and the binary representation of $$$31$$$ is 11111.In the second example, you can choose the substrings 1110010 and 11100.
Code:
n = int(input())
s=input()
b=int(s,2)
a=b;
mx=a|b
for i in range(0,7):
a=a>>1
m=a|b
if m>mx:
# TODO: Your code here
st=format(mx ,"b")
print(st)
|
n = int(input())
s=input()
b=int(s,2)
a=b;
mx=a|b
for i in range(0,7):
a=a>>1
m=a|b
if m>mx:
{{completion}}
st=format(mx ,"b")
print(st)
|
mx=m
|
[{"input": "5\n11010", "output": ["11111"]}, {"input": "7\n1110010", "output": ["1111110"]}, {"input": "4\n0000", "output": ["0"]}]
|
block_completion_002156
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a string $$$s$$$ consisting of $$$n$$$ characters. Each character of $$$s$$$ is either 0 or 1.A substring of $$$s$$$ is a contiguous subsequence of its characters.You have to choose two substrings of $$$s$$$ (possibly intersecting, possibly the same, possibly non-intersecting β just any two substrings). After choosing them, you calculate the value of the chosen pair of substrings as follows: let $$$s_1$$$ be the first substring, $$$s_2$$$ be the second chosen substring, and $$$f(s_i)$$$ be the integer such that $$$s_i$$$ is its binary representation (for example, if $$$s_i$$$ is 11010, $$$f(s_i) = 26$$$); the value is the bitwise OR of $$$f(s_1)$$$ and $$$f(s_2)$$$. Calculate the maximum possible value you can get, and print it in binary representation without leading zeroes.
Input Specification: The first line contains one integer $$$n$$$ β the number of characters in $$$s$$$. The second line contains $$$s$$$ itself, consisting of exactly $$$n$$$ characters 0 and/or 1. All non-example tests in this problem are generated randomly: every character of $$$s$$$ is chosen independently of other characters; for each character, the probability of it being 1 is exactly $$$\frac{1}{2}$$$. This problem has exactly $$$40$$$ tests. Tests from $$$1$$$ to $$$3$$$ are the examples; tests from $$$4$$$ to $$$40$$$ are generated randomly. In tests from $$$4$$$ to $$$10$$$, $$$n = 5$$$; in tests from $$$11$$$ to $$$20$$$, $$$n = 1000$$$; in tests from $$$21$$$ to $$$40$$$, $$$n = 10^6$$$. Hacks are forbidden in this problem.
Output Specification: Print the maximum possible value you can get in binary representation without leading zeroes.
Notes: NoteIn the first example, you can choose the substrings 11010 and 101. $$$f(s_1) = 26$$$, $$$f(s_2) = 5$$$, their bitwise OR is $$$31$$$, and the binary representation of $$$31$$$ is 11111.In the second example, you can choose the substrings 1110010 and 11100.
Code:
n = input()
s = int(input(),2)
res = 0
for i in range(100):
# TODO: Your code here
ans = bin(res)[2:]
print(ans)
|
n = input()
s = int(input(),2)
res = 0
for i in range(100):
{{completion}}
ans = bin(res)[2:]
print(ans)
|
res = max(res,(s | (s >> i)))
|
[{"input": "5\n11010", "output": ["11111"]}, {"input": "7\n1110010", "output": ["1111110"]}, {"input": "4\n0000", "output": ["0"]}]
|
block_completion_002157
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a string $$$s$$$ consisting of $$$n$$$ characters. Each character of $$$s$$$ is either 0 or 1.A substring of $$$s$$$ is a contiguous subsequence of its characters.You have to choose two substrings of $$$s$$$ (possibly intersecting, possibly the same, possibly non-intersecting β just any two substrings). After choosing them, you calculate the value of the chosen pair of substrings as follows: let $$$s_1$$$ be the first substring, $$$s_2$$$ be the second chosen substring, and $$$f(s_i)$$$ be the integer such that $$$s_i$$$ is its binary representation (for example, if $$$s_i$$$ is 11010, $$$f(s_i) = 26$$$); the value is the bitwise OR of $$$f(s_1)$$$ and $$$f(s_2)$$$. Calculate the maximum possible value you can get, and print it in binary representation without leading zeroes.
Input Specification: The first line contains one integer $$$n$$$ β the number of characters in $$$s$$$. The second line contains $$$s$$$ itself, consisting of exactly $$$n$$$ characters 0 and/or 1. All non-example tests in this problem are generated randomly: every character of $$$s$$$ is chosen independently of other characters; for each character, the probability of it being 1 is exactly $$$\frac{1}{2}$$$. This problem has exactly $$$40$$$ tests. Tests from $$$1$$$ to $$$3$$$ are the examples; tests from $$$4$$$ to $$$40$$$ are generated randomly. In tests from $$$4$$$ to $$$10$$$, $$$n = 5$$$; in tests from $$$11$$$ to $$$20$$$, $$$n = 1000$$$; in tests from $$$21$$$ to $$$40$$$, $$$n = 10^6$$$. Hacks are forbidden in this problem.
Output Specification: Print the maximum possible value you can get in binary representation without leading zeroes.
Notes: NoteIn the first example, you can choose the substrings 11010 and 101. $$$f(s_1) = 26$$$, $$$f(s_2) = 5$$$, their bitwise OR is $$$31$$$, and the binary representation of $$$31$$$ is 11111.In the second example, you can choose the substrings 1110010 and 11100.
Code:
input()
n=int(input(),2)
ans=0
for i in range(1,64):
# TODO: Your code here
print(bin(ans)[2:])
|
input()
n=int(input(),2)
ans=0
for i in range(1,64):
{{completion}}
print(bin(ans)[2:])
|
ans=max(ans,n|(n>>i))
|
[{"input": "5\n11010", "output": ["11111"]}, {"input": "7\n1110010", "output": ["1111110"]}, {"input": "4\n0000", "output": ["0"]}]
|
block_completion_002158
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a string $$$s$$$ consisting of $$$n$$$ characters. Each character of $$$s$$$ is either 0 or 1.A substring of $$$s$$$ is a contiguous subsequence of its characters.You have to choose two substrings of $$$s$$$ (possibly intersecting, possibly the same, possibly non-intersecting β just any two substrings). After choosing them, you calculate the value of the chosen pair of substrings as follows: let $$$s_1$$$ be the first substring, $$$s_2$$$ be the second chosen substring, and $$$f(s_i)$$$ be the integer such that $$$s_i$$$ is its binary representation (for example, if $$$s_i$$$ is 11010, $$$f(s_i) = 26$$$); the value is the bitwise OR of $$$f(s_1)$$$ and $$$f(s_2)$$$. Calculate the maximum possible value you can get, and print it in binary representation without leading zeroes.
Input Specification: The first line contains one integer $$$n$$$ β the number of characters in $$$s$$$. The second line contains $$$s$$$ itself, consisting of exactly $$$n$$$ characters 0 and/or 1. All non-example tests in this problem are generated randomly: every character of $$$s$$$ is chosen independently of other characters; for each character, the probability of it being 1 is exactly $$$\frac{1}{2}$$$. This problem has exactly $$$40$$$ tests. Tests from $$$1$$$ to $$$3$$$ are the examples; tests from $$$4$$$ to $$$40$$$ are generated randomly. In tests from $$$4$$$ to $$$10$$$, $$$n = 5$$$; in tests from $$$11$$$ to $$$20$$$, $$$n = 1000$$$; in tests from $$$21$$$ to $$$40$$$, $$$n = 10^6$$$. Hacks are forbidden in this problem.
Output Specification: Print the maximum possible value you can get in binary representation without leading zeroes.
Notes: NoteIn the first example, you can choose the substrings 11010 and 101. $$$f(s_1) = 26$$$, $$$f(s_2) = 5$$$, their bitwise OR is $$$31$$$, and the binary representation of $$$31$$$ is 11111.In the second example, you can choose the substrings 1110010 and 11100.
Code:
n = input()
s = int(input(), base=2)
t = s
for i in range(1,10):
# TODO: Your code here
print("{0:b}".format(t))
|
n = input()
s = int(input(), base=2)
t = s
for i in range(1,10):
{{completion}}
print("{0:b}".format(t))
|
t = max(t, s | s >> i)
|
[{"input": "5\n11010", "output": ["11111"]}, {"input": "7\n1110010", "output": ["1111110"]}, {"input": "4\n0000", "output": ["0"]}]
|
block_completion_002159
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a string $$$s$$$ consisting of $$$n$$$ characters. Each character of $$$s$$$ is either 0 or 1.A substring of $$$s$$$ is a contiguous subsequence of its characters.You have to choose two substrings of $$$s$$$ (possibly intersecting, possibly the same, possibly non-intersecting β just any two substrings). After choosing them, you calculate the value of the chosen pair of substrings as follows: let $$$s_1$$$ be the first substring, $$$s_2$$$ be the second chosen substring, and $$$f(s_i)$$$ be the integer such that $$$s_i$$$ is its binary representation (for example, if $$$s_i$$$ is 11010, $$$f(s_i) = 26$$$); the value is the bitwise OR of $$$f(s_1)$$$ and $$$f(s_2)$$$. Calculate the maximum possible value you can get, and print it in binary representation without leading zeroes.
Input Specification: The first line contains one integer $$$n$$$ β the number of characters in $$$s$$$. The second line contains $$$s$$$ itself, consisting of exactly $$$n$$$ characters 0 and/or 1. All non-example tests in this problem are generated randomly: every character of $$$s$$$ is chosen independently of other characters; for each character, the probability of it being 1 is exactly $$$\frac{1}{2}$$$. This problem has exactly $$$40$$$ tests. Tests from $$$1$$$ to $$$3$$$ are the examples; tests from $$$4$$$ to $$$40$$$ are generated randomly. In tests from $$$4$$$ to $$$10$$$, $$$n = 5$$$; in tests from $$$11$$$ to $$$20$$$, $$$n = 1000$$$; in tests from $$$21$$$ to $$$40$$$, $$$n = 10^6$$$. Hacks are forbidden in this problem.
Output Specification: Print the maximum possible value you can get in binary representation without leading zeroes.
Notes: NoteIn the first example, you can choose the substrings 11010 and 101. $$$f(s_1) = 26$$$, $$$f(s_2) = 5$$$, their bitwise OR is $$$31$$$, and the binary representation of $$$31$$$ is 11111.In the second example, you can choose the substrings 1110010 and 11100.
Code:
n = int(input())
s = input().strip()
s1 = int('0b'+s,2)
res = s1
for i in range(1,8):
# TODO: Your code here
print(bin(res)[2:])
|
n = int(input())
s = input().strip()
s1 = int('0b'+s,2)
res = s1
for i in range(1,8):
{{completion}}
print(bin(res)[2:])
|
res = max(s1 | (s1 >> i), res)
|
[{"input": "5\n11010", "output": ["11111"]}, {"input": "7\n1110010", "output": ["1111110"]}, {"input": "4\n0000", "output": ["0"]}]
|
block_completion_002160
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a string $$$s$$$ consisting of $$$n$$$ characters. Each character of $$$s$$$ is either 0 or 1.A substring of $$$s$$$ is a contiguous subsequence of its characters.You have to choose two substrings of $$$s$$$ (possibly intersecting, possibly the same, possibly non-intersecting β just any two substrings). After choosing them, you calculate the value of the chosen pair of substrings as follows: let $$$s_1$$$ be the first substring, $$$s_2$$$ be the second chosen substring, and $$$f(s_i)$$$ be the integer such that $$$s_i$$$ is its binary representation (for example, if $$$s_i$$$ is 11010, $$$f(s_i) = 26$$$); the value is the bitwise OR of $$$f(s_1)$$$ and $$$f(s_2)$$$. Calculate the maximum possible value you can get, and print it in binary representation without leading zeroes.
Input Specification: The first line contains one integer $$$n$$$ β the number of characters in $$$s$$$. The second line contains $$$s$$$ itself, consisting of exactly $$$n$$$ characters 0 and/or 1. All non-example tests in this problem are generated randomly: every character of $$$s$$$ is chosen independently of other characters; for each character, the probability of it being 1 is exactly $$$\frac{1}{2}$$$. This problem has exactly $$$40$$$ tests. Tests from $$$1$$$ to $$$3$$$ are the examples; tests from $$$4$$$ to $$$40$$$ are generated randomly. In tests from $$$4$$$ to $$$10$$$, $$$n = 5$$$; in tests from $$$11$$$ to $$$20$$$, $$$n = 1000$$$; in tests from $$$21$$$ to $$$40$$$, $$$n = 10^6$$$. Hacks are forbidden in this problem.
Output Specification: Print the maximum possible value you can get in binary representation without leading zeroes.
Notes: NoteIn the first example, you can choose the substrings 11010 and 101. $$$f(s_1) = 26$$$, $$$f(s_2) = 5$$$, their bitwise OR is $$$31$$$, and the binary representation of $$$31$$$ is 11111.In the second example, you can choose the substrings 1110010 and 11100.
Code:
def random(st):
n = 8
st = int(st, 2)
MAX = st
for t in range(n):
# TODO: Your code here
return bin(MAX)[2:]
N = input()
b = input()
print(random(b))
|
def random(st):
n = 8
st = int(st, 2)
MAX = st
for t in range(n):
{{completion}}
return bin(MAX)[2:]
N = input()
b = input()
print(random(b))
|
MAX = max((st >> t) | st, MAX)
|
[{"input": "5\n11010", "output": ["11111"]}, {"input": "7\n1110010", "output": ["1111110"]}, {"input": "4\n0000", "output": ["0"]}]
|
block_completion_002161
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a string $$$s$$$ consisting of $$$n$$$ characters. Each character of $$$s$$$ is either 0 or 1.A substring of $$$s$$$ is a contiguous subsequence of its characters.You have to choose two substrings of $$$s$$$ (possibly intersecting, possibly the same, possibly non-intersecting β just any two substrings). After choosing them, you calculate the value of the chosen pair of substrings as follows: let $$$s_1$$$ be the first substring, $$$s_2$$$ be the second chosen substring, and $$$f(s_i)$$$ be the integer such that $$$s_i$$$ is its binary representation (for example, if $$$s_i$$$ is 11010, $$$f(s_i) = 26$$$); the value is the bitwise OR of $$$f(s_1)$$$ and $$$f(s_2)$$$. Calculate the maximum possible value you can get, and print it in binary representation without leading zeroes.
Input Specification: The first line contains one integer $$$n$$$ β the number of characters in $$$s$$$. The second line contains $$$s$$$ itself, consisting of exactly $$$n$$$ characters 0 and/or 1. All non-example tests in this problem are generated randomly: every character of $$$s$$$ is chosen independently of other characters; for each character, the probability of it being 1 is exactly $$$\frac{1}{2}$$$. This problem has exactly $$$40$$$ tests. Tests from $$$1$$$ to $$$3$$$ are the examples; tests from $$$4$$$ to $$$40$$$ are generated randomly. In tests from $$$4$$$ to $$$10$$$, $$$n = 5$$$; in tests from $$$11$$$ to $$$20$$$, $$$n = 1000$$$; in tests from $$$21$$$ to $$$40$$$, $$$n = 10^6$$$. Hacks are forbidden in this problem.
Output Specification: Print the maximum possible value you can get in binary representation without leading zeroes.
Notes: NoteIn the first example, you can choose the substrings 11010 and 101. $$$f(s_1) = 26$$$, $$$f(s_2) = 5$$$, their bitwise OR is $$$31$$$, and the binary representation of $$$31$$$ is 11111.In the second example, you can choose the substrings 1110010 and 11100.
Code:
# ΩΨ―Ω Ψ§ΩΩ ΨΨ§Ψ¬Ω Ψ¨Ψ¨Ψ§ΩΨ«ΩΩ
input()
n=int(input(),2)
m=n
for i in range(1,100):# TODO: Your code here
print("{0:b}".format(m))
|
# ΩΨ―Ω Ψ§ΩΩ ΨΨ§Ψ¬Ω Ψ¨Ψ¨Ψ§ΩΨ«ΩΩ
input()
n=int(input(),2)
m=n
for i in range(1,100):{{completion}}
print("{0:b}".format(m))
|
m=max(m,n|n>>i)
|
[{"input": "5\n11010", "output": ["11111"]}, {"input": "7\n1110010", "output": ["1111110"]}, {"input": "4\n0000", "output": ["0"]}]
|
block_completion_002162
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a string $$$s$$$ consisting of $$$n$$$ characters. Each character of $$$s$$$ is either 0 or 1.A substring of $$$s$$$ is a contiguous subsequence of its characters.You have to choose two substrings of $$$s$$$ (possibly intersecting, possibly the same, possibly non-intersecting β just any two substrings). After choosing them, you calculate the value of the chosen pair of substrings as follows: let $$$s_1$$$ be the first substring, $$$s_2$$$ be the second chosen substring, and $$$f(s_i)$$$ be the integer such that $$$s_i$$$ is its binary representation (for example, if $$$s_i$$$ is 11010, $$$f(s_i) = 26$$$); the value is the bitwise OR of $$$f(s_1)$$$ and $$$f(s_2)$$$. Calculate the maximum possible value you can get, and print it in binary representation without leading zeroes.
Input Specification: The first line contains one integer $$$n$$$ β the number of characters in $$$s$$$. The second line contains $$$s$$$ itself, consisting of exactly $$$n$$$ characters 0 and/or 1. All non-example tests in this problem are generated randomly: every character of $$$s$$$ is chosen independently of other characters; for each character, the probability of it being 1 is exactly $$$\frac{1}{2}$$$. This problem has exactly $$$40$$$ tests. Tests from $$$1$$$ to $$$3$$$ are the examples; tests from $$$4$$$ to $$$40$$$ are generated randomly. In tests from $$$4$$$ to $$$10$$$, $$$n = 5$$$; in tests from $$$11$$$ to $$$20$$$, $$$n = 1000$$$; in tests from $$$21$$$ to $$$40$$$, $$$n = 10^6$$$. Hacks are forbidden in this problem.
Output Specification: Print the maximum possible value you can get in binary representation without leading zeroes.
Notes: NoteIn the first example, you can choose the substrings 11010 and 101. $$$f(s_1) = 26$$$, $$$f(s_2) = 5$$$, their bitwise OR is $$$31$$$, and the binary representation of $$$31$$$ is 11111.In the second example, you can choose the substrings 1110010 and 11100.
Code:
n = int(input())
a = int(input(), 2)
temp = a
mx = a|temp
for i in range(7):
temp = temp >> 1
m = a|temp
if mx < m:
# TODO: Your code here
print(bin(mx).replace('0b', ''))
|
n = int(input())
a = int(input(), 2)
temp = a
mx = a|temp
for i in range(7):
temp = temp >> 1
m = a|temp
if mx < m:
{{completion}}
print(bin(mx).replace('0b', ''))
|
mx = m
|
[{"input": "5\n11010", "output": ["11111"]}, {"input": "7\n1110010", "output": ["1111110"]}, {"input": "4\n0000", "output": ["0"]}]
|
block_completion_002163
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given $$$n$$$ segments on the coordinate axis. The $$$i$$$-th segment is $$$[l_i, r_i]$$$. Let's denote the set of all integer points belonging to the $$$i$$$-th segment as $$$S_i$$$.Let $$$A \cup B$$$ be the union of two sets $$$A$$$ and $$$B$$$, $$$A \cap B$$$ be the intersection of two sets $$$A$$$ and $$$B$$$, and $$$A \oplus B$$$ be the symmetric difference of $$$A$$$ and $$$B$$$ (a set which contains all elements of $$$A$$$ and all elements of $$$B$$$, except for the ones that belong to both sets).Let $$$[\mathbin{op}_1, \mathbin{op}_2, \dots, \mathbin{op}_{n-1}]$$$ be an array where each element is either $$$\cup$$$, $$$\oplus$$$, or $$$\cap$$$. Over all $$$3^{n-1}$$$ ways to choose this array, calculate the sum of the following values:$$$$$$|(((S_1\ \mathbin{op}_1\ S_2)\ \mathbin{op}_2\ S_3)\ \mathbin{op}_3\ S_4)\ \dots\ \mathbin{op}_{n-1}\ S_n|$$$$$$In this expression, $$$|S|$$$ denotes the size of the set $$$S$$$.
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 3 \cdot 10^5$$$). Then, $$$n$$$ lines follow. The $$$i$$$-th of them contains two integers $$$l_i$$$ and $$$r_i$$$ ($$$0 \le l_i \le r_i \le 3 \cdot 10^5$$$).
Output Specification: Print one integer β the sum of $$$|(((S_1\ \mathbin{op}_1\ S_2)\ \mathbin{op}_2\ S_3)\ \mathbin{op}_3\ S_4)\ \dots\ \mathbin{op}_{n-1}\ S_n|$$$ over all possible ways to choose $$$[\mathbin{op}_1, \mathbin{op}_2, \dots, \mathbin{op}_{n-1}]$$$. Since the answer can be huge, print it modulo $$$998244353$$$.
Code:
import sys
import heapq
from collections import Counter
# sys.setrecursionlimit(10000)
def input_general():
return sys.stdin.readline().rstrip('\r\n')
def input_num():
return int(sys.stdin.readline().rstrip("\r\n"))
def input_multi(x=int):
return map(x, sys.stdin.readline().rstrip("\r\n").split())
def input_list(x=int):
return list(input_multi(x))
def main():
def mod_pow(p, a, e):
base = a
answer = 1
while e:
if e & 1:
# TODO: Your code here
base = (base * base) % p
e >>= 1
return answer
n = input_num()
hp = []
pos = [[] for _ in range(300001)]
for i in range(n):
l, r = input_multi()
pos[l].append((i, r + 1))
P = 998244353
two_inv = (P + 1) // 2
loc = [-1] * 300001
for i in range(300001):
for (idx, r) in pos[i]:
heapq.heappush(hp, (-idx, r))
while hp and hp[0][1] <= i:
heapq.heappop(hp)
if hp:
loc[i] = -hp[0][0]
ctr = Counter(loc)
max_loc = max(ctr.keys())
curr = mod_pow(P, 2, n - 1)
answer = (curr * (ctr[0] + ctr[1])) % P
for i in range(2, max_loc + 1):
curr = (curr * two_inv * 3) % P
answer = (answer + curr * ctr[i]) % P
print(answer)
if __name__ == "__main__":
# cases = input_num()
#
# for _ in range(cases):
main()
|
import sys
import heapq
from collections import Counter
# sys.setrecursionlimit(10000)
def input_general():
return sys.stdin.readline().rstrip('\r\n')
def input_num():
return int(sys.stdin.readline().rstrip("\r\n"))
def input_multi(x=int):
return map(x, sys.stdin.readline().rstrip("\r\n").split())
def input_list(x=int):
return list(input_multi(x))
def main():
def mod_pow(p, a, e):
base = a
answer = 1
while e:
if e & 1:
{{completion}}
base = (base * base) % p
e >>= 1
return answer
n = input_num()
hp = []
pos = [[] for _ in range(300001)]
for i in range(n):
l, r = input_multi()
pos[l].append((i, r + 1))
P = 998244353
two_inv = (P + 1) // 2
loc = [-1] * 300001
for i in range(300001):
for (idx, r) in pos[i]:
heapq.heappush(hp, (-idx, r))
while hp and hp[0][1] <= i:
heapq.heappop(hp)
if hp:
loc[i] = -hp[0][0]
ctr = Counter(loc)
max_loc = max(ctr.keys())
curr = mod_pow(P, 2, n - 1)
answer = (curr * (ctr[0] + ctr[1])) % P
for i in range(2, max_loc + 1):
curr = (curr * two_inv * 3) % P
answer = (answer + curr * ctr[i]) % P
print(answer)
if __name__ == "__main__":
# cases = input_num()
#
# for _ in range(cases):
main()
|
answer = (answer * base) % p
|
[{"input": "4\n3 5\n4 8\n2 2\n1 9", "output": ["162"]}, {"input": "4\n1 9\n3 5\n4 8\n2 2", "output": ["102"]}]
|
block_completion_002199
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given $$$n$$$ segments on the coordinate axis. The $$$i$$$-th segment is $$$[l_i, r_i]$$$. Let's denote the set of all integer points belonging to the $$$i$$$-th segment as $$$S_i$$$.Let $$$A \cup B$$$ be the union of two sets $$$A$$$ and $$$B$$$, $$$A \cap B$$$ be the intersection of two sets $$$A$$$ and $$$B$$$, and $$$A \oplus B$$$ be the symmetric difference of $$$A$$$ and $$$B$$$ (a set which contains all elements of $$$A$$$ and all elements of $$$B$$$, except for the ones that belong to both sets).Let $$$[\mathbin{op}_1, \mathbin{op}_2, \dots, \mathbin{op}_{n-1}]$$$ be an array where each element is either $$$\cup$$$, $$$\oplus$$$, or $$$\cap$$$. Over all $$$3^{n-1}$$$ ways to choose this array, calculate the sum of the following values:$$$$$$|(((S_1\ \mathbin{op}_1\ S_2)\ \mathbin{op}_2\ S_3)\ \mathbin{op}_3\ S_4)\ \dots\ \mathbin{op}_{n-1}\ S_n|$$$$$$In this expression, $$$|S|$$$ denotes the size of the set $$$S$$$.
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 3 \cdot 10^5$$$). Then, $$$n$$$ lines follow. The $$$i$$$-th of them contains two integers $$$l_i$$$ and $$$r_i$$$ ($$$0 \le l_i \le r_i \le 3 \cdot 10^5$$$).
Output Specification: Print one integer β the sum of $$$|(((S_1\ \mathbin{op}_1\ S_2)\ \mathbin{op}_2\ S_3)\ \mathbin{op}_3\ S_4)\ \dots\ \mathbin{op}_{n-1}\ S_n|$$$ over all possible ways to choose $$$[\mathbin{op}_1, \mathbin{op}_2, \dots, \mathbin{op}_{n-1}]$$$. Since the answer can be huge, print it modulo $$$998244353$$$.
Code:
import sys
import heapq
from collections import Counter
# sys.setrecursionlimit(10000)
def input_general():
return sys.stdin.readline().rstrip('\r\n')
def input_num():
return int(sys.stdin.readline().rstrip("\r\n"))
def input_multi(x=int):
return map(x, sys.stdin.readline().rstrip("\r\n").split())
def input_list(x=int):
return list(input_multi(x))
def main():
def mod_pow(p, a, e):
base = a
answer = 1
while e:
if e & 1:
answer = (answer * base) % p
base = (base * base) % p
e >>= 1
return answer
n = input_num()
hp = []
pos = [[] for _ in range(300001)]
for i in range(n):
l, r = input_multi()
pos[l].append((i, r + 1))
P = 998244353
two_inv = (P + 1) // 2
loc = [-1] * 300001
for i in range(300001):
for (idx, r) in pos[i]:
# TODO: Your code here
while hp and hp[0][1] <= i:
heapq.heappop(hp)
if hp:
loc[i] = -hp[0][0]
ctr = Counter(loc)
max_loc = max(ctr.keys())
curr = mod_pow(P, 2, n - 1)
answer = (curr * (ctr[0] + ctr[1])) % P
for i in range(2, max_loc + 1):
curr = (curr * two_inv * 3) % P
answer = (answer + curr * ctr[i]) % P
print(answer)
if __name__ == "__main__":
# cases = input_num()
#
# for _ in range(cases):
main()
|
import sys
import heapq
from collections import Counter
# sys.setrecursionlimit(10000)
def input_general():
return sys.stdin.readline().rstrip('\r\n')
def input_num():
return int(sys.stdin.readline().rstrip("\r\n"))
def input_multi(x=int):
return map(x, sys.stdin.readline().rstrip("\r\n").split())
def input_list(x=int):
return list(input_multi(x))
def main():
def mod_pow(p, a, e):
base = a
answer = 1
while e:
if e & 1:
answer = (answer * base) % p
base = (base * base) % p
e >>= 1
return answer
n = input_num()
hp = []
pos = [[] for _ in range(300001)]
for i in range(n):
l, r = input_multi()
pos[l].append((i, r + 1))
P = 998244353
two_inv = (P + 1) // 2
loc = [-1] * 300001
for i in range(300001):
for (idx, r) in pos[i]:
{{completion}}
while hp and hp[0][1] <= i:
heapq.heappop(hp)
if hp:
loc[i] = -hp[0][0]
ctr = Counter(loc)
max_loc = max(ctr.keys())
curr = mod_pow(P, 2, n - 1)
answer = (curr * (ctr[0] + ctr[1])) % P
for i in range(2, max_loc + 1):
curr = (curr * two_inv * 3) % P
answer = (answer + curr * ctr[i]) % P
print(answer)
if __name__ == "__main__":
# cases = input_num()
#
# for _ in range(cases):
main()
|
heapq.heappush(hp, (-idx, r))
|
[{"input": "4\n3 5\n4 8\n2 2\n1 9", "output": ["162"]}, {"input": "4\n1 9\n3 5\n4 8\n2 2", "output": ["102"]}]
|
block_completion_002200
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given $$$n$$$ segments on the coordinate axis. The $$$i$$$-th segment is $$$[l_i, r_i]$$$. Let's denote the set of all integer points belonging to the $$$i$$$-th segment as $$$S_i$$$.Let $$$A \cup B$$$ be the union of two sets $$$A$$$ and $$$B$$$, $$$A \cap B$$$ be the intersection of two sets $$$A$$$ and $$$B$$$, and $$$A \oplus B$$$ be the symmetric difference of $$$A$$$ and $$$B$$$ (a set which contains all elements of $$$A$$$ and all elements of $$$B$$$, except for the ones that belong to both sets).Let $$$[\mathbin{op}_1, \mathbin{op}_2, \dots, \mathbin{op}_{n-1}]$$$ be an array where each element is either $$$\cup$$$, $$$\oplus$$$, or $$$\cap$$$. Over all $$$3^{n-1}$$$ ways to choose this array, calculate the sum of the following values:$$$$$$|(((S_1\ \mathbin{op}_1\ S_2)\ \mathbin{op}_2\ S_3)\ \mathbin{op}_3\ S_4)\ \dots\ \mathbin{op}_{n-1}\ S_n|$$$$$$In this expression, $$$|S|$$$ denotes the size of the set $$$S$$$.
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 3 \cdot 10^5$$$). Then, $$$n$$$ lines follow. The $$$i$$$-th of them contains two integers $$$l_i$$$ and $$$r_i$$$ ($$$0 \le l_i \le r_i \le 3 \cdot 10^5$$$).
Output Specification: Print one integer β the sum of $$$|(((S_1\ \mathbin{op}_1\ S_2)\ \mathbin{op}_2\ S_3)\ \mathbin{op}_3\ S_4)\ \dots\ \mathbin{op}_{n-1}\ S_n|$$$ over all possible ways to choose $$$[\mathbin{op}_1, \mathbin{op}_2, \dots, \mathbin{op}_{n-1}]$$$. Since the answer can be huge, print it modulo $$$998244353$$$.
Code:
import sys
input = sys.stdin.readline
class Heap():
def __init__(self):
self.arr = []
def append(self, x):
self.arr.append(x)
i = len(self.arr)-1
while i > 0 and self.arr[i] < self.arr[(i-1)//2]:
self.arr[i], self.arr[(i-1)//2] = self.arr[(i-1)//2], self.arr[i]
i = (i-1)//2
def pop(self):
self.arr[-1], self.arr[0] = self.arr[0], self.arr[-1]
self.arr.pop(-1)
i = 0
while i*2+1 < len(self.arr):
if i*2+2 < len(self.arr) and self.arr[i*2+2] < self.arr[i*2+1]:
if self.arr[i*2+2] < self.arr[i]:
self.arr[i], self.arr[i*2+2] = self.arr[i*2+2], self.arr[i]
i = i*2+2
else:
break
else:
if self.arr[i*2+1] < self.arr[i]:
self.arr[i], self.arr[i*2+1] = self.arr[i*2+1], self.arr[i]
i = i*2+1
else:
# TODO: Your code here
def top(self):
return self.arr[0]
n = int(input())
difArr = [[] for _ in range(3*10**5+10)]
for i in range(n):
l,r = [int(x) for x in input().split()]
difArr[l].append(n-i)
difArr[r+1].append(n-i)
ans = 0
heap = Heap()
active = set()
for i in range(3*10**5+1):
for x in difArr[i]:
if x in active:
active.remove(x)
while len(heap.arr) > 0 and heap.top() not in active:
heap.pop()
else:
active.add(x)
heap.append(x)
if len(active) > 0:
ans += pow(3, max(0, n-heap.top()-1), 998244353) * pow(2, min(n-1, heap.top()), 998244353)
ans = ans % 998244353
print(ans)
|
import sys
input = sys.stdin.readline
class Heap():
def __init__(self):
self.arr = []
def append(self, x):
self.arr.append(x)
i = len(self.arr)-1
while i > 0 and self.arr[i] < self.arr[(i-1)//2]:
self.arr[i], self.arr[(i-1)//2] = self.arr[(i-1)//2], self.arr[i]
i = (i-1)//2
def pop(self):
self.arr[-1], self.arr[0] = self.arr[0], self.arr[-1]
self.arr.pop(-1)
i = 0
while i*2+1 < len(self.arr):
if i*2+2 < len(self.arr) and self.arr[i*2+2] < self.arr[i*2+1]:
if self.arr[i*2+2] < self.arr[i]:
self.arr[i], self.arr[i*2+2] = self.arr[i*2+2], self.arr[i]
i = i*2+2
else:
break
else:
if self.arr[i*2+1] < self.arr[i]:
self.arr[i], self.arr[i*2+1] = self.arr[i*2+1], self.arr[i]
i = i*2+1
else:
{{completion}}
def top(self):
return self.arr[0]
n = int(input())
difArr = [[] for _ in range(3*10**5+10)]
for i in range(n):
l,r = [int(x) for x in input().split()]
difArr[l].append(n-i)
difArr[r+1].append(n-i)
ans = 0
heap = Heap()
active = set()
for i in range(3*10**5+1):
for x in difArr[i]:
if x in active:
active.remove(x)
while len(heap.arr) > 0 and heap.top() not in active:
heap.pop()
else:
active.add(x)
heap.append(x)
if len(active) > 0:
ans += pow(3, max(0, n-heap.top()-1), 998244353) * pow(2, min(n-1, heap.top()), 998244353)
ans = ans % 998244353
print(ans)
|
break
|
[{"input": "4\n3 5\n4 8\n2 2\n1 9", "output": ["162"]}, {"input": "4\n1 9\n3 5\n4 8\n2 2", "output": ["102"]}]
|
block_completion_002201
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given $$$n$$$ segments on the coordinate axis. The $$$i$$$-th segment is $$$[l_i, r_i]$$$. Let's denote the set of all integer points belonging to the $$$i$$$-th segment as $$$S_i$$$.Let $$$A \cup B$$$ be the union of two sets $$$A$$$ and $$$B$$$, $$$A \cap B$$$ be the intersection of two sets $$$A$$$ and $$$B$$$, and $$$A \oplus B$$$ be the symmetric difference of $$$A$$$ and $$$B$$$ (a set which contains all elements of $$$A$$$ and all elements of $$$B$$$, except for the ones that belong to both sets).Let $$$[\mathbin{op}_1, \mathbin{op}_2, \dots, \mathbin{op}_{n-1}]$$$ be an array where each element is either $$$\cup$$$, $$$\oplus$$$, or $$$\cap$$$. Over all $$$3^{n-1}$$$ ways to choose this array, calculate the sum of the following values:$$$$$$|(((S_1\ \mathbin{op}_1\ S_2)\ \mathbin{op}_2\ S_3)\ \mathbin{op}_3\ S_4)\ \dots\ \mathbin{op}_{n-1}\ S_n|$$$$$$In this expression, $$$|S|$$$ denotes the size of the set $$$S$$$.
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 3 \cdot 10^5$$$). Then, $$$n$$$ lines follow. The $$$i$$$-th of them contains two integers $$$l_i$$$ and $$$r_i$$$ ($$$0 \le l_i \le r_i \le 3 \cdot 10^5$$$).
Output Specification: Print one integer β the sum of $$$|(((S_1\ \mathbin{op}_1\ S_2)\ \mathbin{op}_2\ S_3)\ \mathbin{op}_3\ S_4)\ \dots\ \mathbin{op}_{n-1}\ S_n|$$$ over all possible ways to choose $$$[\mathbin{op}_1, \mathbin{op}_2, \dots, \mathbin{op}_{n-1}]$$$. Since the answer can be huge, print it modulo $$$998244353$$$.
Code:
import sys
input = sys.stdin.readline
class Heap():
def __init__(self):
self.arr = []
def append(self, x):
self.arr.append(x)
i = len(self.arr)-1
while i > 0 and self.arr[i] < self.arr[(i-1)//2]:
self.arr[i], self.arr[(i-1)//2] = self.arr[(i-1)//2], self.arr[i]
i = (i-1)//2
def pop(self):
self.arr[-1], self.arr[0] = self.arr[0], self.arr[-1]
self.arr.pop(-1)
i = 0
while i*2+1 < len(self.arr):
if i*2+2 < len(self.arr) and self.arr[i*2+2] < self.arr[i*2+1]:
if self.arr[i*2+2] < self.arr[i]:
self.arr[i], self.arr[i*2+2] = self.arr[i*2+2], self.arr[i]
i = i*2+2
else:
# TODO: Your code here
else:
if self.arr[i*2+1] < self.arr[i]:
self.arr[i], self.arr[i*2+1] = self.arr[i*2+1], self.arr[i]
i = i*2+1
else:
break
def top(self):
return self.arr[0]
n = int(input())
difArr = [[] for _ in range(3*10**5+10)]
for i in range(n):
l,r = [int(x) for x in input().split()]
difArr[l].append(n-i)
difArr[r+1].append(n-i)
ans = 0
heap = Heap()
active = set()
for i in range(3*10**5+1):
for x in difArr[i]:
if x in active:
active.remove(x)
while len(heap.arr) > 0 and heap.top() not in active:
heap.pop()
else:
active.add(x)
heap.append(x)
if len(active) > 0:
ans += pow(3, max(0, n-heap.top()-1), 998244353) * pow(2, min(n-1, heap.top()), 998244353)
ans = ans % 998244353
print(ans)
|
import sys
input = sys.stdin.readline
class Heap():
def __init__(self):
self.arr = []
def append(self, x):
self.arr.append(x)
i = len(self.arr)-1
while i > 0 and self.arr[i] < self.arr[(i-1)//2]:
self.arr[i], self.arr[(i-1)//2] = self.arr[(i-1)//2], self.arr[i]
i = (i-1)//2
def pop(self):
self.arr[-1], self.arr[0] = self.arr[0], self.arr[-1]
self.arr.pop(-1)
i = 0
while i*2+1 < len(self.arr):
if i*2+2 < len(self.arr) and self.arr[i*2+2] < self.arr[i*2+1]:
if self.arr[i*2+2] < self.arr[i]:
self.arr[i], self.arr[i*2+2] = self.arr[i*2+2], self.arr[i]
i = i*2+2
else:
{{completion}}
else:
if self.arr[i*2+1] < self.arr[i]:
self.arr[i], self.arr[i*2+1] = self.arr[i*2+1], self.arr[i]
i = i*2+1
else:
break
def top(self):
return self.arr[0]
n = int(input())
difArr = [[] for _ in range(3*10**5+10)]
for i in range(n):
l,r = [int(x) for x in input().split()]
difArr[l].append(n-i)
difArr[r+1].append(n-i)
ans = 0
heap = Heap()
active = set()
for i in range(3*10**5+1):
for x in difArr[i]:
if x in active:
active.remove(x)
while len(heap.arr) > 0 and heap.top() not in active:
heap.pop()
else:
active.add(x)
heap.append(x)
if len(active) > 0:
ans += pow(3, max(0, n-heap.top()-1), 998244353) * pow(2, min(n-1, heap.top()), 998244353)
ans = ans % 998244353
print(ans)
|
break
|
[{"input": "4\n3 5\n4 8\n2 2\n1 9", "output": ["162"]}, {"input": "4\n1 9\n3 5\n4 8\n2 2", "output": ["102"]}]
|
block_completion_002202
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given $$$n$$$ segments on the coordinate axis. The $$$i$$$-th segment is $$$[l_i, r_i]$$$. Let's denote the set of all integer points belonging to the $$$i$$$-th segment as $$$S_i$$$.Let $$$A \cup B$$$ be the union of two sets $$$A$$$ and $$$B$$$, $$$A \cap B$$$ be the intersection of two sets $$$A$$$ and $$$B$$$, and $$$A \oplus B$$$ be the symmetric difference of $$$A$$$ and $$$B$$$ (a set which contains all elements of $$$A$$$ and all elements of $$$B$$$, except for the ones that belong to both sets).Let $$$[\mathbin{op}_1, \mathbin{op}_2, \dots, \mathbin{op}_{n-1}]$$$ be an array where each element is either $$$\cup$$$, $$$\oplus$$$, or $$$\cap$$$. Over all $$$3^{n-1}$$$ ways to choose this array, calculate the sum of the following values:$$$$$$|(((S_1\ \mathbin{op}_1\ S_2)\ \mathbin{op}_2\ S_3)\ \mathbin{op}_3\ S_4)\ \dots\ \mathbin{op}_{n-1}\ S_n|$$$$$$In this expression, $$$|S|$$$ denotes the size of the set $$$S$$$.
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 3 \cdot 10^5$$$). Then, $$$n$$$ lines follow. The $$$i$$$-th of them contains two integers $$$l_i$$$ and $$$r_i$$$ ($$$0 \le l_i \le r_i \le 3 \cdot 10^5$$$).
Output Specification: Print one integer β the sum of $$$|(((S_1\ \mathbin{op}_1\ S_2)\ \mathbin{op}_2\ S_3)\ \mathbin{op}_3\ S_4)\ \dots\ \mathbin{op}_{n-1}\ S_n|$$$ over all possible ways to choose $$$[\mathbin{op}_1, \mathbin{op}_2, \dots, \mathbin{op}_{n-1}]$$$. Since the answer can be huge, print it modulo $$$998244353$$$.
Code:
import sys
input=sys.stdin.readline
from collections import defaultdict
from heapq import heappop,heappush
def solve():
N=int(input())
p=998244353
# 2μ 3μ κ±°λμ κ³± μ μ₯
two=[1]
for _ in range(N):
two.append((two[-1]*2)%p)
three=[1]
for _ in range(N):
three.append((three[-1]*3)%p)
# κ° μμλ³λ‘ λ§μ§λ§ μΆν μΈλ±μ€ μ μ₯
def lazy(n,cur,start,end,left,right):
if end<left or right<start:
return
elif left<=start and end<=right:
st[cur]=n
else:
lazy(n,2*cur,start,(start+end)//2,left,right)
lazy(n,2*cur+1,(start+end)//2+1,end,left,right)
def update(cur,start,end):
if start==end:
last[start]=st[cur]
return
if 2*cur<1200000:
if st[2*cur]<st[cur]:
# TODO: Your code here
update(2*cur,start,(start+end)//2)
if 2*cur+1<1200000:
if st[2*cur+1]<st[cur]:
st[2*cur+1]=st[cur]
update(2*cur+1,(start+end)//2+1,end)
st=[0]*1200000
last=[0]*300001
a,b=map(int,input().split())
lazy(1,1,0,300000,a,b)
for n in range(1,N):
a,b=map(int,input().split())
lazy(n,1,0,300000,a,b)
update(1,0,300000)
# lastκ°μ κΈ°μ€μΌλ‘ λ§μ§λ§ μ°μ°
ans=0
A=defaultdict(int)
for l in last:
if l!=0:
A[l]+=1
for l in A:
ans=(ans+A[l]*(three[l-1]*two[N-l]))%p
print(ans)
solve()
|
import sys
input=sys.stdin.readline
from collections import defaultdict
from heapq import heappop,heappush
def solve():
N=int(input())
p=998244353
# 2μ 3μ κ±°λμ κ³± μ μ₯
two=[1]
for _ in range(N):
two.append((two[-1]*2)%p)
three=[1]
for _ in range(N):
three.append((three[-1]*3)%p)
# κ° μμλ³λ‘ λ§μ§λ§ μΆν μΈλ±μ€ μ μ₯
def lazy(n,cur,start,end,left,right):
if end<left or right<start:
return
elif left<=start and end<=right:
st[cur]=n
else:
lazy(n,2*cur,start,(start+end)//2,left,right)
lazy(n,2*cur+1,(start+end)//2+1,end,left,right)
def update(cur,start,end):
if start==end:
last[start]=st[cur]
return
if 2*cur<1200000:
if st[2*cur]<st[cur]:
{{completion}}
update(2*cur,start,(start+end)//2)
if 2*cur+1<1200000:
if st[2*cur+1]<st[cur]:
st[2*cur+1]=st[cur]
update(2*cur+1,(start+end)//2+1,end)
st=[0]*1200000
last=[0]*300001
a,b=map(int,input().split())
lazy(1,1,0,300000,a,b)
for n in range(1,N):
a,b=map(int,input().split())
lazy(n,1,0,300000,a,b)
update(1,0,300000)
# lastκ°μ κΈ°μ€μΌλ‘ λ§μ§λ§ μ°μ°
ans=0
A=defaultdict(int)
for l in last:
if l!=0:
A[l]+=1
for l in A:
ans=(ans+A[l]*(three[l-1]*two[N-l]))%p
print(ans)
solve()
|
st[2*cur]=st[cur]
|
[{"input": "4\n3 5\n4 8\n2 2\n1 9", "output": ["162"]}, {"input": "4\n1 9\n3 5\n4 8\n2 2", "output": ["102"]}]
|
block_completion_002203
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given $$$n$$$ segments on the coordinate axis. The $$$i$$$-th segment is $$$[l_i, r_i]$$$. Let's denote the set of all integer points belonging to the $$$i$$$-th segment as $$$S_i$$$.Let $$$A \cup B$$$ be the union of two sets $$$A$$$ and $$$B$$$, $$$A \cap B$$$ be the intersection of two sets $$$A$$$ and $$$B$$$, and $$$A \oplus B$$$ be the symmetric difference of $$$A$$$ and $$$B$$$ (a set which contains all elements of $$$A$$$ and all elements of $$$B$$$, except for the ones that belong to both sets).Let $$$[\mathbin{op}_1, \mathbin{op}_2, \dots, \mathbin{op}_{n-1}]$$$ be an array where each element is either $$$\cup$$$, $$$\oplus$$$, or $$$\cap$$$. Over all $$$3^{n-1}$$$ ways to choose this array, calculate the sum of the following values:$$$$$$|(((S_1\ \mathbin{op}_1\ S_2)\ \mathbin{op}_2\ S_3)\ \mathbin{op}_3\ S_4)\ \dots\ \mathbin{op}_{n-1}\ S_n|$$$$$$In this expression, $$$|S|$$$ denotes the size of the set $$$S$$$.
Input Specification: The first line contains one integer $$$n$$$ ($$$2 \le n \le 3 \cdot 10^5$$$). Then, $$$n$$$ lines follow. The $$$i$$$-th of them contains two integers $$$l_i$$$ and $$$r_i$$$ ($$$0 \le l_i \le r_i \le 3 \cdot 10^5$$$).
Output Specification: Print one integer β the sum of $$$|(((S_1\ \mathbin{op}_1\ S_2)\ \mathbin{op}_2\ S_3)\ \mathbin{op}_3\ S_4)\ \dots\ \mathbin{op}_{n-1}\ S_n|$$$ over all possible ways to choose $$$[\mathbin{op}_1, \mathbin{op}_2, \dots, \mathbin{op}_{n-1}]$$$. Since the answer can be huge, print it modulo $$$998244353$$$.
Code:
import sys
input=sys.stdin.readline
from collections import defaultdict
from heapq import heappop,heappush
def solve():
N=int(input())
p=998244353
# 2μ 3μ κ±°λμ κ³± μ μ₯
two=[1]
for _ in range(N):
two.append((two[-1]*2)%p)
three=[1]
for _ in range(N):
three.append((three[-1]*3)%p)
# κ° μμλ³λ‘ λ§μ§λ§ μΆν μΈλ±μ€ μ μ₯
def lazy(n,cur,start,end,left,right):
if end<left or right<start:
return
elif left<=start and end<=right:
st[cur]=n
else:
lazy(n,2*cur,start,(start+end)//2,left,right)
lazy(n,2*cur+1,(start+end)//2+1,end,left,right)
def update(cur,start,end):
if start==end:
last[start]=st[cur]
return
if 2*cur<1200000:
if st[2*cur]<st[cur]:
st[2*cur]=st[cur]
update(2*cur,start,(start+end)//2)
if 2*cur+1<1200000:
if st[2*cur+1]<st[cur]:
# TODO: Your code here
update(2*cur+1,(start+end)//2+1,end)
st=[0]*1200000
last=[0]*300001
a,b=map(int,input().split())
lazy(1,1,0,300000,a,b)
for n in range(1,N):
a,b=map(int,input().split())
lazy(n,1,0,300000,a,b)
update(1,0,300000)
# lastκ°μ κΈ°μ€μΌλ‘ λ§μ§λ§ μ°μ°
ans=0
A=defaultdict(int)
for l in last:
if l!=0:
A[l]+=1
for l in A:
ans=(ans+A[l]*(three[l-1]*two[N-l]))%p
print(ans)
solve()
|
import sys
input=sys.stdin.readline
from collections import defaultdict
from heapq import heappop,heappush
def solve():
N=int(input())
p=998244353
# 2μ 3μ κ±°λμ κ³± μ μ₯
two=[1]
for _ in range(N):
two.append((two[-1]*2)%p)
three=[1]
for _ in range(N):
three.append((three[-1]*3)%p)
# κ° μμλ³λ‘ λ§μ§λ§ μΆν μΈλ±μ€ μ μ₯
def lazy(n,cur,start,end,left,right):
if end<left or right<start:
return
elif left<=start and end<=right:
st[cur]=n
else:
lazy(n,2*cur,start,(start+end)//2,left,right)
lazy(n,2*cur+1,(start+end)//2+1,end,left,right)
def update(cur,start,end):
if start==end:
last[start]=st[cur]
return
if 2*cur<1200000:
if st[2*cur]<st[cur]:
st[2*cur]=st[cur]
update(2*cur,start,(start+end)//2)
if 2*cur+1<1200000:
if st[2*cur+1]<st[cur]:
{{completion}}
update(2*cur+1,(start+end)//2+1,end)
st=[0]*1200000
last=[0]*300001
a,b=map(int,input().split())
lazy(1,1,0,300000,a,b)
for n in range(1,N):
a,b=map(int,input().split())
lazy(n,1,0,300000,a,b)
update(1,0,300000)
# lastκ°μ κΈ°μ€μΌλ‘ λ§μ§λ§ μ°μ°
ans=0
A=defaultdict(int)
for l in last:
if l!=0:
A[l]+=1
for l in A:
ans=(ans+A[l]*(three[l-1]*two[N-l]))%p
print(ans)
solve()
|
st[2*cur+1]=st[cur]
|
[{"input": "4\n3 5\n4 8\n2 2\n1 9", "output": ["162"]}, {"input": "4\n1 9\n3 5\n4 8\n2 2", "output": ["102"]}]
|
block_completion_002204
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is an easy version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
from collections import deque;I=input;R=lambda:map(int,I().split())
def f(x,pre):
global flg;dp=[0]*(n+1)
q=deque([(x,pre)]);R=[]
while q:
u,p=q.popleft()
R.append((u))
for v in g[u]:
if v!=p:# TODO: Your code here
for u in R[::-1]:
path=0;dp[u]+=1 if u in s else 0
for v in g[u]:
path+=(1 if dp[v] else 0);dp[u]+=dp[v]
flg=flg and (path<=1 or path==2 and k==dp[u])
return dp[x]
n=int(I());g=[[] for _ in range(n+1)]
for _ in [0]*(n-1):
u,v=R();g[u].append(v);g[v].append(u)
for _ in [0]*int(I()):
k=int(I());flg=1;s=set(R());f(1,0)
print(['NO','YES'][flg])
|
from collections import deque;I=input;R=lambda:map(int,I().split())
def f(x,pre):
global flg;dp=[0]*(n+1)
q=deque([(x,pre)]);R=[]
while q:
u,p=q.popleft()
R.append((u))
for v in g[u]:
if v!=p:{{completion}}
for u in R[::-1]:
path=0;dp[u]+=1 if u in s else 0
for v in g[u]:
path+=(1 if dp[v] else 0);dp[u]+=dp[v]
flg=flg and (path<=1 or path==2 and k==dp[u])
return dp[x]
n=int(I());g=[[] for _ in range(n+1)]
for _ in [0]*(n-1):
u,v=R();g[u].append(v);g[v].append(u)
for _ in [0]*int(I()):
k=int(I());flg=1;s=set(R());f(1,0)
print(['NO','YES'][flg])
|
q.append((v,u))
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002255
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is an easy version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
import math,sys;input=sys.stdin.readline;S=lambda:input().rstrip();I=lambda:int(S());M=lambda:map(int,S().split());L=lambda:list(M());mod1=1000000007;mod2=998244353
from collections import deque
n=I();adj=[[] for i in range(n)]
for i in range(n-1):
p,q=M()
adj[p-1].append(q-1)
adj[q-1].append(p-1)
p=[-1]*n;d=[0]*n
q=deque([0]);v=[0]*n
while q:
r=q.popleft()
v[r]=1
for j in adj[r]:
if v[j]==0:
# TODO: Your code here
q=I()
for i in range(q):
k=I()
a=L();y=a[:]
f=0;z=[]
j=0;m=0;s=set()
for i in a:
if d[i-1]>m:m=d[i-1];j=i-1
while j not in s:
s.add(j);z.append(j);j=p[j]
if j==-1:break
b=[]
for i in a:
if i-1 not in s:b.append(i)
a=b[:]
if len(a)==0:print("YES");continue
j=0;m=0;s1=set();x=0
for i in a:
if d[i-1]>m:m=d[i-1];j=i-1
while j not in s and p[j]!=-1:
s1.add(j);j=p[j]
for t in range(len(z)-1,-1,-1):
if z[t]==j:x=1
if x==1:s1.add(z[t])
for i in y:
if i-1 not in s1:f=1;break
print("NO" if f else "YES")
|
import math,sys;input=sys.stdin.readline;S=lambda:input().rstrip();I=lambda:int(S());M=lambda:map(int,S().split());L=lambda:list(M());mod1=1000000007;mod2=998244353
from collections import deque
n=I();adj=[[] for i in range(n)]
for i in range(n-1):
p,q=M()
adj[p-1].append(q-1)
adj[q-1].append(p-1)
p=[-1]*n;d=[0]*n
q=deque([0]);v=[0]*n
while q:
r=q.popleft()
v[r]=1
for j in adj[r]:
if v[j]==0:
{{completion}}
q=I()
for i in range(q):
k=I()
a=L();y=a[:]
f=0;z=[]
j=0;m=0;s=set()
for i in a:
if d[i-1]>m:m=d[i-1];j=i-1
while j not in s:
s.add(j);z.append(j);j=p[j]
if j==-1:break
b=[]
for i in a:
if i-1 not in s:b.append(i)
a=b[:]
if len(a)==0:print("YES");continue
j=0;m=0;s1=set();x=0
for i in a:
if d[i-1]>m:m=d[i-1];j=i-1
while j not in s and p[j]!=-1:
s1.add(j);j=p[j]
for t in range(len(z)-1,-1,-1):
if z[t]==j:x=1
if x==1:s1.add(z[t])
for i in y:
if i-1 not in s1:f=1;break
print("NO" if f else "YES")
|
q.append(j);d[j]=d[r]+1;p[j]=r
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002256
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is an easy version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
import math,sys;input=sys.stdin.readline;S=lambda:input().rstrip();I=lambda:int(S());M=lambda:map(int,S().split());L=lambda:list(M());mod1=1000000007;mod2=998244353
from collections import deque
n=I();adj=[[] for i in range(n)]
for i in range(n-1):
p,q=M()
adj[p-1].append(q-1)
adj[q-1].append(p-1)
p=[-1]*n;d=[0]*n
q=deque([0]);v=[0]*n
while q:
r=q.popleft()
v[r]=1
for j in adj[r]:
if v[j]==0:
q.append(j);d[j]=d[r]+1;p[j]=r
q=I()
for i in range(q):
k=I()
a=L();y=a[:]
f=0;z=[]
j=0;m=0;s=set()
for i in a:
if d[i-1]>m:# TODO: Your code here
while j not in s:
s.add(j);z.append(j);j=p[j]
if j==-1:break
b=[]
for i in a:
if i-1 not in s:b.append(i)
a=b[:]
if len(a)==0:print("YES");continue
j=0;m=0;s1=set();x=0
for i in a:
if d[i-1]>m:m=d[i-1];j=i-1
while j not in s and p[j]!=-1:
s1.add(j);j=p[j]
for t in range(len(z)-1,-1,-1):
if z[t]==j:x=1
if x==1:s1.add(z[t])
for i in y:
if i-1 not in s1:f=1;break
print("NO" if f else "YES")
|
import math,sys;input=sys.stdin.readline;S=lambda:input().rstrip();I=lambda:int(S());M=lambda:map(int,S().split());L=lambda:list(M());mod1=1000000007;mod2=998244353
from collections import deque
n=I();adj=[[] for i in range(n)]
for i in range(n-1):
p,q=M()
adj[p-1].append(q-1)
adj[q-1].append(p-1)
p=[-1]*n;d=[0]*n
q=deque([0]);v=[0]*n
while q:
r=q.popleft()
v[r]=1
for j in adj[r]:
if v[j]==0:
q.append(j);d[j]=d[r]+1;p[j]=r
q=I()
for i in range(q):
k=I()
a=L();y=a[:]
f=0;z=[]
j=0;m=0;s=set()
for i in a:
if d[i-1]>m:{{completion}}
while j not in s:
s.add(j);z.append(j);j=p[j]
if j==-1:break
b=[]
for i in a:
if i-1 not in s:b.append(i)
a=b[:]
if len(a)==0:print("YES");continue
j=0;m=0;s1=set();x=0
for i in a:
if d[i-1]>m:m=d[i-1];j=i-1
while j not in s and p[j]!=-1:
s1.add(j);j=p[j]
for t in range(len(z)-1,-1,-1):
if z[t]==j:x=1
if x==1:s1.add(z[t])
for i in y:
if i-1 not in s1:f=1;break
print("NO" if f else "YES")
|
m=d[i-1];j=i-1
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002257
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is an easy version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
def solve():
n = int(input())
g = [[] for _ in range(n)]
for _ in range(n-1):
u, v = [int(t) for t in input().split()]
u -= 1
v -= 1
g[u].append(v)
g[v].append(u)
q = int(input())
for _ in range(q):
input()
S = [int(t)-1 for t in input().split()]
in_S = [0] * n
for v in S:
in_S[v] = 1
v = S[0]
w = farthest(g, v, in_S)
y = farthest(g, w, in_S)
P = set(path(g, w, y))
ans = "YES" if P.issuperset(S) else "NO"
print(ans)
def farthest(g, v, in_S):
queue = [v]
depth = [-1] * len(g)
depth[v] = 0
res = (0, v)
for v in queue:
if in_S[v]:
res = max(res, (depth[v], v))
for nei in g[v]:
if depth[nei] == -1:
# TODO: Your code here
return res[1]
def path(g, st, en):
queue = [st]
prev = [-1] * len(g)
prev[st] = st
for v in queue:
for nei in g[v]:
if prev[nei] == -1:
queue.append(nei)
prev[nei] = v
res = [en]
while prev[res[-1]] != res[-1]:
res.append(prev[res[-1]])
return res[::-1]
import sys, os, io
input = lambda: sys.stdin.readline().rstrip('\r\n')
stdout = io.BytesIO()
sys.stdout.write = lambda s: stdout.write(s.encode("ascii"))
solve()
os.write(1, stdout.getvalue())
|
def solve():
n = int(input())
g = [[] for _ in range(n)]
for _ in range(n-1):
u, v = [int(t) for t in input().split()]
u -= 1
v -= 1
g[u].append(v)
g[v].append(u)
q = int(input())
for _ in range(q):
input()
S = [int(t)-1 for t in input().split()]
in_S = [0] * n
for v in S:
in_S[v] = 1
v = S[0]
w = farthest(g, v, in_S)
y = farthest(g, w, in_S)
P = set(path(g, w, y))
ans = "YES" if P.issuperset(S) else "NO"
print(ans)
def farthest(g, v, in_S):
queue = [v]
depth = [-1] * len(g)
depth[v] = 0
res = (0, v)
for v in queue:
if in_S[v]:
res = max(res, (depth[v], v))
for nei in g[v]:
if depth[nei] == -1:
{{completion}}
return res[1]
def path(g, st, en):
queue = [st]
prev = [-1] * len(g)
prev[st] = st
for v in queue:
for nei in g[v]:
if prev[nei] == -1:
queue.append(nei)
prev[nei] = v
res = [en]
while prev[res[-1]] != res[-1]:
res.append(prev[res[-1]])
return res[::-1]
import sys, os, io
input = lambda: sys.stdin.readline().rstrip('\r\n')
stdout = io.BytesIO()
sys.stdout.write = lambda s: stdout.write(s.encode("ascii"))
solve()
os.write(1, stdout.getvalue())
|
queue.append(nei)
depth[nei] = depth[v] + 1
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002258
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is an easy version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
def solve():
n = int(input())
g = [[] for _ in range(n)]
for _ in range(n-1):
u, v = [int(t) for t in input().split()]
u -= 1
v -= 1
g[u].append(v)
g[v].append(u)
q = int(input())
for _ in range(q):
input()
S = [int(t)-1 for t in input().split()]
in_S = [0] * n
for v in S:
in_S[v] = 1
v = S[0]
w = farthest(g, v, in_S)
y = farthest(g, w, in_S)
P = set(path(g, w, y))
ans = "YES" if P.issuperset(S) else "NO"
print(ans)
def farthest(g, v, in_S):
queue = [v]
depth = [-1] * len(g)
depth[v] = 0
res = (0, v)
for v in queue:
if in_S[v]:
res = max(res, (depth[v], v))
for nei in g[v]:
if depth[nei] == -1:
queue.append(nei)
depth[nei] = depth[v] + 1
return res[1]
def path(g, st, en):
queue = [st]
prev = [-1] * len(g)
prev[st] = st
for v in queue:
for nei in g[v]:
if prev[nei] == -1:
# TODO: Your code here
res = [en]
while prev[res[-1]] != res[-1]:
res.append(prev[res[-1]])
return res[::-1]
import sys, os, io
input = lambda: sys.stdin.readline().rstrip('\r\n')
stdout = io.BytesIO()
sys.stdout.write = lambda s: stdout.write(s.encode("ascii"))
solve()
os.write(1, stdout.getvalue())
|
def solve():
n = int(input())
g = [[] for _ in range(n)]
for _ in range(n-1):
u, v = [int(t) for t in input().split()]
u -= 1
v -= 1
g[u].append(v)
g[v].append(u)
q = int(input())
for _ in range(q):
input()
S = [int(t)-1 for t in input().split()]
in_S = [0] * n
for v in S:
in_S[v] = 1
v = S[0]
w = farthest(g, v, in_S)
y = farthest(g, w, in_S)
P = set(path(g, w, y))
ans = "YES" if P.issuperset(S) else "NO"
print(ans)
def farthest(g, v, in_S):
queue = [v]
depth = [-1] * len(g)
depth[v] = 0
res = (0, v)
for v in queue:
if in_S[v]:
res = max(res, (depth[v], v))
for nei in g[v]:
if depth[nei] == -1:
queue.append(nei)
depth[nei] = depth[v] + 1
return res[1]
def path(g, st, en):
queue = [st]
prev = [-1] * len(g)
prev[st] = st
for v in queue:
for nei in g[v]:
if prev[nei] == -1:
{{completion}}
res = [en]
while prev[res[-1]] != res[-1]:
res.append(prev[res[-1]])
return res[::-1]
import sys, os, io
input = lambda: sys.stdin.readline().rstrip('\r\n')
stdout = io.BytesIO()
sys.stdout.write = lambda s: stdout.write(s.encode("ascii"))
solve()
os.write(1, stdout.getvalue())
|
queue.append(nei)
prev[nei] = v
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002259
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is an easy version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
import sys
from array import array
class graph:
def __init__(self, n):
self.n, self.gdict = n, [array('i') for _ in range(n + 1)]
def add_edge(self, node1, node2):
self.gdict[node1].append(node2)
self.gdict[node2].append(node1)
def dfs(self, root):
stk, ret = array('i', [root]), 0
while stk:
node = stk.pop()
for ch in self.gdict[node]:
if not vis[ch]:
vis[ch] = True
while mem[ch] and stk:
# TODO: Your code here
ret |= mem[ch]
stk.append(ch)
return ret
input = lambda: sys.stdin.buffer.readline().decode().strip()
n = int(input())
g = graph(n)
for _ in range(n - 1):
u, v = map(int, input().split())
g.add_edge(u, v)
for i in range(int(input())):
k, a = int(input()), array('i', [int(x) for x in input().split()])
vis = array('b', [False] * (n + 1))
mem = array('b', [0] * (n + 1))
vis[a[0]], paths = 1, 0
for j in a:
mem[j] = 1
for j in g.gdict[a[0]]:
vis[j] = 1
paths += g.dfs(j) | mem[j]
for j in a:
if not vis[j]:
paths = 3
break
print('yes' if paths < 3 else 'no')
|
import sys
from array import array
class graph:
def __init__(self, n):
self.n, self.gdict = n, [array('i') for _ in range(n + 1)]
def add_edge(self, node1, node2):
self.gdict[node1].append(node2)
self.gdict[node2].append(node1)
def dfs(self, root):
stk, ret = array('i', [root]), 0
while stk:
node = stk.pop()
for ch in self.gdict[node]:
if not vis[ch]:
vis[ch] = True
while mem[ch] and stk:
{{completion}}
ret |= mem[ch]
stk.append(ch)
return ret
input = lambda: sys.stdin.buffer.readline().decode().strip()
n = int(input())
g = graph(n)
for _ in range(n - 1):
u, v = map(int, input().split())
g.add_edge(u, v)
for i in range(int(input())):
k, a = int(input()), array('i', [int(x) for x in input().split()])
vis = array('b', [False] * (n + 1))
mem = array('b', [0] * (n + 1))
vis[a[0]], paths = 1, 0
for j in a:
mem[j] = 1
for j in g.gdict[a[0]]:
vis[j] = 1
paths += g.dfs(j) | mem[j]
for j in a:
if not vis[j]:
paths = 3
break
print('yes' if paths < 3 else 'no')
|
vis[stk.pop()] = 0
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002260
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is an easy version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
from collections import deque
import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
n = int(input())
G = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = [int(x) - 1 for x in input().split()]
G[u].append(v)
G[v].append(u)
# build a tree with BFS
par = [-1] * n
depth = [0] * n
q = deque([0])
while q:
u = q.popleft()
for v in G[u]:
if v != par[u]:
# TODO: Your code here
# Path to LCA
def build_path(u, v):
path = []
if depth[u] < depth[v]:
u, v = v, u
while depth[u] > depth[v]:
path.append(u)
u = par[u]
while u != v:
path.append(u)
path.append(v)
u, v = par[u], par[v]
path.append(u)
return path
res = []
q = int(input())
for _ in range(q):
k = int(input())
P = [int(x) - 1 for x in input().split()]
if k == 1:
res.append("YES")
continue
P.sort(key=lambda u: depth[u])
u = P.pop()
v = P.pop()
path = build_path(u, v)
while P and u == path[0] and v == path[-1]:
u = v
v = P.pop()
path = build_path(u, v)
ans = "YES"
for u in P:
if u not in path:
ans = "NO"
break
res.append(ans)
return res
res = solve()
print("\n".join(res))
|
from collections import deque
import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
n = int(input())
G = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = [int(x) - 1 for x in input().split()]
G[u].append(v)
G[v].append(u)
# build a tree with BFS
par = [-1] * n
depth = [0] * n
q = deque([0])
while q:
u = q.popleft()
for v in G[u]:
if v != par[u]:
{{completion}}
# Path to LCA
def build_path(u, v):
path = []
if depth[u] < depth[v]:
u, v = v, u
while depth[u] > depth[v]:
path.append(u)
u = par[u]
while u != v:
path.append(u)
path.append(v)
u, v = par[u], par[v]
path.append(u)
return path
res = []
q = int(input())
for _ in range(q):
k = int(input())
P = [int(x) - 1 for x in input().split()]
if k == 1:
res.append("YES")
continue
P.sort(key=lambda u: depth[u])
u = P.pop()
v = P.pop()
path = build_path(u, v)
while P and u == path[0] and v == path[-1]:
u = v
v = P.pop()
path = build_path(u, v)
ans = "YES"
for u in P:
if u not in path:
ans = "NO"
break
res.append(ans)
return res
res = solve()
print("\n".join(res))
|
par[v] = u
depth[v] = depth[u] + 1
q.append(v)
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002261
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is an easy version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
from collections import deque
import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
n = int(input())
G = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = [int(x) - 1 for x in input().split()]
G[u].append(v)
G[v].append(u)
# build a tree with BFS
par = [-1] * n
depth = [0] * n
q = deque([0])
while q:
u = q.popleft()
for v in G[u]:
if v != par[u]:
par[v] = u
depth[v] = depth[u] + 1
q.append(v)
# Path to LCA
def build_path(u, v):
path = []
if depth[u] < depth[v]:
u, v = v, u
while depth[u] > depth[v]:
path.append(u)
u = par[u]
while u != v:
path.append(u)
path.append(v)
u, v = par[u], par[v]
path.append(u)
return path
res = []
q = int(input())
for _ in range(q):
k = int(input())
P = [int(x) - 1 for x in input().split()]
if k == 1:
res.append("YES")
continue
P.sort(key=lambda u: depth[u])
u = P.pop()
v = P.pop()
path = build_path(u, v)
while P and u == path[0] and v == path[-1]:
u = v
v = P.pop()
path = build_path(u, v)
ans = "YES"
for u in P:
if u not in path:
# TODO: Your code here
res.append(ans)
return res
res = solve()
print("\n".join(res))
|
from collections import deque
import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
n = int(input())
G = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = [int(x) - 1 for x in input().split()]
G[u].append(v)
G[v].append(u)
# build a tree with BFS
par = [-1] * n
depth = [0] * n
q = deque([0])
while q:
u = q.popleft()
for v in G[u]:
if v != par[u]:
par[v] = u
depth[v] = depth[u] + 1
q.append(v)
# Path to LCA
def build_path(u, v):
path = []
if depth[u] < depth[v]:
u, v = v, u
while depth[u] > depth[v]:
path.append(u)
u = par[u]
while u != v:
path.append(u)
path.append(v)
u, v = par[u], par[v]
path.append(u)
return path
res = []
q = int(input())
for _ in range(q):
k = int(input())
P = [int(x) - 1 for x in input().split()]
if k == 1:
res.append("YES")
continue
P.sort(key=lambda u: depth[u])
u = P.pop()
v = P.pop()
path = build_path(u, v)
while P and u == path[0] and v == path[-1]:
u = v
v = P.pop()
path = build_path(u, v)
ans = "YES"
for u in P:
if u not in path:
{{completion}}
res.append(ans)
return res
res = solve()
print("\n".join(res))
|
ans = "NO"
break
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002262
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is a hard version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 10^5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
input = __import__('sys').stdin.readline
mapnode = lambda x: int(x)-1
n = int(input())
adj = [[] for _ in range(n)]
for _ in range(n-1):
u, v = map(mapnode, input().split())
adj[u].append(v)
adj[v].append(u)
# dfs
jump = [[0] * n]
depth = [0] * n
stack = [(0, -1)]
while len(stack) > 0:
u, par = stack.pop()
jump[0][u] = par
for v in adj[u]:
if v != par:
# TODO: Your code here
for _ in range(19):
jump.append([jump[-1][jump[-1][u]] for u in range(n)])
# print('depth', depth)
# print('jump', jump)
def lca(u, v):
if depth[u] < depth[v]:
u, v = v, u
step = depth[u] - depth[v]
for i in range(19):
if (step >> i) & 1 == 1:
u = jump[i][u]
if u == v:
return u
# move up together
for i in range(18, -1, -1):
if jump[i][u] != jump[i][v]:
u, v = jump[i][u], jump[i][v]
return jump[0][u]
# answer queries
for _ in range(int(input())):
nk = int(input())
nodes = list(sorted(map(mapnode, input().split()), key=lambda u: -depth[u]))
mindepth = min(depth[u] for u in nodes)
# check from lowest depth
tocheck = [nodes[i] for i in range(1, nk) if nodes[i] != lca(nodes[0], nodes[i])]
# print(subroot+1, [x+1 for x in tocheck], [x+1 for x in nodes])
ok = len(tocheck) == 0 or all(lca(tocheck[0], u) == u for u in tocheck) and depth[lca(tocheck[0], nodes[0])] <= mindepth
print('YES' if ok else 'NO')
|
input = __import__('sys').stdin.readline
mapnode = lambda x: int(x)-1
n = int(input())
adj = [[] for _ in range(n)]
for _ in range(n-1):
u, v = map(mapnode, input().split())
adj[u].append(v)
adj[v].append(u)
# dfs
jump = [[0] * n]
depth = [0] * n
stack = [(0, -1)]
while len(stack) > 0:
u, par = stack.pop()
jump[0][u] = par
for v in adj[u]:
if v != par:
{{completion}}
for _ in range(19):
jump.append([jump[-1][jump[-1][u]] for u in range(n)])
# print('depth', depth)
# print('jump', jump)
def lca(u, v):
if depth[u] < depth[v]:
u, v = v, u
step = depth[u] - depth[v]
for i in range(19):
if (step >> i) & 1 == 1:
u = jump[i][u]
if u == v:
return u
# move up together
for i in range(18, -1, -1):
if jump[i][u] != jump[i][v]:
u, v = jump[i][u], jump[i][v]
return jump[0][u]
# answer queries
for _ in range(int(input())):
nk = int(input())
nodes = list(sorted(map(mapnode, input().split()), key=lambda u: -depth[u]))
mindepth = min(depth[u] for u in nodes)
# check from lowest depth
tocheck = [nodes[i] for i in range(1, nk) if nodes[i] != lca(nodes[0], nodes[i])]
# print(subroot+1, [x+1 for x in tocheck], [x+1 for x in nodes])
ok = len(tocheck) == 0 or all(lca(tocheck[0], u) == u for u in tocheck) and depth[lca(tocheck[0], nodes[0])] <= mindepth
print('YES' if ok else 'NO')
|
depth[v] = depth[u] + 1
stack.append((v, u))
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002280
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is a hard version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 10^5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
input = __import__('sys').stdin.readline
mapnode = lambda x: int(x)-1
n = int(input())
adj = [[] for _ in range(n)]
for _ in range(n-1):
u, v = map(mapnode, input().split())
adj[u].append(v)
adj[v].append(u)
# dfs
jump = [[0] * n]
depth = [0] * n
stack = [(0, -1)]
while len(stack) > 0:
u, par = stack.pop()
jump[0][u] = par
for v in adj[u]:
if v != par:
depth[v] = depth[u] + 1
stack.append((v, u))
for _ in range(19):
jump.append([jump[-1][jump[-1][u]] for u in range(n)])
# print('depth', depth)
# print('jump', jump)
def lca(u, v):
if depth[u] < depth[v]:
u, v = v, u
step = depth[u] - depth[v]
for i in range(19):
if (step >> i) & 1 == 1:
# TODO: Your code here
if u == v:
return u
# move up together
for i in range(18, -1, -1):
if jump[i][u] != jump[i][v]:
u, v = jump[i][u], jump[i][v]
return jump[0][u]
# answer queries
for _ in range(int(input())):
nk = int(input())
nodes = list(sorted(map(mapnode, input().split()), key=lambda u: -depth[u]))
mindepth = min(depth[u] for u in nodes)
# check from lowest depth
tocheck = [nodes[i] for i in range(1, nk) if nodes[i] != lca(nodes[0], nodes[i])]
# print(subroot+1, [x+1 for x in tocheck], [x+1 for x in nodes])
ok = len(tocheck) == 0 or all(lca(tocheck[0], u) == u for u in tocheck) and depth[lca(tocheck[0], nodes[0])] <= mindepth
print('YES' if ok else 'NO')
|
input = __import__('sys').stdin.readline
mapnode = lambda x: int(x)-1
n = int(input())
adj = [[] for _ in range(n)]
for _ in range(n-1):
u, v = map(mapnode, input().split())
adj[u].append(v)
adj[v].append(u)
# dfs
jump = [[0] * n]
depth = [0] * n
stack = [(0, -1)]
while len(stack) > 0:
u, par = stack.pop()
jump[0][u] = par
for v in adj[u]:
if v != par:
depth[v] = depth[u] + 1
stack.append((v, u))
for _ in range(19):
jump.append([jump[-1][jump[-1][u]] for u in range(n)])
# print('depth', depth)
# print('jump', jump)
def lca(u, v):
if depth[u] < depth[v]:
u, v = v, u
step = depth[u] - depth[v]
for i in range(19):
if (step >> i) & 1 == 1:
{{completion}}
if u == v:
return u
# move up together
for i in range(18, -1, -1):
if jump[i][u] != jump[i][v]:
u, v = jump[i][u], jump[i][v]
return jump[0][u]
# answer queries
for _ in range(int(input())):
nk = int(input())
nodes = list(sorted(map(mapnode, input().split()), key=lambda u: -depth[u]))
mindepth = min(depth[u] for u in nodes)
# check from lowest depth
tocheck = [nodes[i] for i in range(1, nk) if nodes[i] != lca(nodes[0], nodes[i])]
# print(subroot+1, [x+1 for x in tocheck], [x+1 for x in nodes])
ok = len(tocheck) == 0 or all(lca(tocheck[0], u) == u for u in tocheck) and depth[lca(tocheck[0], nodes[0])] <= mindepth
print('YES' if ok else 'NO')
|
u = jump[i][u]
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002281
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is a hard version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 10^5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
from collections import defaultdict, deque, Counter
import sys
from decimal import *
from heapq import heapify, heappop, heappush
import math
import random
import string
from copy import deepcopy
from itertools import combinations, permutations, product
from operator import mul, itemgetter
from functools import reduce, lru_cache
from bisect import bisect_left, bisect_right
def input():
return sys.stdin.readline().rstrip()
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getListGraph():
return list(map(lambda x:int(x) - 1, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
mod = 10 ** 9 + 7
MOD = 998244353
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
inf = float('inf')
eps = 10 ** (-12)
dy = [0, 1, 0, -1]
dx = [1, 0, -1, 0]
#############
# Main Code #
#############
# lca
class Doubling():
def __init__(self, n, edges, root):
self.n = n
self.logn = n.bit_length()
self.doubling = [[-1] * self.n for _ in range(self.logn)]
self.depth = [-1] * N
self.depth[root] = 0
# bfs
par = [-1] * N
pos = deque([root])
while len(pos) > 0:
u = pos.popleft()
for v in edges[u]:
if self.depth[v] == -1:
self.depth[v] = self.depth[u] + 1
par[v] = u
pos.append(v)
# doubling
for i in range(self.n):
self.doubling[0][i] = par[i]
for i in range(1, self.logn):
for j in range(self.n):
if self.doubling[i - 1][j] == -1:
self.doubling[i][j] = -1
else:
# TODO: Your code here
def lca(self, u, v):
if self.depth[v] < self.depth[u]:
u, v = v, u
du = self.depth[u]
dv = self.depth[v]
for i in range(self.logn):
if (dv - du) >> i & 1:
v = self.doubling[i][v]
if u == v: return u
for i in range(self.logn - 1, -1, -1):
pu, pv = self.doubling[i][u], self.doubling[i][v]
if pu != pv:
u, v = pu, pv
return self.doubling[0][u]
def upstream(self, s, t):
if t == 0:
return s
now = s
for k in range(self.logn):
if t & (1 << k):
now = self.doubling[k][now]
return now
N = getN()
E = [[] for i in range(N)]
for _ in range(N - 1):
a, b = getNM()
E[a - 1].append(b - 1)
E[b - 1].append(a - 1)
D = Doubling(N, E, 0)
Q = getN()
for _ in range(Q):
q_n = getN()
V = sorted([[D.depth[p], p] for p in getListGraph()])
p1 = V.pop()[1]
flag = True
while V:
p2 = V.pop()[1]
lca_p = D.lca(p1, p2)
if lca_p != p2:
while V:
opt_p = V.pop()[1]
# print(D.lca(p1, opt_p), (D.lca(p2, opt_p)))
if not (opt_p == lca_p or ((D.lca(p1, opt_p) == opt_p) ^ (D.lca(p2, opt_p) == opt_p))):
flag = False
print("YES" if flag else "NO")
|
from collections import defaultdict, deque, Counter
import sys
from decimal import *
from heapq import heapify, heappop, heappush
import math
import random
import string
from copy import deepcopy
from itertools import combinations, permutations, product
from operator import mul, itemgetter
from functools import reduce, lru_cache
from bisect import bisect_left, bisect_right
def input():
return sys.stdin.readline().rstrip()
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getListGraph():
return list(map(lambda x:int(x) - 1, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
mod = 10 ** 9 + 7
MOD = 998244353
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
inf = float('inf')
eps = 10 ** (-12)
dy = [0, 1, 0, -1]
dx = [1, 0, -1, 0]
#############
# Main Code #
#############
# lca
class Doubling():
def __init__(self, n, edges, root):
self.n = n
self.logn = n.bit_length()
self.doubling = [[-1] * self.n for _ in range(self.logn)]
self.depth = [-1] * N
self.depth[root] = 0
# bfs
par = [-1] * N
pos = deque([root])
while len(pos) > 0:
u = pos.popleft()
for v in edges[u]:
if self.depth[v] == -1:
self.depth[v] = self.depth[u] + 1
par[v] = u
pos.append(v)
# doubling
for i in range(self.n):
self.doubling[0][i] = par[i]
for i in range(1, self.logn):
for j in range(self.n):
if self.doubling[i - 1][j] == -1:
self.doubling[i][j] = -1
else:
{{completion}}
def lca(self, u, v):
if self.depth[v] < self.depth[u]:
u, v = v, u
du = self.depth[u]
dv = self.depth[v]
for i in range(self.logn):
if (dv - du) >> i & 1:
v = self.doubling[i][v]
if u == v: return u
for i in range(self.logn - 1, -1, -1):
pu, pv = self.doubling[i][u], self.doubling[i][v]
if pu != pv:
u, v = pu, pv
return self.doubling[0][u]
def upstream(self, s, t):
if t == 0:
return s
now = s
for k in range(self.logn):
if t & (1 << k):
now = self.doubling[k][now]
return now
N = getN()
E = [[] for i in range(N)]
for _ in range(N - 1):
a, b = getNM()
E[a - 1].append(b - 1)
E[b - 1].append(a - 1)
D = Doubling(N, E, 0)
Q = getN()
for _ in range(Q):
q_n = getN()
V = sorted([[D.depth[p], p] for p in getListGraph()])
p1 = V.pop()[1]
flag = True
while V:
p2 = V.pop()[1]
lca_p = D.lca(p1, p2)
if lca_p != p2:
while V:
opt_p = V.pop()[1]
# print(D.lca(p1, opt_p), (D.lca(p2, opt_p)))
if not (opt_p == lca_p or ((D.lca(p1, opt_p) == opt_p) ^ (D.lca(p2, opt_p) == opt_p))):
flag = False
print("YES" if flag else "NO")
|
self.doubling[i][j] = self.doubling[i - 1][self.doubling[i - 1][j]]
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002282
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is a hard version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 10^5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
from collections import defaultdict, deque, Counter
import sys
from decimal import *
from heapq import heapify, heappop, heappush
import math
import random
import string
from copy import deepcopy
from itertools import combinations, permutations, product
from operator import mul, itemgetter
from functools import reduce, lru_cache
from bisect import bisect_left, bisect_right
def input():
return sys.stdin.readline().rstrip()
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getListGraph():
return list(map(lambda x:int(x) - 1, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
mod = 10 ** 9 + 7
MOD = 998244353
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
inf = float('inf')
eps = 10 ** (-12)
dy = [0, 1, 0, -1]
dx = [1, 0, -1, 0]
#############
# Main Code #
#############
# lca
class Doubling():
def __init__(self, n, edges, root):
self.n = n
self.logn = n.bit_length()
self.doubling = [[-1] * self.n for _ in range(self.logn)]
self.depth = [-1] * N
self.depth[root] = 0
# bfs
par = [-1] * N
pos = deque([root])
while len(pos) > 0:
u = pos.popleft()
for v in edges[u]:
if self.depth[v] == -1:
# TODO: Your code here
# doubling
for i in range(self.n):
self.doubling[0][i] = par[i]
for i in range(1, self.logn):
for j in range(self.n):
if self.doubling[i - 1][j] == -1:
self.doubling[i][j] = -1
else:
self.doubling[i][j] = self.doubling[i - 1][self.doubling[i - 1][j]]
def lca(self, u, v):
if self.depth[v] < self.depth[u]:
u, v = v, u
du = self.depth[u]
dv = self.depth[v]
for i in range(self.logn):
if (dv - du) >> i & 1:
v = self.doubling[i][v]
if u == v: return u
for i in range(self.logn - 1, -1, -1):
pu, pv = self.doubling[i][u], self.doubling[i][v]
if pu != pv:
u, v = pu, pv
return self.doubling[0][u]
def upstream(self, s, t):
if t == 0:
return s
now = s
for k in range(self.logn):
if t & (1 << k):
now = self.doubling[k][now]
return now
N = getN()
E = [[] for i in range(N)]
for _ in range(N - 1):
a, b = getNM()
E[a - 1].append(b - 1)
E[b - 1].append(a - 1)
D = Doubling(N, E, 0)
Q = getN()
for _ in range(Q):
q_n = getN()
V = sorted([[D.depth[p], p] for p in getListGraph()])
p1 = V.pop()[1]
flag = True
while V:
p2 = V.pop()[1]
lca_p = D.lca(p1, p2)
if lca_p != p2:
while V:
opt_p = V.pop()[1]
# print(D.lca(p1, opt_p), (D.lca(p2, opt_p)))
if not (opt_p == lca_p or ((D.lca(p1, opt_p) == opt_p) ^ (D.lca(p2, opt_p) == opt_p))):
flag = False
print("YES" if flag else "NO")
|
from collections import defaultdict, deque, Counter
import sys
from decimal import *
from heapq import heapify, heappop, heappush
import math
import random
import string
from copy import deepcopy
from itertools import combinations, permutations, product
from operator import mul, itemgetter
from functools import reduce, lru_cache
from bisect import bisect_left, bisect_right
def input():
return sys.stdin.readline().rstrip()
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getListGraph():
return list(map(lambda x:int(x) - 1, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
mod = 10 ** 9 + 7
MOD = 998244353
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
inf = float('inf')
eps = 10 ** (-12)
dy = [0, 1, 0, -1]
dx = [1, 0, -1, 0]
#############
# Main Code #
#############
# lca
class Doubling():
def __init__(self, n, edges, root):
self.n = n
self.logn = n.bit_length()
self.doubling = [[-1] * self.n for _ in range(self.logn)]
self.depth = [-1] * N
self.depth[root] = 0
# bfs
par = [-1] * N
pos = deque([root])
while len(pos) > 0:
u = pos.popleft()
for v in edges[u]:
if self.depth[v] == -1:
{{completion}}
# doubling
for i in range(self.n):
self.doubling[0][i] = par[i]
for i in range(1, self.logn):
for j in range(self.n):
if self.doubling[i - 1][j] == -1:
self.doubling[i][j] = -1
else:
self.doubling[i][j] = self.doubling[i - 1][self.doubling[i - 1][j]]
def lca(self, u, v):
if self.depth[v] < self.depth[u]:
u, v = v, u
du = self.depth[u]
dv = self.depth[v]
for i in range(self.logn):
if (dv - du) >> i & 1:
v = self.doubling[i][v]
if u == v: return u
for i in range(self.logn - 1, -1, -1):
pu, pv = self.doubling[i][u], self.doubling[i][v]
if pu != pv:
u, v = pu, pv
return self.doubling[0][u]
def upstream(self, s, t):
if t == 0:
return s
now = s
for k in range(self.logn):
if t & (1 << k):
now = self.doubling[k][now]
return now
N = getN()
E = [[] for i in range(N)]
for _ in range(N - 1):
a, b = getNM()
E[a - 1].append(b - 1)
E[b - 1].append(a - 1)
D = Doubling(N, E, 0)
Q = getN()
for _ in range(Q):
q_n = getN()
V = sorted([[D.depth[p], p] for p in getListGraph()])
p1 = V.pop()[1]
flag = True
while V:
p2 = V.pop()[1]
lca_p = D.lca(p1, p2)
if lca_p != p2:
while V:
opt_p = V.pop()[1]
# print(D.lca(p1, opt_p), (D.lca(p2, opt_p)))
if not (opt_p == lca_p or ((D.lca(p1, opt_p) == opt_p) ^ (D.lca(p2, opt_p) == opt_p))):
flag = False
print("YES" if flag else "NO")
|
self.depth[v] = self.depth[u] + 1
par[v] = u
pos.append(v)
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002283
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is a hard version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 10^5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
from collections import deque;import math
import sys;I=sys.stdin.readline;R=lambda:map(lambda x:int(x)-1,input().split())
n=int(I());g=[[] for _ in range(n)]
for _ in [0]*(n-1):
u,v=R();g[u].append(v);g[v].append(u)
h=math.ceil(math.log2(n))
fa=[[-1]*(h+1) for _ in range(n)];dep=[0]*n
q=deque([0])
while q:
u=q.popleft()
for v in g[u]:
if v!=fa[u][0]:# TODO: Your code here
for i in range(1,h+1):
for u in range(n):
fa[u][i]=fa[fa[u][i-1]][i-1]
def lca(u,v):
if dep[u]<dep[v]:u,v=v,u
for i in range(h,-1,-1):
if dep[v]+(1<<i)<=dep[u]:u=fa[u][i]
if u==v:return u
for i in range(h,-1,-1):
if fa[u][i]!=fa[v][i]:u=fa[u][i];v=fa[v][i]
return fa[u][0]
for _ in [0]*int(I()):
k=int(I());p=[*R()];z='YES'
if k<=2:print(z);continue
p.sort(key=lambda u:dep[u])
u=p.pop();v=p.pop();f=lca(u,v)
while p and f==v:u=v;v=p.pop();f=lca(u,v)
for x in p:
if dep[x]<=dep[f] and x!=f or lca(u,x)!=x and lca(v,x)!=x:
z='NO';break
print(z)
|
from collections import deque;import math
import sys;I=sys.stdin.readline;R=lambda:map(lambda x:int(x)-1,input().split())
n=int(I());g=[[] for _ in range(n)]
for _ in [0]*(n-1):
u,v=R();g[u].append(v);g[v].append(u)
h=math.ceil(math.log2(n))
fa=[[-1]*(h+1) for _ in range(n)];dep=[0]*n
q=deque([0])
while q:
u=q.popleft()
for v in g[u]:
if v!=fa[u][0]:{{completion}}
for i in range(1,h+1):
for u in range(n):
fa[u][i]=fa[fa[u][i-1]][i-1]
def lca(u,v):
if dep[u]<dep[v]:u,v=v,u
for i in range(h,-1,-1):
if dep[v]+(1<<i)<=dep[u]:u=fa[u][i]
if u==v:return u
for i in range(h,-1,-1):
if fa[u][i]!=fa[v][i]:u=fa[u][i];v=fa[v][i]
return fa[u][0]
for _ in [0]*int(I()):
k=int(I());p=[*R()];z='YES'
if k<=2:print(z);continue
p.sort(key=lambda u:dep[u])
u=p.pop();v=p.pop();f=lca(u,v)
while p and f==v:u=v;v=p.pop();f=lca(u,v)
for x in p:
if dep[x]<=dep[f] and x!=f or lca(u,x)!=x and lca(v,x)!=x:
z='NO';break
print(z)
|
fa[v][0]=u;dep[v]=dep[u]+1;q.append(v)
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002284
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is a hard version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 10^5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
from collections import deque;import math
import sys;I=sys.stdin.readline;R=lambda:map(lambda x:int(x)-1,input().split())
n=int(I());g=[[] for _ in range(n)]
for _ in [0]*(n-1):
u,v=R();g[u].append(v);g[v].append(u)
h=math.ceil(math.log2(n))
fa=[[-1]*(h+1) for _ in range(n)];dep=[0]*n
q=deque([0])
while q:
u=q.popleft()
for v in g[u]:
if v!=fa[u][0]:fa[v][0]=u;dep[v]=dep[u]+1;q.append(v)
for i in range(1,h+1):
for u in range(n):
fa[u][i]=fa[fa[u][i-1]][i-1]
def lca(u,v):
if dep[u]<dep[v]:u,v=v,u
for i in range(h,-1,-1):
if dep[v]+(1<<i)<=dep[u]:# TODO: Your code here
if u==v:return u
for i in range(h,-1,-1):
if fa[u][i]!=fa[v][i]:u=fa[u][i];v=fa[v][i]
return fa[u][0]
for _ in [0]*int(I()):
k=int(I());p=[*R()];z='YES'
if k<=2:print(z);continue
p.sort(key=lambda u:dep[u])
u=p.pop();v=p.pop();f=lca(u,v)
while p and f==v:u=v;v=p.pop();f=lca(u,v)
for x in p:
if dep[x]<=dep[f] and x!=f or lca(u,x)!=x and lca(v,x)!=x:
z='NO';break
print(z)
|
from collections import deque;import math
import sys;I=sys.stdin.readline;R=lambda:map(lambda x:int(x)-1,input().split())
n=int(I());g=[[] for _ in range(n)]
for _ in [0]*(n-1):
u,v=R();g[u].append(v);g[v].append(u)
h=math.ceil(math.log2(n))
fa=[[-1]*(h+1) for _ in range(n)];dep=[0]*n
q=deque([0])
while q:
u=q.popleft()
for v in g[u]:
if v!=fa[u][0]:fa[v][0]=u;dep[v]=dep[u]+1;q.append(v)
for i in range(1,h+1):
for u in range(n):
fa[u][i]=fa[fa[u][i-1]][i-1]
def lca(u,v):
if dep[u]<dep[v]:u,v=v,u
for i in range(h,-1,-1):
if dep[v]+(1<<i)<=dep[u]:{{completion}}
if u==v:return u
for i in range(h,-1,-1):
if fa[u][i]!=fa[v][i]:u=fa[u][i];v=fa[v][i]
return fa[u][0]
for _ in [0]*int(I()):
k=int(I());p=[*R()];z='YES'
if k<=2:print(z);continue
p.sort(key=lambda u:dep[u])
u=p.pop();v=p.pop();f=lca(u,v)
while p and f==v:u=v;v=p.pop();f=lca(u,v)
for x in p:
if dep[x]<=dep[f] and x!=f or lca(u,x)!=x and lca(v,x)!=x:
z='NO';break
print(z)
|
u=fa[u][i]
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002285
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is a hard version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 10^5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
from sys import stdin
input = stdin.readline
inp = lambda : list(map(int,input().split()))
def dfs(p , prev , lvl):
s = [[p , prev , lvl]]
while(len(s)):
p , prev , lvl = s.pop()
level[p] = lvl
parent[p][0] = prev
for i in child[p]:
if(i == prev):continue
s.append([i , p , lvl + 1])
def lca(u,v):
if(level[u] > level[v]):u,v=v,u
dist=level[v] - level[u]
for i in range(20,-1,-1):
if(dist >> i & 1):
v=parent[v][i]
if(u==v):return u
for i in range(20,-1,-1):
if(parent[u][i] != parent[v][i]):
u=parent[u][i]
v=parent[v][i]
return parent[u][0]
for T in range(1):
n = int(input())
child = [[] for i in range(n + 1)]
for i in range(n - 1):
u , v = inp()
child[u].append(v)
child[v].append(u)
level = [0 for i in range(n + 1)]
parent=[[-1 for i in range(21)] for j in range(n + 1)]
dfs(1 , -1 , 1)
for j in range(1 , 21):
for i in range(1 , n + 1):
if(parent[i][j - 1] == -1):continue
parent[i][j] = parent[parent[i][j - 1]][j - 1]
for q in range(int(input())):
x = int(input())
a = inp()
maxval = 0
for i in range(x):
if(maxval < level[a[i]]):
maxval = level[a[i]]
left = a[i]
maxval = 0
for i in range(x):
if(lca(a[i] , left) != a[i]):
if(maxval < level[a[i]]):
# TODO: Your code here
if(maxval == 0):
print('YES')
continue
ok = True
Lca = lca(left , right)
for i in range(x):
if(a[i] == Lca):continue
if(lca(Lca , a[i]) == a[i]):
ok = False
break
if(lca(a[i] , left) != a[i] and lca(a[i] , right) != a[i]):
ok = False
break
if(ok):print('YES')
else:print('NO')
|
from sys import stdin
input = stdin.readline
inp = lambda : list(map(int,input().split()))
def dfs(p , prev , lvl):
s = [[p , prev , lvl]]
while(len(s)):
p , prev , lvl = s.pop()
level[p] = lvl
parent[p][0] = prev
for i in child[p]:
if(i == prev):continue
s.append([i , p , lvl + 1])
def lca(u,v):
if(level[u] > level[v]):u,v=v,u
dist=level[v] - level[u]
for i in range(20,-1,-1):
if(dist >> i & 1):
v=parent[v][i]
if(u==v):return u
for i in range(20,-1,-1):
if(parent[u][i] != parent[v][i]):
u=parent[u][i]
v=parent[v][i]
return parent[u][0]
for T in range(1):
n = int(input())
child = [[] for i in range(n + 1)]
for i in range(n - 1):
u , v = inp()
child[u].append(v)
child[v].append(u)
level = [0 for i in range(n + 1)]
parent=[[-1 for i in range(21)] for j in range(n + 1)]
dfs(1 , -1 , 1)
for j in range(1 , 21):
for i in range(1 , n + 1):
if(parent[i][j - 1] == -1):continue
parent[i][j] = parent[parent[i][j - 1]][j - 1]
for q in range(int(input())):
x = int(input())
a = inp()
maxval = 0
for i in range(x):
if(maxval < level[a[i]]):
maxval = level[a[i]]
left = a[i]
maxval = 0
for i in range(x):
if(lca(a[i] , left) != a[i]):
if(maxval < level[a[i]]):
{{completion}}
if(maxval == 0):
print('YES')
continue
ok = True
Lca = lca(left , right)
for i in range(x):
if(a[i] == Lca):continue
if(lca(Lca , a[i]) == a[i]):
ok = False
break
if(lca(a[i] , left) != a[i] and lca(a[i] , right) != a[i]):
ok = False
break
if(ok):print('YES')
else:print('NO')
|
maxval = level[a[i]]
right = a[i]
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002286
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is a hard version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 10^5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
from sys import stdin
input = stdin.readline
inp = lambda : list(map(int,input().split()))
def dfs(p , prev , lvl):
s = [[p , prev , lvl]]
while(len(s)):
p , prev , lvl = s.pop()
level[p] = lvl
parent[p][0] = prev
for i in child[p]:
if(i == prev):# TODO: Your code here
s.append([i , p , lvl + 1])
def lca(u,v):
if(level[u] > level[v]):u,v=v,u
dist=level[v] - level[u]
for i in range(20,-1,-1):
if(dist >> i & 1):
v=parent[v][i]
if(u==v):return u
for i in range(20,-1,-1):
if(parent[u][i] != parent[v][i]):
u=parent[u][i]
v=parent[v][i]
return parent[u][0]
for T in range(1):
n = int(input())
child = [[] for i in range(n + 1)]
for i in range(n - 1):
u , v = inp()
child[u].append(v)
child[v].append(u)
level = [0 for i in range(n + 1)]
parent=[[-1 for i in range(21)] for j in range(n + 1)]
dfs(1 , -1 , 1)
for j in range(1 , 21):
for i in range(1 , n + 1):
if(parent[i][j - 1] == -1):continue
parent[i][j] = parent[parent[i][j - 1]][j - 1]
for q in range(int(input())):
x = int(input())
a = inp()
maxval = 0
for i in range(x):
if(maxval < level[a[i]]):
maxval = level[a[i]]
left = a[i]
maxval = 0
for i in range(x):
if(lca(a[i] , left) != a[i]):
if(maxval < level[a[i]]):
maxval = level[a[i]]
right = a[i]
if(maxval == 0):
print('YES')
continue
ok = True
Lca = lca(left , right)
for i in range(x):
if(a[i] == Lca):continue
if(lca(Lca , a[i]) == a[i]):
ok = False
break
if(lca(a[i] , left) != a[i] and lca(a[i] , right) != a[i]):
ok = False
break
if(ok):print('YES')
else:print('NO')
|
from sys import stdin
input = stdin.readline
inp = lambda : list(map(int,input().split()))
def dfs(p , prev , lvl):
s = [[p , prev , lvl]]
while(len(s)):
p , prev , lvl = s.pop()
level[p] = lvl
parent[p][0] = prev
for i in child[p]:
if(i == prev):{{completion}}
s.append([i , p , lvl + 1])
def lca(u,v):
if(level[u] > level[v]):u,v=v,u
dist=level[v] - level[u]
for i in range(20,-1,-1):
if(dist >> i & 1):
v=parent[v][i]
if(u==v):return u
for i in range(20,-1,-1):
if(parent[u][i] != parent[v][i]):
u=parent[u][i]
v=parent[v][i]
return parent[u][0]
for T in range(1):
n = int(input())
child = [[] for i in range(n + 1)]
for i in range(n - 1):
u , v = inp()
child[u].append(v)
child[v].append(u)
level = [0 for i in range(n + 1)]
parent=[[-1 for i in range(21)] for j in range(n + 1)]
dfs(1 , -1 , 1)
for j in range(1 , 21):
for i in range(1 , n + 1):
if(parent[i][j - 1] == -1):continue
parent[i][j] = parent[parent[i][j - 1]][j - 1]
for q in range(int(input())):
x = int(input())
a = inp()
maxval = 0
for i in range(x):
if(maxval < level[a[i]]):
maxval = level[a[i]]
left = a[i]
maxval = 0
for i in range(x):
if(lca(a[i] , left) != a[i]):
if(maxval < level[a[i]]):
maxval = level[a[i]]
right = a[i]
if(maxval == 0):
print('YES')
continue
ok = True
Lca = lca(left , right)
for i in range(x):
if(a[i] == Lca):continue
if(lca(Lca , a[i]) == a[i]):
ok = False
break
if(lca(a[i] , left) != a[i] and lca(a[i] , right) != a[i]):
ok = False
break
if(ok):print('YES')
else:print('NO')
|
continue
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002287
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is a hard version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 10^5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
import sys
class LCA:
def __init__(self, g, root=0):
self.g = g
self.root = root
n = len(g)
self.logn = (n - 1).bit_length()
self.depth = [None] * n
self.parent = [[None] * self.logn for _ in range(n)]
self._dfs()
self._doubling()
def _dfs(self):
self.depth[self.root] = 0
stack = [self.root]
while stack:
u = stack.pop()
for v in self.g[u]:
if self.depth[v] is None:
# TODO: Your code here
def _doubling(self):
for i in range(self.logn - 1):
for p in self.parent:
if p[i] is not None:
p[i + 1] = self.parent[p[i]][i]
def lca(self, u, v):
if self.depth[v] < self.depth[u]:
u, v = v, u
d = self.depth[v] - self.depth[u]
for i in range(d.bit_length()):
if d >> i & 1:
v = self.parent[v][i]
if u == v:
return u
for i in reversed(range(self.logn)):
if (pu := self.parent[u][i]) != (pv := self.parent[v][i]):
u, v = pu, pv
return self.parent[u][i]
def query(lca):
k = int(sys.stdin.readline())
p = sorted(
(int(x) - 1 for x in sys.stdin.readline().split()),
key=lca.depth.__getitem__,
reverse=True,
)
branch = []
top = p[0]
for x in p[1:]:
if lca.lca(top, x) == x:
top = x
else:
branch.append(x)
if not branch:
return True
if lca.lca(branch[0], p[0]) != lca.lca(branch[0], top):
return False
for i in range(1, len(branch)):
if lca.lca(branch[i - 1], branch[i]) != branch[i]:
return False
return True
n = int(input())
g = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = (int(x) - 1 for x in sys.stdin.readline().split())
g[u].append(v)
g[v].append(u)
lca = LCA(g)
for _ in range(int(input())):
print("YES" if query(lca) else "NO")
|
import sys
class LCA:
def __init__(self, g, root=0):
self.g = g
self.root = root
n = len(g)
self.logn = (n - 1).bit_length()
self.depth = [None] * n
self.parent = [[None] * self.logn for _ in range(n)]
self._dfs()
self._doubling()
def _dfs(self):
self.depth[self.root] = 0
stack = [self.root]
while stack:
u = stack.pop()
for v in self.g[u]:
if self.depth[v] is None:
{{completion}}
def _doubling(self):
for i in range(self.logn - 1):
for p in self.parent:
if p[i] is not None:
p[i + 1] = self.parent[p[i]][i]
def lca(self, u, v):
if self.depth[v] < self.depth[u]:
u, v = v, u
d = self.depth[v] - self.depth[u]
for i in range(d.bit_length()):
if d >> i & 1:
v = self.parent[v][i]
if u == v:
return u
for i in reversed(range(self.logn)):
if (pu := self.parent[u][i]) != (pv := self.parent[v][i]):
u, v = pu, pv
return self.parent[u][i]
def query(lca):
k = int(sys.stdin.readline())
p = sorted(
(int(x) - 1 for x in sys.stdin.readline().split()),
key=lca.depth.__getitem__,
reverse=True,
)
branch = []
top = p[0]
for x in p[1:]:
if lca.lca(top, x) == x:
top = x
else:
branch.append(x)
if not branch:
return True
if lca.lca(branch[0], p[0]) != lca.lca(branch[0], top):
return False
for i in range(1, len(branch)):
if lca.lca(branch[i - 1], branch[i]) != branch[i]:
return False
return True
n = int(input())
g = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = (int(x) - 1 for x in sys.stdin.readline().split())
g[u].append(v)
g[v].append(u)
lca = LCA(g)
for _ in range(int(input())):
print("YES" if query(lca) else "NO")
|
self.depth[v] = self.depth[u] + 1
self.parent[v][0] = u
stack.append(v)
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002288
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: This is a hard version of the problem. The only difference between an easy and a hard version is in the number of queries.Polycarp grew a tree from $$$n$$$ vertices. We remind you that a tree of $$$n$$$ vertices is an undirected connected graph of $$$n$$$ vertices and $$$n-1$$$ edges that does not contain cycles.He calls a set of vertices passable if there is such a path in the tree that passes through each vertex of this set without passing through any edge twice. The path can visit other vertices (not from this set).In other words, a set of vertices is called passable if there is a simple path that passes through all the vertices of this set (and possibly some other).For example, for a tree below sets $$$\{3, 2, 5\}$$$, $$$\{1, 5, 4\}$$$, $$$\{1, 4\}$$$ are passable, and $$$\{1, 3, 5\}$$$, $$$\{1, 2, 3, 4, 5\}$$$ are not. Polycarp asks you to answer $$$q$$$ queries. Each query is a set of vertices. For each query, you need to determine whether the corresponding set of vertices is passable.
Input Specification: The first line of input contains a single integer $$$n$$$ ($$$1 \le n \le 2 \cdot 10^5$$$) β number of vertices. Following $$$n - 1$$$ lines a description of the tree.. Each line contains two integers $$$u$$$ and $$$v$$$ ($$$1 \le u, v \le n$$$, $$$u \ne v$$$) β indices of vertices connected by an edge. Following line contains single integer $$$q$$$ ($$$1 \le q \le 10^5$$$)Β β number of queries. The following $$$2 \cdot q$$$ lines contain descriptions of sets. The first line of the description contains an integer $$$k$$$ ($$$1 \le k \le n$$$) β the size of the set. The second line of the description contains $$$k$$$ of distinct integers $$$p_1, p_2, \dots, p_k$$$ ($$$1 \le p_i \le n$$$) β indices of the vertices of the set. It is guaranteed that the sum of $$$k$$$ values for all queries does not exceed $$$2 \cdot 10^5$$$.
Output Specification: Output $$$q$$$ lines, each of which contains the answer to the corresponding query. As an answer, output "YES" if the set is passable, and "NO" otherwise. You can output the answer in any case (for example, the strings "yEs", "yes", "Yes" and "YES" will be recognized as a positive answer).
Code:
import sys
class LCA:
def __init__(self, g, root=0):
self.g = g
self.root = root
n = len(g)
self.logn = (n - 1).bit_length()
self.depth = [None] * n
self.parent = [[None] * self.logn for _ in range(n)]
self._dfs()
self._doubling()
def _dfs(self):
self.depth[self.root] = 0
stack = [self.root]
while stack:
u = stack.pop()
for v in self.g[u]:
if self.depth[v] is None:
self.depth[v] = self.depth[u] + 1
self.parent[v][0] = u
stack.append(v)
def _doubling(self):
for i in range(self.logn - 1):
for p in self.parent:
if p[i] is not None:
# TODO: Your code here
def lca(self, u, v):
if self.depth[v] < self.depth[u]:
u, v = v, u
d = self.depth[v] - self.depth[u]
for i in range(d.bit_length()):
if d >> i & 1:
v = self.parent[v][i]
if u == v:
return u
for i in reversed(range(self.logn)):
if (pu := self.parent[u][i]) != (pv := self.parent[v][i]):
u, v = pu, pv
return self.parent[u][i]
def query(lca):
k = int(sys.stdin.readline())
p = sorted(
(int(x) - 1 for x in sys.stdin.readline().split()),
key=lca.depth.__getitem__,
reverse=True,
)
branch = []
top = p[0]
for x in p[1:]:
if lca.lca(top, x) == x:
top = x
else:
branch.append(x)
if not branch:
return True
if lca.lca(branch[0], p[0]) != lca.lca(branch[0], top):
return False
for i in range(1, len(branch)):
if lca.lca(branch[i - 1], branch[i]) != branch[i]:
return False
return True
n = int(input())
g = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = (int(x) - 1 for x in sys.stdin.readline().split())
g[u].append(v)
g[v].append(u)
lca = LCA(g)
for _ in range(int(input())):
print("YES" if query(lca) else "NO")
|
import sys
class LCA:
def __init__(self, g, root=0):
self.g = g
self.root = root
n = len(g)
self.logn = (n - 1).bit_length()
self.depth = [None] * n
self.parent = [[None] * self.logn for _ in range(n)]
self._dfs()
self._doubling()
def _dfs(self):
self.depth[self.root] = 0
stack = [self.root]
while stack:
u = stack.pop()
for v in self.g[u]:
if self.depth[v] is None:
self.depth[v] = self.depth[u] + 1
self.parent[v][0] = u
stack.append(v)
def _doubling(self):
for i in range(self.logn - 1):
for p in self.parent:
if p[i] is not None:
{{completion}}
def lca(self, u, v):
if self.depth[v] < self.depth[u]:
u, v = v, u
d = self.depth[v] - self.depth[u]
for i in range(d.bit_length()):
if d >> i & 1:
v = self.parent[v][i]
if u == v:
return u
for i in reversed(range(self.logn)):
if (pu := self.parent[u][i]) != (pv := self.parent[v][i]):
u, v = pu, pv
return self.parent[u][i]
def query(lca):
k = int(sys.stdin.readline())
p = sorted(
(int(x) - 1 for x in sys.stdin.readline().split()),
key=lca.depth.__getitem__,
reverse=True,
)
branch = []
top = p[0]
for x in p[1:]:
if lca.lca(top, x) == x:
top = x
else:
branch.append(x)
if not branch:
return True
if lca.lca(branch[0], p[0]) != lca.lca(branch[0], top):
return False
for i in range(1, len(branch)):
if lca.lca(branch[i - 1], branch[i]) != branch[i]:
return False
return True
n = int(input())
g = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = (int(x) - 1 for x in sys.stdin.readline().split())
g[u].append(v)
g[v].append(u)
lca = LCA(g)
for _ in range(int(input())):
print("YES" if query(lca) else "NO")
|
p[i + 1] = self.parent[p[i]][i]
|
[{"input": "5\n1 2\n2 3\n2 4\n4 5\n5\n3\n3 2 5\n5\n1 2 3 4 5\n2\n1 4\n3\n1 3 5\n3\n1 5 4", "output": ["YES\nNO\nYES\nNO\nYES"]}, {"input": "5\n1 2\n3 2\n2 4\n5 2\n4\n2\n3 1\n3\n3 4 5\n3\n2 3 5\n1\n1", "output": ["YES\nNO\nYES\nYES"]}]
|
block_completion_002289
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A class of students got bored wearing the same pair of shoes every day, so they decided to shuffle their shoes among themselves. In this problem, a pair of shoes is inseparable and is considered as a single object.There are $$$n$$$ students in the class, and you are given an array $$$s$$$ in non-decreasing order, where $$$s_i$$$ is the shoe size of the $$$i$$$-th student. A shuffling of shoes is valid only if no student gets their own shoes and if every student gets shoes of size greater than or equal to their size. You have to output a permutation $$$p$$$ of $$$\{1,2,\ldots,n\}$$$ denoting a valid shuffling of shoes, where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student ($$$p_i \ne i$$$). And output $$$-1$$$ if a valid shuffling does not exist.A permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).
Input Specification: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) β the number of test cases. Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1\leq n\leq10^5$$$)Β β the number of students. The second line of each test case contains $$$n$$$ integers $$$s_1, s_2,\ldots,s_n$$$ ($$$1\leq s_i\leq10^9$$$, and for all $$$1\le i<n$$$, $$$s_i\le s_{i+1}$$$) β the shoe sizes of the students. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print the answer in a single line using the following format. If a valid shuffling does not exist, print the number $$$-1$$$ as the answer. If a valid shuffling exists, print $$$n$$$ space-separated integers β a permutation $$$p$$$ of $$$1,2,\ldots,n$$$ denoting a valid shuffling of shoes where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student. If there are multiple answers, then print any of them.
Notes: NoteIn the first test case, any permutation $$$p$$$ of $$$1,\ldots,n$$$ where $$$p_i\ne i$$$ would represent a valid shuffling since all students have equal shoe sizes, and thus anyone can wear anyone's shoes.In the second test case, it can be shown that no valid shuffling is possible.
Code:
from collections import Counter
for _ in range(int(input())):
n=int(input());
l=list(map(int, input().split()));c = Counter(l);
if any(x == 1 for x in c.values()):
# TODO: Your code here
print(*[i if i!=0 and l[i]==l[i-1] else i+c[l[i]] for i in range(n)])
|
from collections import Counter
for _ in range(int(input())):
n=int(input());
l=list(map(int, input().split()));c = Counter(l);
if any(x == 1 for x in c.values()):
{{completion}}
print(*[i if i!=0 and l[i]==l[i-1] else i+c[l[i]] for i in range(n)])
|
print(-1); continue
|
[{"input": "2\n5\n1 1 1 1 1\n6\n3 6 8 13 15 21", "output": ["5 1 2 3 4 \n-1"]}]
|
block_completion_002395
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A class of students got bored wearing the same pair of shoes every day, so they decided to shuffle their shoes among themselves. In this problem, a pair of shoes is inseparable and is considered as a single object.There are $$$n$$$ students in the class, and you are given an array $$$s$$$ in non-decreasing order, where $$$s_i$$$ is the shoe size of the $$$i$$$-th student. A shuffling of shoes is valid only if no student gets their own shoes and if every student gets shoes of size greater than or equal to their size. You have to output a permutation $$$p$$$ of $$$\{1,2,\ldots,n\}$$$ denoting a valid shuffling of shoes, where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student ($$$p_i \ne i$$$). And output $$$-1$$$ if a valid shuffling does not exist.A permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).
Input Specification: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) β the number of test cases. Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1\leq n\leq10^5$$$)Β β the number of students. The second line of each test case contains $$$n$$$ integers $$$s_1, s_2,\ldots,s_n$$$ ($$$1\leq s_i\leq10^9$$$, and for all $$$1\le i<n$$$, $$$s_i\le s_{i+1}$$$) β the shoe sizes of the students. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print the answer in a single line using the following format. If a valid shuffling does not exist, print the number $$$-1$$$ as the answer. If a valid shuffling exists, print $$$n$$$ space-separated integers β a permutation $$$p$$$ of $$$1,2,\ldots,n$$$ denoting a valid shuffling of shoes where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student. If there are multiple answers, then print any of them.
Notes: NoteIn the first test case, any permutation $$$p$$$ of $$$1,\ldots,n$$$ where $$$p_i\ne i$$$ would represent a valid shuffling since all students have equal shoe sizes, and thus anyone can wear anyone's shoes.In the second test case, it can be shown that no valid shuffling is possible.
Code:
# Codeforce 795 Div 2
import sys
input = sys.stdin.readline
flush = sys.stdout.flush
iil = lambda: [int(x) for x in input().split()]
tests, = iil()
for _ in range(tests):
n, = iil()
a = iil()
last_c = a[0]
count = 1
ans = []
for i, c in enumerate(a[1:]):
if c == last_c:
count += 1
else:
if count == 1:
print(-1)
break
else:
# TODO: Your code here
else:
if count <= 1:
print(-1)
continue
ans.extend([i+2] + list(range(i-count + 3, i+2)))
print(" ".join(str(x) for x in ans))
|
# Codeforce 795 Div 2
import sys
input = sys.stdin.readline
flush = sys.stdout.flush
iil = lambda: [int(x) for x in input().split()]
tests, = iil()
for _ in range(tests):
n, = iil()
a = iil()
last_c = a[0]
count = 1
ans = []
for i, c in enumerate(a[1:]):
if c == last_c:
count += 1
else:
if count == 1:
print(-1)
break
else:
{{completion}}
else:
if count <= 1:
print(-1)
continue
ans.extend([i+2] + list(range(i-count + 3, i+2)))
print(" ".join(str(x) for x in ans))
|
ans.extend([i+1] + list(range(i-count + 2, i+1)))
last_c = c
count = 1
|
[{"input": "2\n5\n1 1 1 1 1\n6\n3 6 8 13 15 21", "output": ["5 1 2 3 4 \n-1"]}]
|
block_completion_002396
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A class of students got bored wearing the same pair of shoes every day, so they decided to shuffle their shoes among themselves. In this problem, a pair of shoes is inseparable and is considered as a single object.There are $$$n$$$ students in the class, and you are given an array $$$s$$$ in non-decreasing order, where $$$s_i$$$ is the shoe size of the $$$i$$$-th student. A shuffling of shoes is valid only if no student gets their own shoes and if every student gets shoes of size greater than or equal to their size. You have to output a permutation $$$p$$$ of $$$\{1,2,\ldots,n\}$$$ denoting a valid shuffling of shoes, where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student ($$$p_i \ne i$$$). And output $$$-1$$$ if a valid shuffling does not exist.A permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).
Input Specification: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) β the number of test cases. Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1\leq n\leq10^5$$$)Β β the number of students. The second line of each test case contains $$$n$$$ integers $$$s_1, s_2,\ldots,s_n$$$ ($$$1\leq s_i\leq10^9$$$, and for all $$$1\le i<n$$$, $$$s_i\le s_{i+1}$$$) β the shoe sizes of the students. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print the answer in a single line using the following format. If a valid shuffling does not exist, print the number $$$-1$$$ as the answer. If a valid shuffling exists, print $$$n$$$ space-separated integers β a permutation $$$p$$$ of $$$1,2,\ldots,n$$$ denoting a valid shuffling of shoes where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student. If there are multiple answers, then print any of them.
Notes: NoteIn the first test case, any permutation $$$p$$$ of $$$1,\ldots,n$$$ where $$$p_i\ne i$$$ would represent a valid shuffling since all students have equal shoe sizes, and thus anyone can wear anyone's shoes.In the second test case, it can be shown that no valid shuffling is possible.
Code:
for _ in range(int(input())):
n = int(input())
ans =[]
arr = [int(c) for c in input().split()]
j = 0
for i in range(n):
if i == j:continue
if arr[i] == arr[j]:
continue
else:
if i == j+1:
print(-1)
break
else:
# print(list(range(j,i)))
# TODO: Your code here
else:
if n==j+1:
print(-1)
else:
ls = list(range(j+1,n+1))
newls = [ls[-1]]+ls[0:-1]
ans.extend(newls)
print(*ans)
|
for _ in range(int(input())):
n = int(input())
ans =[]
arr = [int(c) for c in input().split()]
j = 0
for i in range(n):
if i == j:continue
if arr[i] == arr[j]:
continue
else:
if i == j+1:
print(-1)
break
else:
# print(list(range(j,i)))
{{completion}}
else:
if n==j+1:
print(-1)
else:
ls = list(range(j+1,n+1))
newls = [ls[-1]]+ls[0:-1]
ans.extend(newls)
print(*ans)
|
ls = list(range(j+1,i+1))
newls = [ls[-1]]+ls[0:-1]
ans.extend(newls)
j=i
|
[{"input": "2\n5\n1 1 1 1 1\n6\n3 6 8 13 15 21", "output": ["5 1 2 3 4 \n-1"]}]
|
block_completion_002397
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A class of students got bored wearing the same pair of shoes every day, so they decided to shuffle their shoes among themselves. In this problem, a pair of shoes is inseparable and is considered as a single object.There are $$$n$$$ students in the class, and you are given an array $$$s$$$ in non-decreasing order, where $$$s_i$$$ is the shoe size of the $$$i$$$-th student. A shuffling of shoes is valid only if no student gets their own shoes and if every student gets shoes of size greater than or equal to their size. You have to output a permutation $$$p$$$ of $$$\{1,2,\ldots,n\}$$$ denoting a valid shuffling of shoes, where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student ($$$p_i \ne i$$$). And output $$$-1$$$ if a valid shuffling does not exist.A permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).
Input Specification: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) β the number of test cases. Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1\leq n\leq10^5$$$)Β β the number of students. The second line of each test case contains $$$n$$$ integers $$$s_1, s_2,\ldots,s_n$$$ ($$$1\leq s_i\leq10^9$$$, and for all $$$1\le i<n$$$, $$$s_i\le s_{i+1}$$$) β the shoe sizes of the students. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print the answer in a single line using the following format. If a valid shuffling does not exist, print the number $$$-1$$$ as the answer. If a valid shuffling exists, print $$$n$$$ space-separated integers β a permutation $$$p$$$ of $$$1,2,\ldots,n$$$ denoting a valid shuffling of shoes where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student. If there are multiple answers, then print any of them.
Notes: NoteIn the first test case, any permutation $$$p$$$ of $$$1,\ldots,n$$$ where $$$p_i\ne i$$$ would represent a valid shuffling since all students have equal shoe sizes, and thus anyone can wear anyone's shoes.In the second test case, it can be shown that no valid shuffling is possible.
Code:
import collections
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n = int(input())
data = dict(collections.Counter(map(int, input().split())))
if min(list(data.values())) > 1:
last = 1
for i in data.keys():
print(last + data[i] - 1, end=' ')
for j in range(last, last + data[i] - 1):
# TODO: Your code here
last = last + data[i]
print()
else:
print(-1)
|
import collections
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n = int(input())
data = dict(collections.Counter(map(int, input().split())))
if min(list(data.values())) > 1:
last = 1
for i in data.keys():
print(last + data[i] - 1, end=' ')
for j in range(last, last + data[i] - 1):
{{completion}}
last = last + data[i]
print()
else:
print(-1)
|
print(j, end=' ')
|
[{"input": "2\n5\n1 1 1 1 1\n6\n3 6 8 13 15 21", "output": ["5 1 2 3 4 \n-1"]}]
|
block_completion_002398
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A class of students got bored wearing the same pair of shoes every day, so they decided to shuffle their shoes among themselves. In this problem, a pair of shoes is inseparable and is considered as a single object.There are $$$n$$$ students in the class, and you are given an array $$$s$$$ in non-decreasing order, where $$$s_i$$$ is the shoe size of the $$$i$$$-th student. A shuffling of shoes is valid only if no student gets their own shoes and if every student gets shoes of size greater than or equal to their size. You have to output a permutation $$$p$$$ of $$$\{1,2,\ldots,n\}$$$ denoting a valid shuffling of shoes, where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student ($$$p_i \ne i$$$). And output $$$-1$$$ if a valid shuffling does not exist.A permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).
Input Specification: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) β the number of test cases. Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1\leq n\leq10^5$$$)Β β the number of students. The second line of each test case contains $$$n$$$ integers $$$s_1, s_2,\ldots,s_n$$$ ($$$1\leq s_i\leq10^9$$$, and for all $$$1\le i<n$$$, $$$s_i\le s_{i+1}$$$) β the shoe sizes of the students. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print the answer in a single line using the following format. If a valid shuffling does not exist, print the number $$$-1$$$ as the answer. If a valid shuffling exists, print $$$n$$$ space-separated integers β a permutation $$$p$$$ of $$$1,2,\ldots,n$$$ denoting a valid shuffling of shoes where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student. If there are multiple answers, then print any of them.
Notes: NoteIn the first test case, any permutation $$$p$$$ of $$$1,\ldots,n$$$ where $$$p_i\ne i$$$ would represent a valid shuffling since all students have equal shoe sizes, and thus anyone can wear anyone's shoes.In the second test case, it can be shown that no valid shuffling is possible.
Code:
for t in range(int(input())):
n=int(input())
x=list(map(int,input().split()))
g={}
if n==1:
print(-1)
else:
for i in range(n-1):
if not((x[i]==x[i+1] or x[i]==x[i-1]) and ( x[-1]==x[-2])):
print(-1)
break
g[x[i]]=[]
else:
for i in range(n):
g[x[i]].append(i+1)
for i,j in g.items():
for q in range(len(j)):
# TODO: Your code here
print()
|
for t in range(int(input())):
n=int(input())
x=list(map(int,input().split()))
g={}
if n==1:
print(-1)
else:
for i in range(n-1):
if not((x[i]==x[i+1] or x[i]==x[i-1]) and ( x[-1]==x[-2])):
print(-1)
break
g[x[i]]=[]
else:
for i in range(n):
g[x[i]].append(i+1)
for i,j in g.items():
for q in range(len(j)):
{{completion}}
print()
|
print(j[q-1],end=' ')
|
[{"input": "2\n5\n1 1 1 1 1\n6\n3 6 8 13 15 21", "output": ["5 1 2 3 4 \n-1"]}]
|
block_completion_002399
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A class of students got bored wearing the same pair of shoes every day, so they decided to shuffle their shoes among themselves. In this problem, a pair of shoes is inseparable and is considered as a single object.There are $$$n$$$ students in the class, and you are given an array $$$s$$$ in non-decreasing order, where $$$s_i$$$ is the shoe size of the $$$i$$$-th student. A shuffling of shoes is valid only if no student gets their own shoes and if every student gets shoes of size greater than or equal to their size. You have to output a permutation $$$p$$$ of $$$\{1,2,\ldots,n\}$$$ denoting a valid shuffling of shoes, where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student ($$$p_i \ne i$$$). And output $$$-1$$$ if a valid shuffling does not exist.A permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).
Input Specification: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) β the number of test cases. Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1\leq n\leq10^5$$$)Β β the number of students. The second line of each test case contains $$$n$$$ integers $$$s_1, s_2,\ldots,s_n$$$ ($$$1\leq s_i\leq10^9$$$, and for all $$$1\le i<n$$$, $$$s_i\le s_{i+1}$$$) β the shoe sizes of the students. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print the answer in a single line using the following format. If a valid shuffling does not exist, print the number $$$-1$$$ as the answer. If a valid shuffling exists, print $$$n$$$ space-separated integers β a permutation $$$p$$$ of $$$1,2,\ldots,n$$$ denoting a valid shuffling of shoes where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student. If there are multiple answers, then print any of them.
Notes: NoteIn the first test case, any permutation $$$p$$$ of $$$1,\ldots,n$$$ where $$$p_i\ne i$$$ would represent a valid shuffling since all students have equal shoe sizes, and thus anyone can wear anyone's shoes.In the second test case, it can be shown that no valid shuffling is possible.
Code:
t = int(input())
for i in range(t):
n = int(input())
s = [int(x) for x in input().split(' ')]
s.append('A')
f = 0
p = s[0]
c = 0
for x in range(n+1):
if s[x] == p:
s[x] = str(x)
c+=1
else:
if c == 1:
s = -1
break
else:
# TODO: Your code here
if s != -1:
s.pop()
print(' '.join(s))
else:
print(s)
|
t = int(input())
for i in range(t):
n = int(input())
s = [int(x) for x in input().split(' ')]
s.append('A')
f = 0
p = s[0]
c = 0
for x in range(n+1):
if s[x] == p:
s[x] = str(x)
c+=1
else:
if c == 1:
s = -1
break
else:
{{completion}}
if s != -1:
s.pop()
print(' '.join(s))
else:
print(s)
|
s[f] = str(x)
f = x
p = s[x]
c = 1
|
[{"input": "2\n5\n1 1 1 1 1\n6\n3 6 8 13 15 21", "output": ["5 1 2 3 4 \n-1"]}]
|
block_completion_002400
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A class of students got bored wearing the same pair of shoes every day, so they decided to shuffle their shoes among themselves. In this problem, a pair of shoes is inseparable and is considered as a single object.There are $$$n$$$ students in the class, and you are given an array $$$s$$$ in non-decreasing order, where $$$s_i$$$ is the shoe size of the $$$i$$$-th student. A shuffling of shoes is valid only if no student gets their own shoes and if every student gets shoes of size greater than or equal to their size. You have to output a permutation $$$p$$$ of $$$\{1,2,\ldots,n\}$$$ denoting a valid shuffling of shoes, where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student ($$$p_i \ne i$$$). And output $$$-1$$$ if a valid shuffling does not exist.A permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).
Input Specification: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) β the number of test cases. Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1\leq n\leq10^5$$$)Β β the number of students. The second line of each test case contains $$$n$$$ integers $$$s_1, s_2,\ldots,s_n$$$ ($$$1\leq s_i\leq10^9$$$, and for all $$$1\le i<n$$$, $$$s_i\le s_{i+1}$$$) β the shoe sizes of the students. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print the answer in a single line using the following format. If a valid shuffling does not exist, print the number $$$-1$$$ as the answer. If a valid shuffling exists, print $$$n$$$ space-separated integers β a permutation $$$p$$$ of $$$1,2,\ldots,n$$$ denoting a valid shuffling of shoes where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student. If there are multiple answers, then print any of them.
Notes: NoteIn the first test case, any permutation $$$p$$$ of $$$1,\ldots,n$$$ where $$$p_i\ne i$$$ would represent a valid shuffling since all students have equal shoe sizes, and thus anyone can wear anyone's shoes.In the second test case, it can be shown that no valid shuffling is possible.
Code:
import sys
input=sys.stdin.readline
for _ in range(int(input())):
n=int(input())
x=tuple(map(int,input().split()))
if n==1:
print(-1)
continue
ans=[-1]*n
extra=[]
visited=[False]*n
for i in range(n-1,-1,-1):
if i!=0 and x[i]==x[i-1]:
ans[i]=i
visited[i-1]=True
if not visited[i]:
extra.append(i+1)
else:
if extra:
ans[i]=extra.pop()
else:
# TODO: Your code here
else:
print(*ans)
|
import sys
input=sys.stdin.readline
for _ in range(int(input())):
n=int(input())
x=tuple(map(int,input().split()))
if n==1:
print(-1)
continue
ans=[-1]*n
extra=[]
visited=[False]*n
for i in range(n-1,-1,-1):
if i!=0 and x[i]==x[i-1]:
ans[i]=i
visited[i-1]=True
if not visited[i]:
extra.append(i+1)
else:
if extra:
ans[i]=extra.pop()
else:
{{completion}}
else:
print(*ans)
|
print(-1)
break
|
[{"input": "2\n5\n1 1 1 1 1\n6\n3 6 8 13 15 21", "output": ["5 1 2 3 4 \n-1"]}]
|
block_completion_002401
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A class of students got bored wearing the same pair of shoes every day, so they decided to shuffle their shoes among themselves. In this problem, a pair of shoes is inseparable and is considered as a single object.There are $$$n$$$ students in the class, and you are given an array $$$s$$$ in non-decreasing order, where $$$s_i$$$ is the shoe size of the $$$i$$$-th student. A shuffling of shoes is valid only if no student gets their own shoes and if every student gets shoes of size greater than or equal to their size. You have to output a permutation $$$p$$$ of $$$\{1,2,\ldots,n\}$$$ denoting a valid shuffling of shoes, where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student ($$$p_i \ne i$$$). And output $$$-1$$$ if a valid shuffling does not exist.A permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).
Input Specification: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) β the number of test cases. Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1\leq n\leq10^5$$$)Β β the number of students. The second line of each test case contains $$$n$$$ integers $$$s_1, s_2,\ldots,s_n$$$ ($$$1\leq s_i\leq10^9$$$, and for all $$$1\le i<n$$$, $$$s_i\le s_{i+1}$$$) β the shoe sizes of the students. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print the answer in a single line using the following format. If a valid shuffling does not exist, print the number $$$-1$$$ as the answer. If a valid shuffling exists, print $$$n$$$ space-separated integers β a permutation $$$p$$$ of $$$1,2,\ldots,n$$$ denoting a valid shuffling of shoes where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student. If there are multiple answers, then print any of them.
Notes: NoteIn the first test case, any permutation $$$p$$$ of $$$1,\ldots,n$$$ where $$$p_i\ne i$$$ would represent a valid shuffling since all students have equal shoe sizes, and thus anyone can wear anyone's shoes.In the second test case, it can be shown that no valid shuffling is possible.
Code:
from sys import stdin
input = stdin.readline
I = lambda : list(map(int, input().split()))
def solve(N,A):
dic = {}
for i in range(N):
if A[i] not in dic:
# TODO: Your code here
dic[A[i]].append(i)
ans = [0]*N
for k in dic.keys():
l = dic[k]
if len(l) == 1:
return [-1]
for i in range(len(l)):
ans[l[i]] = l[(i-1)%len(l)] + 1
return ans
T = int(input())
for _ in range(T):
N = int(input())
A = I()
print(*solve(N,A))
|
from sys import stdin
input = stdin.readline
I = lambda : list(map(int, input().split()))
def solve(N,A):
dic = {}
for i in range(N):
if A[i] not in dic:
{{completion}}
dic[A[i]].append(i)
ans = [0]*N
for k in dic.keys():
l = dic[k]
if len(l) == 1:
return [-1]
for i in range(len(l)):
ans[l[i]] = l[(i-1)%len(l)] + 1
return ans
T = int(input())
for _ in range(T):
N = int(input())
A = I()
print(*solve(N,A))
|
dic[A[i]] = []
|
[{"input": "2\n5\n1 1 1 1 1\n6\n3 6 8 13 15 21", "output": ["5 1 2 3 4 \n-1"]}]
|
block_completion_002402
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A class of students got bored wearing the same pair of shoes every day, so they decided to shuffle their shoes among themselves. In this problem, a pair of shoes is inseparable and is considered as a single object.There are $$$n$$$ students in the class, and you are given an array $$$s$$$ in non-decreasing order, where $$$s_i$$$ is the shoe size of the $$$i$$$-th student. A shuffling of shoes is valid only if no student gets their own shoes and if every student gets shoes of size greater than or equal to their size. You have to output a permutation $$$p$$$ of $$$\{1,2,\ldots,n\}$$$ denoting a valid shuffling of shoes, where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student ($$$p_i \ne i$$$). And output $$$-1$$$ if a valid shuffling does not exist.A permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).
Input Specification: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) β the number of test cases. Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1\leq n\leq10^5$$$)Β β the number of students. The second line of each test case contains $$$n$$$ integers $$$s_1, s_2,\ldots,s_n$$$ ($$$1\leq s_i\leq10^9$$$, and for all $$$1\le i<n$$$, $$$s_i\le s_{i+1}$$$) β the shoe sizes of the students. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print the answer in a single line using the following format. If a valid shuffling does not exist, print the number $$$-1$$$ as the answer. If a valid shuffling exists, print $$$n$$$ space-separated integers β a permutation $$$p$$$ of $$$1,2,\ldots,n$$$ denoting a valid shuffling of shoes where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student. If there are multiple answers, then print any of them.
Notes: NoteIn the first test case, any permutation $$$p$$$ of $$$1,\ldots,n$$$ where $$$p_i\ne i$$$ would represent a valid shuffling since all students have equal shoe sizes, and thus anyone can wear anyone's shoes.In the second test case, it can be shown that no valid shuffling is possible.
Code:
from sys import stdin
input = stdin.readline
I = lambda : list(map(int, input().split()))
def solve(N,A):
dic = {}
for i in range(N):
if A[i] not in dic:
dic[A[i]] = []
dic[A[i]].append(i)
ans = [0]*N
for k in dic.keys():
l = dic[k]
if len(l) == 1:
# TODO: Your code here
for i in range(len(l)):
ans[l[i]] = l[(i-1)%len(l)] + 1
return ans
T = int(input())
for _ in range(T):
N = int(input())
A = I()
print(*solve(N,A))
|
from sys import stdin
input = stdin.readline
I = lambda : list(map(int, input().split()))
def solve(N,A):
dic = {}
for i in range(N):
if A[i] not in dic:
dic[A[i]] = []
dic[A[i]].append(i)
ans = [0]*N
for k in dic.keys():
l = dic[k]
if len(l) == 1:
{{completion}}
for i in range(len(l)):
ans[l[i]] = l[(i-1)%len(l)] + 1
return ans
T = int(input())
for _ in range(T):
N = int(input())
A = I()
print(*solve(N,A))
|
return [-1]
|
[{"input": "2\n5\n1 1 1 1 1\n6\n3 6 8 13 15 21", "output": ["5 1 2 3 4 \n-1"]}]
|
block_completion_002403
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A class of students got bored wearing the same pair of shoes every day, so they decided to shuffle their shoes among themselves. In this problem, a pair of shoes is inseparable and is considered as a single object.There are $$$n$$$ students in the class, and you are given an array $$$s$$$ in non-decreasing order, where $$$s_i$$$ is the shoe size of the $$$i$$$-th student. A shuffling of shoes is valid only if no student gets their own shoes and if every student gets shoes of size greater than or equal to their size. You have to output a permutation $$$p$$$ of $$$\{1,2,\ldots,n\}$$$ denoting a valid shuffling of shoes, where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student ($$$p_i \ne i$$$). And output $$$-1$$$ if a valid shuffling does not exist.A permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).
Input Specification: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) β the number of test cases. Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1\leq n\leq10^5$$$)Β β the number of students. The second line of each test case contains $$$n$$$ integers $$$s_1, s_2,\ldots,s_n$$$ ($$$1\leq s_i\leq10^9$$$, and for all $$$1\le i<n$$$, $$$s_i\le s_{i+1}$$$) β the shoe sizes of the students. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print the answer in a single line using the following format. If a valid shuffling does not exist, print the number $$$-1$$$ as the answer. If a valid shuffling exists, print $$$n$$$ space-separated integers β a permutation $$$p$$$ of $$$1,2,\ldots,n$$$ denoting a valid shuffling of shoes where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student. If there are multiple answers, then print any of them.
Notes: NoteIn the first test case, any permutation $$$p$$$ of $$$1,\ldots,n$$$ where $$$p_i\ne i$$$ would represent a valid shuffling since all students have equal shoe sizes, and thus anyone can wear anyone's shoes.In the second test case, it can be shown that no valid shuffling is possible.
Code:
for _ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
freq = {}
for i in arr:
if(i in freq): freq[i] += 1
else: freq[i] = 1
for i in freq:
if(freq[i] == 1): #not in pairs
print(-1);break
else:
ans2 = []
for i in freq:
res = []
res.append(freq[i]+len(ans2))
for j in range(1,freq[i]):
# TODO: Your code here
ans2.extend(res)
print(*ans2)
|
for _ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
freq = {}
for i in arr:
if(i in freq): freq[i] += 1
else: freq[i] = 1
for i in freq:
if(freq[i] == 1): #not in pairs
print(-1);break
else:
ans2 = []
for i in freq:
res = []
res.append(freq[i]+len(ans2))
for j in range(1,freq[i]):
{{completion}}
ans2.extend(res)
print(*ans2)
|
res.append(j+len(ans2))
|
[{"input": "2\n5\n1 1 1 1 1\n6\n3 6 8 13 15 21", "output": ["5 1 2 3 4 \n-1"]}]
|
block_completion_002404
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: A class of students got bored wearing the same pair of shoes every day, so they decided to shuffle their shoes among themselves. In this problem, a pair of shoes is inseparable and is considered as a single object.There are $$$n$$$ students in the class, and you are given an array $$$s$$$ in non-decreasing order, where $$$s_i$$$ is the shoe size of the $$$i$$$-th student. A shuffling of shoes is valid only if no student gets their own shoes and if every student gets shoes of size greater than or equal to their size. You have to output a permutation $$$p$$$ of $$$\{1,2,\ldots,n\}$$$ denoting a valid shuffling of shoes, where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student ($$$p_i \ne i$$$). And output $$$-1$$$ if a valid shuffling does not exist.A permutation is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array) and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).
Input Specification: Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \le t \le 1000$$$) β the number of test cases. Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1\leq n\leq10^5$$$)Β β the number of students. The second line of each test case contains $$$n$$$ integers $$$s_1, s_2,\ldots,s_n$$$ ($$$1\leq s_i\leq10^9$$$, and for all $$$1\le i<n$$$, $$$s_i\le s_{i+1}$$$) β the shoe sizes of the students. It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.
Output Specification: For each test case, print the answer in a single line using the following format. If a valid shuffling does not exist, print the number $$$-1$$$ as the answer. If a valid shuffling exists, print $$$n$$$ space-separated integers β a permutation $$$p$$$ of $$$1,2,\ldots,n$$$ denoting a valid shuffling of shoes where the $$$i$$$-th student gets the shoes of the $$$p_i$$$-th student. If there are multiple answers, then print any of them.
Notes: NoteIn the first test case, any permutation $$$p$$$ of $$$1,\ldots,n$$$ where $$$p_i\ne i$$$ would represent a valid shuffling since all students have equal shoe sizes, and thus anyone can wear anyone's shoes.In the second test case, it can be shown that no valid shuffling is possible.
Code:
from bisect import bisect_left
cases = int(input())
for run in range(cases):
n = int(input())
shoes = input().split()
for x in range(len(shoes)):
shoes[x] = int(shoes[x])
perm = []
i = 0
while i < len(shoes) and perm != [-1]:
p = bisect_left(shoes,shoes[i]+1)-1
if p == i:
perm = [-1]
else:
# TODO: Your code here
print(" ".join([str(int) for int in perm]))
|
from bisect import bisect_left
cases = int(input())
for run in range(cases):
n = int(input())
shoes = input().split()
for x in range(len(shoes)):
shoes[x] = int(shoes[x])
perm = []
i = 0
while i < len(shoes) and perm != [-1]:
p = bisect_left(shoes,shoes[i]+1)-1
if p == i:
perm = [-1]
else:
{{completion}}
print(" ".join([str(int) for int in perm]))
|
perm.append(p+1)
perm += list(range(i+1,p+1))
i = p+1
|
[{"input": "2\n5\n1 1 1 1 1\n6\n3 6 8 13 15 21", "output": ["5 1 2 3 4 \n-1"]}]
|
block_completion_002405
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a tree $$$G$$$ with $$$n$$$ vertices and an integer $$$k$$$. The vertices of the tree are numbered from $$$1$$$ to $$$n$$$.For a vertex $$$r$$$ and a subset $$$S$$$ of vertices of $$$G$$$, such that $$$|S| = k$$$, we define $$$f(r, S)$$$ as the size of the smallest rooted subtree containing all vertices in $$$S$$$ when the tree is rooted at $$$r$$$. A set of vertices $$$T$$$ is called a rooted subtree, if all the vertices in $$$T$$$ are connected, and for each vertex in $$$T$$$, all its descendants belong to $$$T$$$.You need to calculate the sum of $$$f(r, S)$$$ over all possible distinct combinations of vertices $$$r$$$ and subsets $$$S$$$, where $$$|S| = k$$$. Formally, compute the following: $$$$$$\sum_{r \in V} \sum_{S \subseteq V, |S| = k} f(r, S),$$$$$$ where $$$V$$$ is the set of vertices in $$$G$$$.Output the answer modulo $$$10^9 + 7$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$k$$$ ($$$3 \le n \le 2 \cdot 10^5$$$, $$$1 \le k \le n$$$). Each of the following $$$n - 1$$$ lines contains two integers $$$x$$$ and $$$y$$$ ($$$1 \le x, y \le n$$$), denoting an edge between vertex $$$x$$$ and $$$y$$$. It is guaranteed that the given edges form a tree.
Output Specification: Print the answer modulo $$$10^9 + 7$$$.
Notes: NoteThe tree in the second example is given below: We have $$$21$$$ subsets of size $$$2$$$ in the given tree. Hence, $$$$$$S \in \left\{\{1, 2\}, \{1, 3\}, \{1, 4\}, \{1, 5\}, \{1, 6\}, \{1, 7\}, \{2, 3\}, \{2, 4\}, \{2, 5\}, \{2, 6\}, \{2, 7\}, \{3, 4\}, \{3, 5\}, \{3, 6\}, \{3, 7\}, \{4, 5\}, \{4, 6\}, \{4, 7\}, \{5, 6\}, \{5, 7\}, \{6, 7\} \right\}.$$$$$$ And since we have $$$7$$$ vertices, $$$1 \le r \le 7$$$. We need to find the sum of $$$f(r, S)$$$ over all possible pairs of $$$r$$$ and $$$S$$$. Below we have listed the value of $$$f(r, S)$$$ for some combinations of $$$r$$$ and $$$S$$$. $$$r = 1$$$, $$$S = \{3, 7\}$$$. The value of $$$f(r, S)$$$ is $$$5$$$ and the corresponding subtree is $$$\{2, 3, 4, 6, 7\}$$$. $$$r = 1$$$, $$$S = \{5, 4\}$$$. The value of $$$f(r, S)$$$ is $$$7$$$ and the corresponding subtree is $$$\{1, 2, 3, 4, 5, 6, 7\}$$$. $$$r = 1$$$, $$$S = \{4, 6\}$$$. The value of $$$f(r, S)$$$ is $$$3$$$ and the corresponding subtree is $$$\{4, 6, 7\}$$$.
Code:
import sys
sys.setrecursionlimit(300000)
import faulthandler
faulthandler.enable()
n, k = map(int, input().split())
MOD = 10**9 + 7
fact = [1 for i in range(n+1)]
for i in range(2, n+1):
fact[i] = i*fact[i-1] % MOD
inv_fact = [1 for i in range(n+1)]
inv_fact[-1] = pow(fact[-1], MOD-2, MOD)
for i in range(1, n):
inv_fact[n-i] = (n-i+1)*inv_fact[n-i+1] % MOD
def comb(a, b):
if a < b:
return 0
return fact[a]*inv_fact[b]*inv_fact[a-b] % MOD
edges = [[] for i in range(n)]
for _ in range(n-1):
x, y = map(lambda a: int(a)-1, input().split())
edges[x].append(y)
edges[y].append(x)
ends = [[] for i in range(n)]
visited = [0 for i in range(n)]
totals = [1 for i in range(n)]
dfs_stack = [0]
while len(dfs_stack) > 0:
node = dfs_stack[-1]
if visited[node] == 1:
visited[node] = 2
for next_node in edges[node]:
if visited[next_node] == 2:
totals[node] += totals[next_node]
ends[node].append(totals[next_node])
ends[node].append(n-totals[node])
dfs_stack.pop()
else:
visited[node] = 1
for next_node in edges[node]:
if visited[next_node] == 0:
# TODO: Your code here
z = n*n * comb(n, k) % MOD
node_v = [0 for i in range(n)]
for i in range(n):
node_v[i] = sum(comb(e, k) for e in ends[i]) % MOD
for e in ends[i]:
z = (z - e*e * (comb(n-e, k) + comb(e, k) - node_v[i])) % MOD
print(z)
|
import sys
sys.setrecursionlimit(300000)
import faulthandler
faulthandler.enable()
n, k = map(int, input().split())
MOD = 10**9 + 7
fact = [1 for i in range(n+1)]
for i in range(2, n+1):
fact[i] = i*fact[i-1] % MOD
inv_fact = [1 for i in range(n+1)]
inv_fact[-1] = pow(fact[-1], MOD-2, MOD)
for i in range(1, n):
inv_fact[n-i] = (n-i+1)*inv_fact[n-i+1] % MOD
def comb(a, b):
if a < b:
return 0
return fact[a]*inv_fact[b]*inv_fact[a-b] % MOD
edges = [[] for i in range(n)]
for _ in range(n-1):
x, y = map(lambda a: int(a)-1, input().split())
edges[x].append(y)
edges[y].append(x)
ends = [[] for i in range(n)]
visited = [0 for i in range(n)]
totals = [1 for i in range(n)]
dfs_stack = [0]
while len(dfs_stack) > 0:
node = dfs_stack[-1]
if visited[node] == 1:
visited[node] = 2
for next_node in edges[node]:
if visited[next_node] == 2:
totals[node] += totals[next_node]
ends[node].append(totals[next_node])
ends[node].append(n-totals[node])
dfs_stack.pop()
else:
visited[node] = 1
for next_node in edges[node]:
if visited[next_node] == 0:
{{completion}}
z = n*n * comb(n, k) % MOD
node_v = [0 for i in range(n)]
for i in range(n):
node_v[i] = sum(comb(e, k) for e in ends[i]) % MOD
for e in ends[i]:
z = (z - e*e * (comb(n-e, k) + comb(e, k) - node_v[i])) % MOD
print(z)
|
dfs_stack.append(next_node)
|
[{"input": "3 2\n1 2\n1 3", "output": ["25"]}, {"input": "7 2\n1 2\n2 3\n2 4\n1 5\n4 6\n4 7", "output": ["849"]}]
|
block_completion_002482
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a tree $$$G$$$ with $$$n$$$ vertices and an integer $$$k$$$. The vertices of the tree are numbered from $$$1$$$ to $$$n$$$.For a vertex $$$r$$$ and a subset $$$S$$$ of vertices of $$$G$$$, such that $$$|S| = k$$$, we define $$$f(r, S)$$$ as the size of the smallest rooted subtree containing all vertices in $$$S$$$ when the tree is rooted at $$$r$$$. A set of vertices $$$T$$$ is called a rooted subtree, if all the vertices in $$$T$$$ are connected, and for each vertex in $$$T$$$, all its descendants belong to $$$T$$$.You need to calculate the sum of $$$f(r, S)$$$ over all possible distinct combinations of vertices $$$r$$$ and subsets $$$S$$$, where $$$|S| = k$$$. Formally, compute the following: $$$$$$\sum_{r \in V} \sum_{S \subseteq V, |S| = k} f(r, S),$$$$$$ where $$$V$$$ is the set of vertices in $$$G$$$.Output the answer modulo $$$10^9 + 7$$$.
Input Specification: The first line contains two integers $$$n$$$ and $$$k$$$ ($$$3 \le n \le 2 \cdot 10^5$$$, $$$1 \le k \le n$$$). Each of the following $$$n - 1$$$ lines contains two integers $$$x$$$ and $$$y$$$ ($$$1 \le x, y \le n$$$), denoting an edge between vertex $$$x$$$ and $$$y$$$. It is guaranteed that the given edges form a tree.
Output Specification: Print the answer modulo $$$10^9 + 7$$$.
Notes: NoteThe tree in the second example is given below: We have $$$21$$$ subsets of size $$$2$$$ in the given tree. Hence, $$$$$$S \in \left\{\{1, 2\}, \{1, 3\}, \{1, 4\}, \{1, 5\}, \{1, 6\}, \{1, 7\}, \{2, 3\}, \{2, 4\}, \{2, 5\}, \{2, 6\}, \{2, 7\}, \{3, 4\}, \{3, 5\}, \{3, 6\}, \{3, 7\}, \{4, 5\}, \{4, 6\}, \{4, 7\}, \{5, 6\}, \{5, 7\}, \{6, 7\} \right\}.$$$$$$ And since we have $$$7$$$ vertices, $$$1 \le r \le 7$$$. We need to find the sum of $$$f(r, S)$$$ over all possible pairs of $$$r$$$ and $$$S$$$. Below we have listed the value of $$$f(r, S)$$$ for some combinations of $$$r$$$ and $$$S$$$. $$$r = 1$$$, $$$S = \{3, 7\}$$$. The value of $$$f(r, S)$$$ is $$$5$$$ and the corresponding subtree is $$$\{2, 3, 4, 6, 7\}$$$. $$$r = 1$$$, $$$S = \{5, 4\}$$$. The value of $$$f(r, S)$$$ is $$$7$$$ and the corresponding subtree is $$$\{1, 2, 3, 4, 5, 6, 7\}$$$. $$$r = 1$$$, $$$S = \{4, 6\}$$$. The value of $$$f(r, S)$$$ is $$$3$$$ and the corresponding subtree is $$$\{4, 6, 7\}$$$.
Code:
# import io,os
# read = io.BytesIO(os.read(0, os.fstat(0).st_size))
# I = lambda: [*map(int, read.readline().split())]
import sys
I=lambda:[*map(int,sys.stdin.readline().split())]
M = 10 ** 9 + 7
n, k = I()
binomk = [0] * k
binomk.append(1)
for i in range(k + 1, n + 1):
binomk.append(binomk[-1] * i * pow(i - k, M - 2, M) % M)
neighbors = [[] for i in range(n)]
for i in range(n - 1):
a, b = I()
a -= 1
b -= 1
neighbors[a].append(b)
neighbors[b].append(a)
parents = [None] + [-1] * (n - 1)
children = [[] for i in range(n)]
layer = [0]
while layer:
newlayer = []
for guy in layer:
for boi in neighbors[guy]:
if boi != parents[guy]:
# TODO: Your code here
layer = newlayer
size = [0] * n
q = []
for i in range(n):
if len(children[i]) == 0:
q.append(i)
qind = 0
left = [len(children[i]) for i in range(n)]
while qind < len(q):
v = q[qind]
tot = 1
for guy in children[v]:
tot += size[guy]
size[v] = tot
if parents[v] is None:
break
left[parents[v]] -= 1
if left[parents[v]] == 0:
q.append(parents[v])
qind += 1
answer = 0
for i in range(n):
things = []
for guy in children[i]:
things.append(size[guy])
if i != 0:
things.append(n - 1 - sum(things))
bins = [binomk[i] for i in things]
ss = sum(bins) % M
for guy in things:
answer = (answer + (n - guy) * guy * binomk[n - guy]) % M
answer = (answer - (n - guy) * guy * (ss - binomk[guy])) % M
answer = (answer + n * binomk[n]) % M
answer = (answer - ss * n) % M
print(answer)
|
# import io,os
# read = io.BytesIO(os.read(0, os.fstat(0).st_size))
# I = lambda: [*map(int, read.readline().split())]
import sys
I=lambda:[*map(int,sys.stdin.readline().split())]
M = 10 ** 9 + 7
n, k = I()
binomk = [0] * k
binomk.append(1)
for i in range(k + 1, n + 1):
binomk.append(binomk[-1] * i * pow(i - k, M - 2, M) % M)
neighbors = [[] for i in range(n)]
for i in range(n - 1):
a, b = I()
a -= 1
b -= 1
neighbors[a].append(b)
neighbors[b].append(a)
parents = [None] + [-1] * (n - 1)
children = [[] for i in range(n)]
layer = [0]
while layer:
newlayer = []
for guy in layer:
for boi in neighbors[guy]:
if boi != parents[guy]:
{{completion}}
layer = newlayer
size = [0] * n
q = []
for i in range(n):
if len(children[i]) == 0:
q.append(i)
qind = 0
left = [len(children[i]) for i in range(n)]
while qind < len(q):
v = q[qind]
tot = 1
for guy in children[v]:
tot += size[guy]
size[v] = tot
if parents[v] is None:
break
left[parents[v]] -= 1
if left[parents[v]] == 0:
q.append(parents[v])
qind += 1
answer = 0
for i in range(n):
things = []
for guy in children[i]:
things.append(size[guy])
if i != 0:
things.append(n - 1 - sum(things))
bins = [binomk[i] for i in things]
ss = sum(bins) % M
for guy in things:
answer = (answer + (n - guy) * guy * binomk[n - guy]) % M
answer = (answer - (n - guy) * guy * (ss - binomk[guy])) % M
answer = (answer + n * binomk[n]) % M
answer = (answer - ss * n) % M
print(answer)
|
children[guy].append(boi)
parents[boi] = guy
newlayer.append(boi)
|
[{"input": "3 2\n1 2\n1 3", "output": ["25"]}, {"input": "7 2\n1 2\n2 3\n2 4\n1 5\n4 6\n4 7", "output": ["849"]}]
|
block_completion_002483
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Mike and Joe are playing a game with some stones. Specifically, they have $$$n$$$ piles of stones of sizes $$$a_1, a_2, \ldots, a_n$$$. These piles are arranged in a circle.The game goes as follows. Players take turns removing some positive number of stones from a pile in clockwise order starting from pile $$$1$$$. Formally, if a player removed stones from pile $$$i$$$ on a turn, the other player removes stones from pile $$$((i\bmod n) + 1)$$$ on the next turn.If a player cannot remove any stones on their turn (because the pile is empty), they lose. Mike goes first.If Mike and Joe play optimally, who will win?
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \le t \le 1000$$$). Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \le n \le 50$$$) Β β the number of piles. The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le 10^9$$$) Β β the size of the piles.
Output Specification: For each test case print the winner of the game, either "Mike" or "Joe" on its own line (without quotes).
Notes: NoteIn the first test case, Mike just takes all $$$37$$$ stones on his first turn.In the second test case, Joe can just copy Mike's moves every time. Since Mike went first, he will hit $$$0$$$ on the first pile one move before Joe does so on the second pile.
Code:
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N = nextInt()
A = getIntArray(N)
if N % 2 == 0:
a1 = [A[i] for i in range(0, N, 2)]
a2 = [A[i] for i in range(1, N, 2)]
i1, i2 = a1.index(min(a1)), a2.index(min(a2))
m1 = min(a1) * len(a1) + i1
m2 = min(a2) * len(a2) + i2
print("Mike" if m1 > m2 else "Joe")
else:
# TODO: Your code here
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N = nextInt()
A = getIntArray(N)
if N % 2 == 0:
a1 = [A[i] for i in range(0, N, 2)]
a2 = [A[i] for i in range(1, N, 2)]
i1, i2 = a1.index(min(a1)), a2.index(min(a2))
m1 = min(a1) * len(a1) + i1
m2 = min(a2) * len(a2) + i2
print("Mike" if m1 > m2 else "Joe")
else:
{{completion}}
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
print("Mike")
|
[{"input": "2\n\n1\n\n37\n\n2\n\n100 100", "output": ["Mike\nJoe"]}]
|
block_completion_002489
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Mike and Joe are playing a game with some stones. Specifically, they have $$$n$$$ piles of stones of sizes $$$a_1, a_2, \ldots, a_n$$$. These piles are arranged in a circle.The game goes as follows. Players take turns removing some positive number of stones from a pile in clockwise order starting from pile $$$1$$$. Formally, if a player removed stones from pile $$$i$$$ on a turn, the other player removes stones from pile $$$((i\bmod n) + 1)$$$ on the next turn.If a player cannot remove any stones on their turn (because the pile is empty), they lose. Mike goes first.If Mike and Joe play optimally, who will win?
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \le t \le 1000$$$). Description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$1 \le n \le 50$$$) Β β the number of piles. The second line contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le 10^9$$$) Β β the size of the piles.
Output Specification: For each test case print the winner of the game, either "Mike" or "Joe" on its own line (without quotes).
Notes: NoteIn the first test case, Mike just takes all $$$37$$$ stones on his first turn.In the second test case, Joe can just copy Mike's moves every time. Since Mike went first, he will hit $$$0$$$ on the first pile one move before Joe does so on the second pile.
Code:
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N = nextInt()
A = getIntArray(N)
if N % 2 == 0:
a1 = [A[i] for i in range(0, N, 2)]
a2 = [A[i] for i in range(1, N, 2)]
i1, i2 = a1.index(min(a1)), a2.index(min(a2))
m1 = min(a1) * len(a1) + i1
m2 = min(a2) * len(a2) + i2
print("Mike" if m1 > m2 else "Joe")
else:
print("Mike")
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
# TODO: Your code here
assert not tokens
|
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N = nextInt()
A = getIntArray(N)
if N % 2 == 0:
a1 = [A[i] for i in range(0, N, 2)]
a2 = [A[i] for i in range(1, N, 2)]
i1, i2 = a1.index(min(a1)), a2.index(min(a2))
m1 = min(a1) * len(a1) + i1
m2 = min(a2) * len(a2) + i2
print("Mike" if m1 > m2 else "Joe")
else:
print("Mike")
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
{{completion}}
assert not tokens
|
solve(tc + 1)
|
[{"input": "2\n\n1\n\n37\n\n2\n\n100 100", "output": ["Mike\nJoe"]}]
|
block_completion_002490
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a grid with $$$n$$$ rows and $$$m$$$ columns. We denote the square on the $$$i$$$-th ($$$1\le i\le n$$$) row and $$$j$$$-th ($$$1\le j\le m$$$) column by $$$(i, j)$$$ and the number there by $$$a_{ij}$$$. All numbers are equal to $$$1$$$ or to $$$-1$$$. You start from the square $$$(1, 1)$$$ and can move one square down or one square to the right at a time. In the end, you want to end up at the square $$$(n, m)$$$.Is it possible to move in such a way so that the sum of the values written in all the visited cells (including $$$a_{11}$$$ and $$$a_{nm}$$$) is $$$0$$$?
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \leq t \leq 10^4$$$). Description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n, m \le 1000$$$) Β β the size of the grid. Each of the following $$$n$$$ lines contains $$$m$$$ integers. The $$$j$$$-th integer on the $$$i$$$-th line is $$$a_{ij}$$$ ($$$a_{ij} = 1$$$ or $$$-1$$$) Β β the element in the cell $$$(i, j)$$$. It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$10^6$$$.
Output Specification: For each test case, print "YES" if there exists a path from the top left to the bottom right that adds up to $$$0$$$, and "NO" otherwise. You can output each letter in any case.
Notes: NoteOne possible path for the fourth test case is given in the picture in the statement.
Code:
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N, M = nextInt(), nextInt()
A = [getIntArray(M) for i in range(N)]
def get(sum):
return sum + N + M
B = [[0] * M for i in range(N)]
B[0][0] |= 1 << get(A[0][0])
for i in range(N):
for j in range(M):
if i == 0 and j == 0: continue
if i: B[i][j] |= B[i - 1][j]
if j: B[i][j] |= B[i][j - 1]
if A[i][j] > 0: B[i][j] <<= 1
else: # TODO: Your code here
if i: B[i - 1] = None
print("YES" if B[-1][-1] & (1 << get(0)) else "NO")
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N, M = nextInt(), nextInt()
A = [getIntArray(M) for i in range(N)]
def get(sum):
return sum + N + M
B = [[0] * M for i in range(N)]
B[0][0] |= 1 << get(A[0][0])
for i in range(N):
for j in range(M):
if i == 0 and j == 0: continue
if i: B[i][j] |= B[i - 1][j]
if j: B[i][j] |= B[i][j - 1]
if A[i][j] > 0: B[i][j] <<= 1
else: {{completion}}
if i: B[i - 1] = None
print("YES" if B[-1][-1] & (1 << get(0)) else "NO")
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
B[i][j] >>= 1
|
[{"input": "5\n\n1 1\n\n1\n\n1 2\n\n1 -1\n\n1 4\n\n1 -1 1 -1\n\n3 4\n\n1 -1 -1 -1\n\n-1 1 1 -1\n\n1 1 1 -1\n\n3 4\n\n1 -1 1 1\n\n-1 1 -1 1\n\n1 -1 1 1", "output": ["NO\nYES\nYES\nYES\nNO"]}]
|
block_completion_002514
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a grid with $$$n$$$ rows and $$$m$$$ columns. We denote the square on the $$$i$$$-th ($$$1\le i\le n$$$) row and $$$j$$$-th ($$$1\le j\le m$$$) column by $$$(i, j)$$$ and the number there by $$$a_{ij}$$$. All numbers are equal to $$$1$$$ or to $$$-1$$$. You start from the square $$$(1, 1)$$$ and can move one square down or one square to the right at a time. In the end, you want to end up at the square $$$(n, m)$$$.Is it possible to move in such a way so that the sum of the values written in all the visited cells (including $$$a_{11}$$$ and $$$a_{nm}$$$) is $$$0$$$?
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \leq t \leq 10^4$$$). Description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n, m \le 1000$$$) Β β the size of the grid. Each of the following $$$n$$$ lines contains $$$m$$$ integers. The $$$j$$$-th integer on the $$$i$$$-th line is $$$a_{ij}$$$ ($$$a_{ij} = 1$$$ or $$$-1$$$) Β β the element in the cell $$$(i, j)$$$. It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$10^6$$$.
Output Specification: For each test case, print "YES" if there exists a path from the top left to the bottom right that adds up to $$$0$$$, and "NO" otherwise. You can output each letter in any case.
Notes: NoteOne possible path for the fourth test case is given in the picture in the statement.
Code:
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N, M = nextInt(), nextInt()
A = [getIntArray(M) for i in range(N)]
def get(sum):
return sum + N + M
B = [[0] * M for i in range(N)]
B[0][0] |= 1 << get(A[0][0])
for i in range(N):
for j in range(M):
if i == 0 and j == 0: # TODO: Your code here
if i: B[i][j] |= B[i - 1][j]
if j: B[i][j] |= B[i][j - 1]
if A[i][j] > 0: B[i][j] <<= 1
else: B[i][j] >>= 1
if i: B[i - 1] = None
print("YES" if B[-1][-1] & (1 << get(0)) else "NO")
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N, M = nextInt(), nextInt()
A = [getIntArray(M) for i in range(N)]
def get(sum):
return sum + N + M
B = [[0] * M for i in range(N)]
B[0][0] |= 1 << get(A[0][0])
for i in range(N):
for j in range(M):
if i == 0 and j == 0: {{completion}}
if i: B[i][j] |= B[i - 1][j]
if j: B[i][j] |= B[i][j - 1]
if A[i][j] > 0: B[i][j] <<= 1
else: B[i][j] >>= 1
if i: B[i - 1] = None
print("YES" if B[-1][-1] & (1 << get(0)) else "NO")
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
continue
|
[{"input": "5\n\n1 1\n\n1\n\n1 2\n\n1 -1\n\n1 4\n\n1 -1 1 -1\n\n3 4\n\n1 -1 -1 -1\n\n-1 1 1 -1\n\n1 1 1 -1\n\n3 4\n\n1 -1 1 1\n\n-1 1 -1 1\n\n1 -1 1 1", "output": ["NO\nYES\nYES\nYES\nNO"]}]
|
block_completion_002515
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a grid with $$$n$$$ rows and $$$m$$$ columns. We denote the square on the $$$i$$$-th ($$$1\le i\le n$$$) row and $$$j$$$-th ($$$1\le j\le m$$$) column by $$$(i, j)$$$ and the number there by $$$a_{ij}$$$. All numbers are equal to $$$1$$$ or to $$$-1$$$. You start from the square $$$(1, 1)$$$ and can move one square down or one square to the right at a time. In the end, you want to end up at the square $$$(n, m)$$$.Is it possible to move in such a way so that the sum of the values written in all the visited cells (including $$$a_{11}$$$ and $$$a_{nm}$$$) is $$$0$$$?
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \leq t \leq 10^4$$$). Description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n, m \le 1000$$$) Β β the size of the grid. Each of the following $$$n$$$ lines contains $$$m$$$ integers. The $$$j$$$-th integer on the $$$i$$$-th line is $$$a_{ij}$$$ ($$$a_{ij} = 1$$$ or $$$-1$$$) Β β the element in the cell $$$(i, j)$$$. It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$10^6$$$.
Output Specification: For each test case, print "YES" if there exists a path from the top left to the bottom right that adds up to $$$0$$$, and "NO" otherwise. You can output each letter in any case.
Notes: NoteOne possible path for the fourth test case is given in the picture in the statement.
Code:
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N, M = nextInt(), nextInt()
A = [getIntArray(M) for _ in range(N)]
if N < M:
A = [list(i) for i in zip(*A)]
N, M = M, N
def get(sum):
return sum + N + M
B = [[0] * M for i in range(N)]
B[0][0] |= 1 << get(A[0][0])
for i in range(N):
for j in range(M):
if i == 0 and j == 0: continue
if i: B[i][j] |= B[i - 1][j]
if j: B[i][j] |= B[i][j - 1]
if A[i][j] > 0: B[i][j] <<= 1
else: # TODO: Your code here
if i: B[i - 1] = None
print("YES" if B[-1][-1] & (1 << get(0)) else "NO")
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N, M = nextInt(), nextInt()
A = [getIntArray(M) for _ in range(N)]
if N < M:
A = [list(i) for i in zip(*A)]
N, M = M, N
def get(sum):
return sum + N + M
B = [[0] * M for i in range(N)]
B[0][0] |= 1 << get(A[0][0])
for i in range(N):
for j in range(M):
if i == 0 and j == 0: continue
if i: B[i][j] |= B[i - 1][j]
if j: B[i][j] |= B[i][j - 1]
if A[i][j] > 0: B[i][j] <<= 1
else: {{completion}}
if i: B[i - 1] = None
print("YES" if B[-1][-1] & (1 << get(0)) else "NO")
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
B[i][j] >>= 1
|
[{"input": "5\n\n1 1\n\n1\n\n1 2\n\n1 -1\n\n1 4\n\n1 -1 1 -1\n\n3 4\n\n1 -1 -1 -1\n\n-1 1 1 -1\n\n1 1 1 -1\n\n3 4\n\n1 -1 1 1\n\n-1 1 -1 1\n\n1 -1 1 1", "output": ["NO\nYES\nYES\nYES\nNO"]}]
|
block_completion_002516
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a grid with $$$n$$$ rows and $$$m$$$ columns. We denote the square on the $$$i$$$-th ($$$1\le i\le n$$$) row and $$$j$$$-th ($$$1\le j\le m$$$) column by $$$(i, j)$$$ and the number there by $$$a_{ij}$$$. All numbers are equal to $$$1$$$ or to $$$-1$$$. You start from the square $$$(1, 1)$$$ and can move one square down or one square to the right at a time. In the end, you want to end up at the square $$$(n, m)$$$.Is it possible to move in such a way so that the sum of the values written in all the visited cells (including $$$a_{11}$$$ and $$$a_{nm}$$$) is $$$0$$$?
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \leq t \leq 10^4$$$). Description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n, m \le 1000$$$) Β β the size of the grid. Each of the following $$$n$$$ lines contains $$$m$$$ integers. The $$$j$$$-th integer on the $$$i$$$-th line is $$$a_{ij}$$$ ($$$a_{ij} = 1$$$ or $$$-1$$$) Β β the element in the cell $$$(i, j)$$$. It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$10^6$$$.
Output Specification: For each test case, print "YES" if there exists a path from the top left to the bottom right that adds up to $$$0$$$, and "NO" otherwise. You can output each letter in any case.
Notes: NoteOne possible path for the fourth test case is given in the picture in the statement.
Code:
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N, M = nextInt(), nextInt()
A = [getIntArray(M) for _ in range(N)]
if N < M:
A = [list(i) for i in zip(*A)]
N, M = M, N
def get(sum):
return sum + N + M
B = [[0] * M for i in range(N)]
B[0][0] |= 1 << get(A[0][0])
for i in range(N):
for j in range(M):
if i == 0 and j == 0: # TODO: Your code here
if i: B[i][j] |= B[i - 1][j]
if j: B[i][j] |= B[i][j - 1]
if A[i][j] > 0: B[i][j] <<= 1
else: B[i][j] >>= 1
if i: B[i - 1] = None
print("YES" if B[-1][-1] & (1 << get(0)) else "NO")
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N, M = nextInt(), nextInt()
A = [getIntArray(M) for _ in range(N)]
if N < M:
A = [list(i) for i in zip(*A)]
N, M = M, N
def get(sum):
return sum + N + M
B = [[0] * M for i in range(N)]
B[0][0] |= 1 << get(A[0][0])
for i in range(N):
for j in range(M):
if i == 0 and j == 0: {{completion}}
if i: B[i][j] |= B[i - 1][j]
if j: B[i][j] |= B[i][j - 1]
if A[i][j] > 0: B[i][j] <<= 1
else: B[i][j] >>= 1
if i: B[i - 1] = None
print("YES" if B[-1][-1] & (1 << get(0)) else "NO")
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
continue
|
[{"input": "5\n\n1 1\n\n1\n\n1 2\n\n1 -1\n\n1 4\n\n1 -1 1 -1\n\n3 4\n\n1 -1 -1 -1\n\n-1 1 1 -1\n\n1 1 1 -1\n\n3 4\n\n1 -1 1 1\n\n-1 1 -1 1\n\n1 -1 1 1", "output": ["NO\nYES\nYES\nYES\nNO"]}]
|
block_completion_002517
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a grid with $$$n$$$ rows and $$$m$$$ columns. We denote the square on the $$$i$$$-th ($$$1\le i\le n$$$) row and $$$j$$$-th ($$$1\le j\le m$$$) column by $$$(i, j)$$$ and the number there by $$$a_{ij}$$$. All numbers are equal to $$$1$$$ or to $$$-1$$$. You start from the square $$$(1, 1)$$$ and can move one square down or one square to the right at a time. In the end, you want to end up at the square $$$(n, m)$$$.Is it possible to move in such a way so that the sum of the values written in all the visited cells (including $$$a_{11}$$$ and $$$a_{nm}$$$) is $$$0$$$?
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \leq t \leq 10^4$$$). Description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n, m \le 1000$$$) Β β the size of the grid. Each of the following $$$n$$$ lines contains $$$m$$$ integers. The $$$j$$$-th integer on the $$$i$$$-th line is $$$a_{ij}$$$ ($$$a_{ij} = 1$$$ or $$$-1$$$) Β β the element in the cell $$$(i, j)$$$. It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$10^6$$$.
Output Specification: For each test case, print "YES" if there exists a path from the top left to the bottom right that adds up to $$$0$$$, and "NO" otherwise. You can output each letter in any case.
Notes: NoteOne possible path for the fourth test case is given in the picture in the statement.
Code:
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N, M = nextInt(), nextInt()
A = [getIntArray(M) for i in range(N)]
if N > M:
A = [list(i) for i in zip(*A)]
N, M = M, N
def get(sum):
return sum + N + M
B = [[0] * M for i in range(N)]
B[0][0] |= 1 << get(A[0][0])
for i in range(N):
for j in range(M):
if i == 0 and j == 0: continue
if i: B[i][j] |= B[i - 1][j]
if j: B[i][j] |= B[i][j - 1]
if A[i][j] > 0: B[i][j] <<= 1
else: # TODO: Your code here
if i: B[i - 1] = None
print("YES" if B[-1][-1] & (1 << get(0)) else "NO")
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N, M = nextInt(), nextInt()
A = [getIntArray(M) for i in range(N)]
if N > M:
A = [list(i) for i in zip(*A)]
N, M = M, N
def get(sum):
return sum + N + M
B = [[0] * M for i in range(N)]
B[0][0] |= 1 << get(A[0][0])
for i in range(N):
for j in range(M):
if i == 0 and j == 0: continue
if i: B[i][j] |= B[i - 1][j]
if j: B[i][j] |= B[i][j - 1]
if A[i][j] > 0: B[i][j] <<= 1
else: {{completion}}
if i: B[i - 1] = None
print("YES" if B[-1][-1] & (1 << get(0)) else "NO")
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
B[i][j] >>= 1
|
[{"input": "5\n\n1 1\n\n1\n\n1 2\n\n1 -1\n\n1 4\n\n1 -1 1 -1\n\n3 4\n\n1 -1 -1 -1\n\n-1 1 1 -1\n\n1 1 1 -1\n\n3 4\n\n1 -1 1 1\n\n-1 1 -1 1\n\n1 -1 1 1", "output": ["NO\nYES\nYES\nYES\nNO"]}]
|
block_completion_002518
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: You are given a grid with $$$n$$$ rows and $$$m$$$ columns. We denote the square on the $$$i$$$-th ($$$1\le i\le n$$$) row and $$$j$$$-th ($$$1\le j\le m$$$) column by $$$(i, j)$$$ and the number there by $$$a_{ij}$$$. All numbers are equal to $$$1$$$ or to $$$-1$$$. You start from the square $$$(1, 1)$$$ and can move one square down or one square to the right at a time. In the end, you want to end up at the square $$$(n, m)$$$.Is it possible to move in such a way so that the sum of the values written in all the visited cells (including $$$a_{11}$$$ and $$$a_{nm}$$$) is $$$0$$$?
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \leq t \leq 10^4$$$). Description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n, m \le 1000$$$) Β β the size of the grid. Each of the following $$$n$$$ lines contains $$$m$$$ integers. The $$$j$$$-th integer on the $$$i$$$-th line is $$$a_{ij}$$$ ($$$a_{ij} = 1$$$ or $$$-1$$$) Β β the element in the cell $$$(i, j)$$$. It is guaranteed that the sum of $$$n\cdot m$$$ over all test cases does not exceed $$$10^6$$$.
Output Specification: For each test case, print "YES" if there exists a path from the top left to the bottom right that adds up to $$$0$$$, and "NO" otherwise. You can output each letter in any case.
Notes: NoteOne possible path for the fourth test case is given in the picture in the statement.
Code:
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N, M = nextInt(), nextInt()
A = [getIntArray(M) for i in range(N)]
if N > M:
A = [list(i) for i in zip(*A)]
N, M = M, N
def get(sum):
return sum + N + M
B = [[0] * M for i in range(N)]
B[0][0] |= 1 << get(A[0][0])
for i in range(N):
for j in range(M):
if i == 0 and j == 0: # TODO: Your code here
if i: B[i][j] |= B[i - 1][j]
if j: B[i][j] |= B[i][j - 1]
if A[i][j] > 0: B[i][j] <<= 1
else: B[i][j] >>= 1
if i: B[i - 1] = None
print("YES" if B[-1][-1] & (1 << get(0)) else "NO")
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N, M = nextInt(), nextInt()
A = [getIntArray(M) for i in range(N)]
if N > M:
A = [list(i) for i in zip(*A)]
N, M = M, N
def get(sum):
return sum + N + M
B = [[0] * M for i in range(N)]
B[0][0] |= 1 << get(A[0][0])
for i in range(N):
for j in range(M):
if i == 0 and j == 0: {{completion}}
if i: B[i][j] |= B[i - 1][j]
if j: B[i][j] |= B[i][j - 1]
if A[i][j] > 0: B[i][j] <<= 1
else: B[i][j] >>= 1
if i: B[i - 1] = None
print("YES" if B[-1][-1] & (1 << get(0)) else "NO")
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
continue
|
[{"input": "5\n\n1 1\n\n1\n\n1 2\n\n1 -1\n\n1 4\n\n1 -1 1 -1\n\n3 4\n\n1 -1 -1 -1\n\n-1 1 1 -1\n\n1 1 1 -1\n\n3 4\n\n1 -1 1 1\n\n-1 1 -1 1\n\n1 -1 1 1", "output": ["NO\nYES\nYES\nYES\nNO"]}]
|
block_completion_002519
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Michael and Joe are playing a game. The game is played on a grid with $$$n$$$ rows and $$$m$$$ columns, filled with distinct integers. We denote the square on the $$$i$$$-th ($$$1\le i\le n$$$) row and $$$j$$$-th ($$$1\le j\le m$$$) column by $$$(i, j)$$$ and the number there by $$$a_{ij}$$$.Michael starts by saying two numbers $$$h$$$ ($$$1\le h \le n$$$) and $$$w$$$ ($$$1\le w \le m$$$). Then Joe picks any $$$h\times w$$$ subrectangle of the board (without Michael seeing).Formally, an $$$h\times w$$$ subrectangle starts at some square $$$(a,b)$$$ where $$$1 \le a \le n-h+1$$$ and $$$1 \le b \le m-w+1$$$. It contains all squares $$$(i,j)$$$ for $$$a \le i \le a+h-1$$$ and $$$b \le j \le b+w-1$$$. Possible move by Joe if Michael says $$$3\times 2$$$ (with maximum of $$$15$$$). Finally, Michael has to guess the maximum number in the subrectangle. He wins if he gets it right.Because Michael doesn't like big numbers, he wants the area of the chosen subrectangle (that is, $$$h \cdot w$$$), to be as small as possible, while still ensuring that he wins, not depending on Joe's choice. Help Michael out by finding this minimum possible area. It can be shown that Michael can always choose $$$h, w$$$ for which he can ensure that he wins.
Input Specification: Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \le t \le 20$$$). Description of the test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$1 \le n, m \le 40$$$) Β β the size of the grid. Each of the following $$$n$$$ lines contains $$$m$$$ integers. The $$$j$$$-th integer on the $$$i$$$-th line is $$$a_{ij}$$$ ($$$-10^9 \le a_{ij} \le 10^9$$$) Β β the element in the cell $$$(i, j)$$$. It is guaranteed that all the numbers are distinct (that is, if $$$a_{i_1j_1} = a_{i_2j_2}$$$, then $$$i_1 = i_2, j_1 = j_2$$$).
Output Specification: For each test case print a single positive integer Β β the minimum possible area the subrectangle can have while still ensuring that Michael can guarantee the victory.
Notes: NoteIn the first test case, the grid is $$$1\times 1$$$, so the only possible choice for $$$h, w$$$ is $$$h = 1, w = 1$$$, giving an area of $$$h\cdot w = 1$$$.The grid from the second test case is drawn in the statement. It can be shown that with $$$h = 3, w = 3$$$ Michael can guarantee the victory and that any choice with $$$h\cdot w \le 8$$$ doesn't.
Code:
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N, M = nextInt(), nextInt()
A = [getIntArray(M) for i in range(N)]
X = Y = 0
for i in range(N):
for j in range(M):
if A[i][j] > A[X][Y]:
# TODO: Your code here
height = max(N - X, X + 1)
width = max(M - Y, Y + 1)
print(height * width)
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
import sys
tokens = ''.join(sys.stdin.readlines()).split()[::-1]
def next(): return tokens.pop()
def nextInt(): return int(next())
def nextFloat(): return float(next())
def getIntArray(n): return [nextInt() for _ in range(n)]
def getFloatArray(n): return [nextFloat() for _ in range(n)]
def getStringArray(n): return [next() for _ in range(n)]
testcase = True
def solve(testcase = 1):
N, M = nextInt(), nextInt()
A = [getIntArray(M) for i in range(N)]
X = Y = 0
for i in range(N):
for j in range(M):
if A[i][j] > A[X][Y]:
{{completion}}
height = max(N - X, X + 1)
width = max(M - Y, Y + 1)
print(height * width)
pass
if testcase is None:
testcaseCount = 1
while tokens:
solve(testcaseCount)
testcaseCount += 1
else:
testcaseCount = nextInt() if testcase else 1
for tc in range(testcaseCount):
solve(tc + 1)
assert not tokens
|
X, Y = i, j
|
[{"input": "3\n\n1 1\n\n3\n\n4 4\n\n2 12 6 10\n\n3 15 16 4\n\n1 13 8 11\n\n14 7 9 5\n\n2 3\n\n-7 5 2\n\n0 8 -3", "output": ["1\n9\n4"]}]
|
block_completion_002537
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: AquaMoon has two binary sequences $$$a$$$ and $$$b$$$, which contain only $$$0$$$ and $$$1$$$. AquaMoon can perform the following two operations any number of times ($$$a_1$$$ is the first element of $$$a$$$, $$$a_2$$$ is the second element of $$$a$$$, and so on): Operation 1: if $$$a$$$ contains at least two elements, change $$$a_2$$$ to $$$\operatorname{min}(a_1,a_2)$$$, and remove the first element of $$$a$$$. Operation 2: if $$$a$$$ contains at least two elements, change $$$a_2$$$ to $$$\operatorname{max}(a_1,a_2)$$$, and remove the first element of $$$a$$$.Note that after a removal of the first element of $$$a$$$, the former $$$a_2$$$ becomes the first element of $$$a$$$, the former $$$a_3$$$ becomes the second element of $$$a$$$ and so on, and the length of $$$a$$$ reduces by one.Determine if AquaMoon can make $$$a$$$ equal to $$$b$$$ by using these operations.
Input Specification: The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 2\,000$$$) β the number of test cases. Description of test cases follows. The first line of each test case contains two integers $$$n$$$, $$$m$$$ ($$$1 \leq n,m \leq 50$$$, $$$m \leq n$$$) β the lengths of $$$a$$$ and $$$b$$$ respectively. The second line of each test case contains a string $$$a$$$ of length $$$n$$$, consisting only $$$0$$$ and $$$1$$$. The third line of each test case contains a string $$$b$$$ of length $$$m$$$, consisting only $$$0$$$ and $$$1$$$.
Output Specification: For each test case, output "YES" if AquaMoon can change $$$a$$$ to $$$b$$$ by using these options; otherwise, output "NO". You may print each letter in any case (for example, "YES", "Yes", "yes", "yEs" will all be recognized as a positive answer).
Notes: NoteIn the first test case, you can use Operation 2 four times to make $$$a$$$ equals to $$$b$$$.In the second test case, you can use Operation 1 four times to make $$$a$$$ equals to $$$b$$$.In the third test case, it can be proved that no matter how we use the operations, it is impossible to make $$$a$$$ equal to $$$b$$$.In the fourth test case, it can be proved that no matter how we use the operations, it is impossible to make $$$a$$$ equal to $$$b$$$.In the fifth test case, you can use Operation 2 three times to make $$$a$$$ become $$$10101$$$, so the first element of $$$a$$$ equals to the first element of $$$b$$$, but it can be proved that no matter how to operate, the second to the fifth elements of $$$a$$$ can't be the same as $$$b$$$.
Code:
import sys
def _input_iter():
for line in sys.stdin:
for part in line.strip().split(' '):
stripped = part.strip()
if stripped:
# TODO: Your code here
def read_int():
return int(next(stream))
def read_str():
return next(stream)
def get_ans(a, b):
if len(a) < len(b):
return False
if len(a) == len(b):
return a == b
if len(b) == 1:
return b in a
if a[-len(b) + 1:] != b[1:]:
return False
return b[0] in a[:len(a) - len(b) + 1]
def run():
read_int(), read_int()
a, b = read_str(), read_str()
print('YES' if get_ans(a, b) else 'NO')
stream = _input_iter()
def main():
t = read_int()
for _ in range(t):
run()
if __name__ == '__main__':
main()
|
import sys
def _input_iter():
for line in sys.stdin:
for part in line.strip().split(' '):
stripped = part.strip()
if stripped:
{{completion}}
def read_int():
return int(next(stream))
def read_str():
return next(stream)
def get_ans(a, b):
if len(a) < len(b):
return False
if len(a) == len(b):
return a == b
if len(b) == 1:
return b in a
if a[-len(b) + 1:] != b[1:]:
return False
return b[0] in a[:len(a) - len(b) + 1]
def run():
read_int(), read_int()
a, b = read_str(), read_str()
print('YES' if get_ans(a, b) else 'NO')
stream = _input_iter()
def main():
t = read_int()
for _ in range(t):
run()
if __name__ == '__main__':
main()
|
yield stripped
|
[{"input": "10\n\n6 2\n\n001001\n\n11\n\n6 2\n\n110111\n\n01\n\n6 2\n\n000001\n\n11\n\n6 2\n\n111111\n\n01\n\n8 5\n\n10000101\n\n11010\n\n7 4\n\n1010001\n\n1001\n\n8 6\n\n01010010\n\n010010\n\n8 4\n\n01010101\n\n1001\n\n8 4\n\n10101010\n\n0110\n\n7 5\n\n1011100\n\n11100", "output": ["YES\nYES\nNO\nNO\nNO\nYES\nYES\nNO\nNO\nYES"]}]
|
block_completion_002625
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Eric has an array $$$b$$$ of length $$$m$$$, then he generates $$$n$$$ additional arrays $$$c_1, c_2, \dots, c_n$$$, each of length $$$m$$$, from the array $$$b$$$, by the following way:Initially, $$$c_i = b$$$ for every $$$1 \le i \le n$$$. Eric secretly chooses an integer $$$k$$$ $$$(1 \le k \le n)$$$ and chooses $$$c_k$$$ to be the special array.There are two operations that Eric can perform on an array $$$c_t$$$: Operation 1: Choose two integers $$$i$$$ and $$$j$$$ ($$$2 \leq i < j \leq m-1$$$), subtract $$$1$$$ from both $$$c_t[i]$$$ and $$$c_t[j]$$$, and add $$$1$$$ to both $$$c_t[i-1]$$$ and $$$c_t[j+1]$$$. That operation can only be used on a non-special array, that is when $$$t \neq k$$$.; Operation 2: Choose two integers $$$i$$$ and $$$j$$$ ($$$2 \leq i < j \leq m-2$$$), subtract $$$1$$$ from both $$$c_t[i]$$$ and $$$c_t[j]$$$, and add $$$1$$$ to both $$$c_t[i-1]$$$ and $$$c_t[j+2]$$$. That operation can only be used on a special array, that is when $$$t = k$$$.Note that Eric can't perform an operation if any element of the array will become less than $$$0$$$ after that operation.Now, Eric does the following: For every non-special array $$$c_i$$$ ($$$i \neq k$$$), Eric uses only operation 1 on it at least once. For the special array $$$c_k$$$, Eric uses only operation 2 on it at least once.Lastly, Eric discards the array $$$b$$$.For given arrays $$$c_1, c_2, \dots, c_n$$$, your task is to find out the special array, i.e. the value $$$k$$$. Also, you need to find the number of times of operation $$$2$$$ was used on it.
Input Specification: The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^4$$$) β the number of test cases. Description of test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$3 \leq n \leq 10^5$$$, $$$7 \leq m \leq 3 \cdot 10^5$$$) β the number of arrays given to you, and the length of each array. The next $$$n$$$ lines contains $$$m$$$ integers each, $$$c_{i,1}, c_{i,2}, \dots , c_{i,m}$$$. It is guaranteed that each element of the discarded array $$$b$$$ is in the range $$$[0,10^6]$$$, and therefore $$$0 \leq c_{i,j} \leq 3 \cdot 10^{11}$$$ for all possible pairs of $$$(i,j)$$$. It is guaranteed that the sum of $$$n \cdot m$$$ over all test cases does not exceed $$$10^6$$$. It is guaranteed that the input is generated according to the procedure above.
Output Specification: For each test case, output one line containing two integers β the index of the special array, and the number of times that Operation 2 was performed on it. It can be shown that under the constraints given in the problem, this value is unique and won't exceed $$$10^{18}$$$, so you can represent it as a $$$64$$$-bit integer. It can also be shown that the index of the special array is uniquely determined. In this problem, hacks are disabled.
Notes: NoteIn the first test case, the secret array $$$b$$$ is $$$[0, 1, 1, 1, 1, 1, 1, 1, 0]$$$. Array $$$c_1$$$ and array $$$c_2$$$ are generated by using operation 1. Array $$$c_3$$$ is generated by using operation 2.For Array $$$c_1$$$,you can choose $$$i=4$$$ and $$$j=5$$$ perform Operation 1 one time to generate it. For Array $$$c_2$$$, you can choose $$$i=6$$$ and $$$j=7$$$ perform Operation 1 one time to generate it. For Array $$$c_3$$$,you can choose $$$i=4$$$ and $$$j=5$$$ perform Operation 2 one time to generate it.In the second test case, the secret array $$$b$$$ is $$$[20, 20, 20, 20, 20, 20, 20]$$$. You can also find that array $$$c_1$$$ and array $$$c_2$$$ are generated by using Operation 1. Array $$$c_3$$$ is generated by using Operation 2.In the third test case, the secret array $$$b$$$ is $$$[20, 20, 20, 20, 20, 20, 20, 20, 20]$$$. You can also find that array $$$c_1$$$ and array $$$c_2$$$ are generated by using Operation 1. Array $$$c_3$$$ is generated by using Operation 2.
Code:
R=lambda:map(int,input().split());G=range;t,=R()
for _ in G(t):
# TODO: Your code here
|
R=lambda:map(int,input().split());G=range;t,=R()
for _ in G(t):
{{completion}}
|
n,m=R();s=[sum(i*v for i,v in enumerate(R()))for _ in G(n)]
mx=max(s);print(s.index(mx)+1,mx-min(s))
|
[{"input": "7\n3 9\n0 1 2 0 0 2 1 1 0\n0 1 1 1 2 0 0 2 0\n0 1 2 0 0 1 2 1 0\n3 7\n25 15 20 15 25 20 20\n26 14 20 14 26 20 20\n25 15 20 15 20 20 25\n3 9\n25 15 20 15 25 20 20 20 20\n26 14 20 14 26 20 20 20 20\n25 15 20 15 25 15 20 20 25\n3 11\n25 15 20 15 25 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20\n25 15 20 15 25 20 15 20 20 20 25\n3 13\n25 15 20 15 25 20 20 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20 20 20\n25 15 20 15 25 20 20 15 20 20 20 20 25\n3 15\n25 15 20 15 25 20 20 20 20 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20 20 20 20 20\n25 15 20 15 25 20 20 20 15 20 20 20 20 20 25\n3 9\n909459 479492 676924 224197 162866 164495 193268 742456 728277\n948845 455424 731850 327890 304150 237351 251763 225845 798316\n975446 401170 792914 272263 300770 242037 236619 334316 725899", "output": ["3 1\n3 10\n3 15\n3 20\n3 25\n3 30\n1 1378716"]}]
|
block_completion_002627
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Eric has an array $$$b$$$ of length $$$m$$$, then he generates $$$n$$$ additional arrays $$$c_1, c_2, \dots, c_n$$$, each of length $$$m$$$, from the array $$$b$$$, by the following way:Initially, $$$c_i = b$$$ for every $$$1 \le i \le n$$$. Eric secretly chooses an integer $$$k$$$ $$$(1 \le k \le n)$$$ and chooses $$$c_k$$$ to be the special array.There are two operations that Eric can perform on an array $$$c_t$$$: Operation 1: Choose two integers $$$i$$$ and $$$j$$$ ($$$2 \leq i < j \leq m-1$$$), subtract $$$1$$$ from both $$$c_t[i]$$$ and $$$c_t[j]$$$, and add $$$1$$$ to both $$$c_t[i-1]$$$ and $$$c_t[j+1]$$$. That operation can only be used on a non-special array, that is when $$$t \neq k$$$.; Operation 2: Choose two integers $$$i$$$ and $$$j$$$ ($$$2 \leq i < j \leq m-2$$$), subtract $$$1$$$ from both $$$c_t[i]$$$ and $$$c_t[j]$$$, and add $$$1$$$ to both $$$c_t[i-1]$$$ and $$$c_t[j+2]$$$. That operation can only be used on a special array, that is when $$$t = k$$$.Note that Eric can't perform an operation if any element of the array will become less than $$$0$$$ after that operation.Now, Eric does the following: For every non-special array $$$c_i$$$ ($$$i \neq k$$$), Eric uses only operation 1 on it at least once. For the special array $$$c_k$$$, Eric uses only operation 2 on it at least once.Lastly, Eric discards the array $$$b$$$.For given arrays $$$c_1, c_2, \dots, c_n$$$, your task is to find out the special array, i.e. the value $$$k$$$. Also, you need to find the number of times of operation $$$2$$$ was used on it.
Input Specification: The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^4$$$) β the number of test cases. Description of test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$3 \leq n \leq 10^5$$$, $$$7 \leq m \leq 3 \cdot 10^5$$$) β the number of arrays given to you, and the length of each array. The next $$$n$$$ lines contains $$$m$$$ integers each, $$$c_{i,1}, c_{i,2}, \dots , c_{i,m}$$$. It is guaranteed that each element of the discarded array $$$b$$$ is in the range $$$[0,10^6]$$$, and therefore $$$0 \leq c_{i,j} \leq 3 \cdot 10^{11}$$$ for all possible pairs of $$$(i,j)$$$. It is guaranteed that the sum of $$$n \cdot m$$$ over all test cases does not exceed $$$10^6$$$. It is guaranteed that the input is generated according to the procedure above.
Output Specification: For each test case, output one line containing two integers β the index of the special array, and the number of times that Operation 2 was performed on it. It can be shown that under the constraints given in the problem, this value is unique and won't exceed $$$10^{18}$$$, so you can represent it as a $$$64$$$-bit integer. It can also be shown that the index of the special array is uniquely determined. In this problem, hacks are disabled.
Notes: NoteIn the first test case, the secret array $$$b$$$ is $$$[0, 1, 1, 1, 1, 1, 1, 1, 0]$$$. Array $$$c_1$$$ and array $$$c_2$$$ are generated by using operation 1. Array $$$c_3$$$ is generated by using operation 2.For Array $$$c_1$$$,you can choose $$$i=4$$$ and $$$j=5$$$ perform Operation 1 one time to generate it. For Array $$$c_2$$$, you can choose $$$i=6$$$ and $$$j=7$$$ perform Operation 1 one time to generate it. For Array $$$c_3$$$,you can choose $$$i=4$$$ and $$$j=5$$$ perform Operation 2 one time to generate it.In the second test case, the secret array $$$b$$$ is $$$[20, 20, 20, 20, 20, 20, 20]$$$. You can also find that array $$$c_1$$$ and array $$$c_2$$$ are generated by using Operation 1. Array $$$c_3$$$ is generated by using Operation 2.In the third test case, the secret array $$$b$$$ is $$$[20, 20, 20, 20, 20, 20, 20, 20, 20]$$$. You can also find that array $$$c_1$$$ and array $$$c_2$$$ are generated by using Operation 1. Array $$$c_3$$$ is generated by using Operation 2.
Code:
for _ in range(int(input())):
n, m = map(int, input().split())
vals = []
for _ in range(n):
count = 0
for a, b in enumerate(map(int, input().split())):
# TODO: Your code here
vals.append(count)
c = vals.index(max(vals))
print(c + 1, vals[c] - vals[c-1])
|
for _ in range(int(input())):
n, m = map(int, input().split())
vals = []
for _ in range(n):
count = 0
for a, b in enumerate(map(int, input().split())):
{{completion}}
vals.append(count)
c = vals.index(max(vals))
print(c + 1, vals[c] - vals[c-1])
|
count += a*b
|
[{"input": "7\n3 9\n0 1 2 0 0 2 1 1 0\n0 1 1 1 2 0 0 2 0\n0 1 2 0 0 1 2 1 0\n3 7\n25 15 20 15 25 20 20\n26 14 20 14 26 20 20\n25 15 20 15 20 20 25\n3 9\n25 15 20 15 25 20 20 20 20\n26 14 20 14 26 20 20 20 20\n25 15 20 15 25 15 20 20 25\n3 11\n25 15 20 15 25 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20\n25 15 20 15 25 20 15 20 20 20 25\n3 13\n25 15 20 15 25 20 20 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20 20 20\n25 15 20 15 25 20 20 15 20 20 20 20 25\n3 15\n25 15 20 15 25 20 20 20 20 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20 20 20 20 20\n25 15 20 15 25 20 20 20 15 20 20 20 20 20 25\n3 9\n909459 479492 676924 224197 162866 164495 193268 742456 728277\n948845 455424 731850 327890 304150 237351 251763 225845 798316\n975446 401170 792914 272263 300770 242037 236619 334316 725899", "output": ["3 1\n3 10\n3 15\n3 20\n3 25\n3 30\n1 1378716"]}]
|
block_completion_002628
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Eric has an array $$$b$$$ of length $$$m$$$, then he generates $$$n$$$ additional arrays $$$c_1, c_2, \dots, c_n$$$, each of length $$$m$$$, from the array $$$b$$$, by the following way:Initially, $$$c_i = b$$$ for every $$$1 \le i \le n$$$. Eric secretly chooses an integer $$$k$$$ $$$(1 \le k \le n)$$$ and chooses $$$c_k$$$ to be the special array.There are two operations that Eric can perform on an array $$$c_t$$$: Operation 1: Choose two integers $$$i$$$ and $$$j$$$ ($$$2 \leq i < j \leq m-1$$$), subtract $$$1$$$ from both $$$c_t[i]$$$ and $$$c_t[j]$$$, and add $$$1$$$ to both $$$c_t[i-1]$$$ and $$$c_t[j+1]$$$. That operation can only be used on a non-special array, that is when $$$t \neq k$$$.; Operation 2: Choose two integers $$$i$$$ and $$$j$$$ ($$$2 \leq i < j \leq m-2$$$), subtract $$$1$$$ from both $$$c_t[i]$$$ and $$$c_t[j]$$$, and add $$$1$$$ to both $$$c_t[i-1]$$$ and $$$c_t[j+2]$$$. That operation can only be used on a special array, that is when $$$t = k$$$.Note that Eric can't perform an operation if any element of the array will become less than $$$0$$$ after that operation.Now, Eric does the following: For every non-special array $$$c_i$$$ ($$$i \neq k$$$), Eric uses only operation 1 on it at least once. For the special array $$$c_k$$$, Eric uses only operation 2 on it at least once.Lastly, Eric discards the array $$$b$$$.For given arrays $$$c_1, c_2, \dots, c_n$$$, your task is to find out the special array, i.e. the value $$$k$$$. Also, you need to find the number of times of operation $$$2$$$ was used on it.
Input Specification: The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^4$$$) β the number of test cases. Description of test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$3 \leq n \leq 10^5$$$, $$$7 \leq m \leq 3 \cdot 10^5$$$) β the number of arrays given to you, and the length of each array. The next $$$n$$$ lines contains $$$m$$$ integers each, $$$c_{i,1}, c_{i,2}, \dots , c_{i,m}$$$. It is guaranteed that each element of the discarded array $$$b$$$ is in the range $$$[0,10^6]$$$, and therefore $$$0 \leq c_{i,j} \leq 3 \cdot 10^{11}$$$ for all possible pairs of $$$(i,j)$$$. It is guaranteed that the sum of $$$n \cdot m$$$ over all test cases does not exceed $$$10^6$$$. It is guaranteed that the input is generated according to the procedure above.
Output Specification: For each test case, output one line containing two integers β the index of the special array, and the number of times that Operation 2 was performed on it. It can be shown that under the constraints given in the problem, this value is unique and won't exceed $$$10^{18}$$$, so you can represent it as a $$$64$$$-bit integer. It can also be shown that the index of the special array is uniquely determined. In this problem, hacks are disabled.
Notes: NoteIn the first test case, the secret array $$$b$$$ is $$$[0, 1, 1, 1, 1, 1, 1, 1, 0]$$$. Array $$$c_1$$$ and array $$$c_2$$$ are generated by using operation 1. Array $$$c_3$$$ is generated by using operation 2.For Array $$$c_1$$$,you can choose $$$i=4$$$ and $$$j=5$$$ perform Operation 1 one time to generate it. For Array $$$c_2$$$, you can choose $$$i=6$$$ and $$$j=7$$$ perform Operation 1 one time to generate it. For Array $$$c_3$$$,you can choose $$$i=4$$$ and $$$j=5$$$ perform Operation 2 one time to generate it.In the second test case, the secret array $$$b$$$ is $$$[20, 20, 20, 20, 20, 20, 20]$$$. You can also find that array $$$c_1$$$ and array $$$c_2$$$ are generated by using Operation 1. Array $$$c_3$$$ is generated by using Operation 2.In the third test case, the secret array $$$b$$$ is $$$[20, 20, 20, 20, 20, 20, 20, 20, 20]$$$. You can also find that array $$$c_1$$$ and array $$$c_2$$$ are generated by using Operation 1. Array $$$c_3$$$ is generated by using Operation 2.
Code:
case=int(input())
for i in range(case):
n,m = (int(v) for v in input().split())
tmp=0
for j in range(n):
list1 = [int(v) for v in input().split()]
value = 0
for k in range(m):
value += list1[k]*(k+1)
if j==0:
tmp = value
else:
if value > tmp:
print(str(j+1)+" "+str(value-tmp))
elif value < tmp:
# TODO: Your code here
else:
pass
|
case=int(input())
for i in range(case):
n,m = (int(v) for v in input().split())
tmp=0
for j in range(n):
list1 = [int(v) for v in input().split()]
value = 0
for k in range(m):
value += list1[k]*(k+1)
if j==0:
tmp = value
else:
if value > tmp:
print(str(j+1)+" "+str(value-tmp))
elif value < tmp:
{{completion}}
else:
pass
|
print("1 "+str(tmp-value))
tmp = value
|
[{"input": "7\n3 9\n0 1 2 0 0 2 1 1 0\n0 1 1 1 2 0 0 2 0\n0 1 2 0 0 1 2 1 0\n3 7\n25 15 20 15 25 20 20\n26 14 20 14 26 20 20\n25 15 20 15 20 20 25\n3 9\n25 15 20 15 25 20 20 20 20\n26 14 20 14 26 20 20 20 20\n25 15 20 15 25 15 20 20 25\n3 11\n25 15 20 15 25 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20\n25 15 20 15 25 20 15 20 20 20 25\n3 13\n25 15 20 15 25 20 20 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20 20 20\n25 15 20 15 25 20 20 15 20 20 20 20 25\n3 15\n25 15 20 15 25 20 20 20 20 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20 20 20 20 20\n25 15 20 15 25 20 20 20 15 20 20 20 20 20 25\n3 9\n909459 479492 676924 224197 162866 164495 193268 742456 728277\n948845 455424 731850 327890 304150 237351 251763 225845 798316\n975446 401170 792914 272263 300770 242037 236619 334316 725899", "output": ["3 1\n3 10\n3 15\n3 20\n3 25\n3 30\n1 1378716"]}]
|
block_completion_002629
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Eric has an array $$$b$$$ of length $$$m$$$, then he generates $$$n$$$ additional arrays $$$c_1, c_2, \dots, c_n$$$, each of length $$$m$$$, from the array $$$b$$$, by the following way:Initially, $$$c_i = b$$$ for every $$$1 \le i \le n$$$. Eric secretly chooses an integer $$$k$$$ $$$(1 \le k \le n)$$$ and chooses $$$c_k$$$ to be the special array.There are two operations that Eric can perform on an array $$$c_t$$$: Operation 1: Choose two integers $$$i$$$ and $$$j$$$ ($$$2 \leq i < j \leq m-1$$$), subtract $$$1$$$ from both $$$c_t[i]$$$ and $$$c_t[j]$$$, and add $$$1$$$ to both $$$c_t[i-1]$$$ and $$$c_t[j+1]$$$. That operation can only be used on a non-special array, that is when $$$t \neq k$$$.; Operation 2: Choose two integers $$$i$$$ and $$$j$$$ ($$$2 \leq i < j \leq m-2$$$), subtract $$$1$$$ from both $$$c_t[i]$$$ and $$$c_t[j]$$$, and add $$$1$$$ to both $$$c_t[i-1]$$$ and $$$c_t[j+2]$$$. That operation can only be used on a special array, that is when $$$t = k$$$.Note that Eric can't perform an operation if any element of the array will become less than $$$0$$$ after that operation.Now, Eric does the following: For every non-special array $$$c_i$$$ ($$$i \neq k$$$), Eric uses only operation 1 on it at least once. For the special array $$$c_k$$$, Eric uses only operation 2 on it at least once.Lastly, Eric discards the array $$$b$$$.For given arrays $$$c_1, c_2, \dots, c_n$$$, your task is to find out the special array, i.e. the value $$$k$$$. Also, you need to find the number of times of operation $$$2$$$ was used on it.
Input Specification: The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^4$$$) β the number of test cases. Description of test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$3 \leq n \leq 10^5$$$, $$$7 \leq m \leq 3 \cdot 10^5$$$) β the number of arrays given to you, and the length of each array. The next $$$n$$$ lines contains $$$m$$$ integers each, $$$c_{i,1}, c_{i,2}, \dots , c_{i,m}$$$. It is guaranteed that each element of the discarded array $$$b$$$ is in the range $$$[0,10^6]$$$, and therefore $$$0 \leq c_{i,j} \leq 3 \cdot 10^{11}$$$ for all possible pairs of $$$(i,j)$$$. It is guaranteed that the sum of $$$n \cdot m$$$ over all test cases does not exceed $$$10^6$$$. It is guaranteed that the input is generated according to the procedure above.
Output Specification: For each test case, output one line containing two integers β the index of the special array, and the number of times that Operation 2 was performed on it. It can be shown that under the constraints given in the problem, this value is unique and won't exceed $$$10^{18}$$$, so you can represent it as a $$$64$$$-bit integer. It can also be shown that the index of the special array is uniquely determined. In this problem, hacks are disabled.
Notes: NoteIn the first test case, the secret array $$$b$$$ is $$$[0, 1, 1, 1, 1, 1, 1, 1, 0]$$$. Array $$$c_1$$$ and array $$$c_2$$$ are generated by using operation 1. Array $$$c_3$$$ is generated by using operation 2.For Array $$$c_1$$$,you can choose $$$i=4$$$ and $$$j=5$$$ perform Operation 1 one time to generate it. For Array $$$c_2$$$, you can choose $$$i=6$$$ and $$$j=7$$$ perform Operation 1 one time to generate it. For Array $$$c_3$$$,you can choose $$$i=4$$$ and $$$j=5$$$ perform Operation 2 one time to generate it.In the second test case, the secret array $$$b$$$ is $$$[20, 20, 20, 20, 20, 20, 20]$$$. You can also find that array $$$c_1$$$ and array $$$c_2$$$ are generated by using Operation 1. Array $$$c_3$$$ is generated by using Operation 2.In the third test case, the secret array $$$b$$$ is $$$[20, 20, 20, 20, 20, 20, 20, 20, 20]$$$. You can also find that array $$$c_1$$$ and array $$$c_2$$$ are generated by using Operation 1. Array $$$c_3$$$ is generated by using Operation 2.
Code:
case=int(input())
for i in range(case):
n,m = (int(v) for v in input().split())
tmp=0
for j in range(n):
list1 = [int(v) for v in input().split()]
value = 0
for k in range(m):
value += list1[k]*(k+1)
if j==0:
tmp = value
else:
if value > tmp:
print(str(j+1)+" "+str(value-tmp))
elif value < tmp:
print("1 "+str(tmp-value))
tmp = value
else:
# TODO: Your code here
|
case=int(input())
for i in range(case):
n,m = (int(v) for v in input().split())
tmp=0
for j in range(n):
list1 = [int(v) for v in input().split()]
value = 0
for k in range(m):
value += list1[k]*(k+1)
if j==0:
tmp = value
else:
if value > tmp:
print(str(j+1)+" "+str(value-tmp))
elif value < tmp:
print("1 "+str(tmp-value))
tmp = value
else:
{{completion}}
|
pass
|
[{"input": "7\n3 9\n0 1 2 0 0 2 1 1 0\n0 1 1 1 2 0 0 2 0\n0 1 2 0 0 1 2 1 0\n3 7\n25 15 20 15 25 20 20\n26 14 20 14 26 20 20\n25 15 20 15 20 20 25\n3 9\n25 15 20 15 25 20 20 20 20\n26 14 20 14 26 20 20 20 20\n25 15 20 15 25 15 20 20 25\n3 11\n25 15 20 15 25 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20\n25 15 20 15 25 20 15 20 20 20 25\n3 13\n25 15 20 15 25 20 20 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20 20 20\n25 15 20 15 25 20 20 15 20 20 20 20 25\n3 15\n25 15 20 15 25 20 20 20 20 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20 20 20 20 20\n25 15 20 15 25 20 20 20 15 20 20 20 20 20 25\n3 9\n909459 479492 676924 224197 162866 164495 193268 742456 728277\n948845 455424 731850 327890 304150 237351 251763 225845 798316\n975446 401170 792914 272263 300770 242037 236619 334316 725899", "output": ["3 1\n3 10\n3 15\n3 20\n3 25\n3 30\n1 1378716"]}]
|
block_completion_002630
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Eric has an array $$$b$$$ of length $$$m$$$, then he generates $$$n$$$ additional arrays $$$c_1, c_2, \dots, c_n$$$, each of length $$$m$$$, from the array $$$b$$$, by the following way:Initially, $$$c_i = b$$$ for every $$$1 \le i \le n$$$. Eric secretly chooses an integer $$$k$$$ $$$(1 \le k \le n)$$$ and chooses $$$c_k$$$ to be the special array.There are two operations that Eric can perform on an array $$$c_t$$$: Operation 1: Choose two integers $$$i$$$ and $$$j$$$ ($$$2 \leq i < j \leq m-1$$$), subtract $$$1$$$ from both $$$c_t[i]$$$ and $$$c_t[j]$$$, and add $$$1$$$ to both $$$c_t[i-1]$$$ and $$$c_t[j+1]$$$. That operation can only be used on a non-special array, that is when $$$t \neq k$$$.; Operation 2: Choose two integers $$$i$$$ and $$$j$$$ ($$$2 \leq i < j \leq m-2$$$), subtract $$$1$$$ from both $$$c_t[i]$$$ and $$$c_t[j]$$$, and add $$$1$$$ to both $$$c_t[i-1]$$$ and $$$c_t[j+2]$$$. That operation can only be used on a special array, that is when $$$t = k$$$.Note that Eric can't perform an operation if any element of the array will become less than $$$0$$$ after that operation.Now, Eric does the following: For every non-special array $$$c_i$$$ ($$$i \neq k$$$), Eric uses only operation 1 on it at least once. For the special array $$$c_k$$$, Eric uses only operation 2 on it at least once.Lastly, Eric discards the array $$$b$$$.For given arrays $$$c_1, c_2, \dots, c_n$$$, your task is to find out the special array, i.e. the value $$$k$$$. Also, you need to find the number of times of operation $$$2$$$ was used on it.
Input Specification: The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^4$$$) β the number of test cases. Description of test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$3 \leq n \leq 10^5$$$, $$$7 \leq m \leq 3 \cdot 10^5$$$) β the number of arrays given to you, and the length of each array. The next $$$n$$$ lines contains $$$m$$$ integers each, $$$c_{i,1}, c_{i,2}, \dots , c_{i,m}$$$. It is guaranteed that each element of the discarded array $$$b$$$ is in the range $$$[0,10^6]$$$, and therefore $$$0 \leq c_{i,j} \leq 3 \cdot 10^{11}$$$ for all possible pairs of $$$(i,j)$$$. It is guaranteed that the sum of $$$n \cdot m$$$ over all test cases does not exceed $$$10^6$$$. It is guaranteed that the input is generated according to the procedure above.
Output Specification: For each test case, output one line containing two integers β the index of the special array, and the number of times that Operation 2 was performed on it. It can be shown that under the constraints given in the problem, this value is unique and won't exceed $$$10^{18}$$$, so you can represent it as a $$$64$$$-bit integer. It can also be shown that the index of the special array is uniquely determined. In this problem, hacks are disabled.
Notes: NoteIn the first test case, the secret array $$$b$$$ is $$$[0, 1, 1, 1, 1, 1, 1, 1, 0]$$$. Array $$$c_1$$$ and array $$$c_2$$$ are generated by using operation 1. Array $$$c_3$$$ is generated by using operation 2.For Array $$$c_1$$$,you can choose $$$i=4$$$ and $$$j=5$$$ perform Operation 1 one time to generate it. For Array $$$c_2$$$, you can choose $$$i=6$$$ and $$$j=7$$$ perform Operation 1 one time to generate it. For Array $$$c_3$$$,you can choose $$$i=4$$$ and $$$j=5$$$ perform Operation 2 one time to generate it.In the second test case, the secret array $$$b$$$ is $$$[20, 20, 20, 20, 20, 20, 20]$$$. You can also find that array $$$c_1$$$ and array $$$c_2$$$ are generated by using Operation 1. Array $$$c_3$$$ is generated by using Operation 2.In the third test case, the secret array $$$b$$$ is $$$[20, 20, 20, 20, 20, 20, 20, 20, 20]$$$. You can also find that array $$$c_1$$$ and array $$$c_2$$$ are generated by using Operation 1. Array $$$c_3$$$ is generated by using Operation 2.
Code:
input = __import__('sys').stdin.readline
def solve():
n, m = map(int, input().split())
mx = (0, -1)
mn = (10**18, -1)
for i in range(n):
current, total = 0, 0
for x in map(int, input().split()):
# TODO: Your code here
mx = max(mx, (total, i))
mn = min(mn, (total, i))
print(mn[1]+1, mx[0] - mn[0])
for _ in range(int(input())):
solve()
|
input = __import__('sys').stdin.readline
def solve():
n, m = map(int, input().split())
mx = (0, -1)
mn = (10**18, -1)
for i in range(n):
current, total = 0, 0
for x in map(int, input().split()):
{{completion}}
mx = max(mx, (total, i))
mn = min(mn, (total, i))
print(mn[1]+1, mx[0] - mn[0])
for _ in range(int(input())):
solve()
|
current += x
total += current
|
[{"input": "7\n3 9\n0 1 2 0 0 2 1 1 0\n0 1 1 1 2 0 0 2 0\n0 1 2 0 0 1 2 1 0\n3 7\n25 15 20 15 25 20 20\n26 14 20 14 26 20 20\n25 15 20 15 20 20 25\n3 9\n25 15 20 15 25 20 20 20 20\n26 14 20 14 26 20 20 20 20\n25 15 20 15 25 15 20 20 25\n3 11\n25 15 20 15 25 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20\n25 15 20 15 25 20 15 20 20 20 25\n3 13\n25 15 20 15 25 20 20 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20 20 20\n25 15 20 15 25 20 20 15 20 20 20 20 25\n3 15\n25 15 20 15 25 20 20 20 20 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20 20 20 20 20\n25 15 20 15 25 20 20 20 15 20 20 20 20 20 25\n3 9\n909459 479492 676924 224197 162866 164495 193268 742456 728277\n948845 455424 731850 327890 304150 237351 251763 225845 798316\n975446 401170 792914 272263 300770 242037 236619 334316 725899", "output": ["3 1\n3 10\n3 15\n3 20\n3 25\n3 30\n1 1378716"]}]
|
block_completion_002631
|
block
|
python
|
Complete the code in python to solve this programming problem:
Description: Eric has an array $$$b$$$ of length $$$m$$$, then he generates $$$n$$$ additional arrays $$$c_1, c_2, \dots, c_n$$$, each of length $$$m$$$, from the array $$$b$$$, by the following way:Initially, $$$c_i = b$$$ for every $$$1 \le i \le n$$$. Eric secretly chooses an integer $$$k$$$ $$$(1 \le k \le n)$$$ and chooses $$$c_k$$$ to be the special array.There are two operations that Eric can perform on an array $$$c_t$$$: Operation 1: Choose two integers $$$i$$$ and $$$j$$$ ($$$2 \leq i < j \leq m-1$$$), subtract $$$1$$$ from both $$$c_t[i]$$$ and $$$c_t[j]$$$, and add $$$1$$$ to both $$$c_t[i-1]$$$ and $$$c_t[j+1]$$$. That operation can only be used on a non-special array, that is when $$$t \neq k$$$.; Operation 2: Choose two integers $$$i$$$ and $$$j$$$ ($$$2 \leq i < j \leq m-2$$$), subtract $$$1$$$ from both $$$c_t[i]$$$ and $$$c_t[j]$$$, and add $$$1$$$ to both $$$c_t[i-1]$$$ and $$$c_t[j+2]$$$. That operation can only be used on a special array, that is when $$$t = k$$$.Note that Eric can't perform an operation if any element of the array will become less than $$$0$$$ after that operation.Now, Eric does the following: For every non-special array $$$c_i$$$ ($$$i \neq k$$$), Eric uses only operation 1 on it at least once. For the special array $$$c_k$$$, Eric uses only operation 2 on it at least once.Lastly, Eric discards the array $$$b$$$.For given arrays $$$c_1, c_2, \dots, c_n$$$, your task is to find out the special array, i.e. the value $$$k$$$. Also, you need to find the number of times of operation $$$2$$$ was used on it.
Input Specification: The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^4$$$) β the number of test cases. Description of test cases follows. The first line of each test case contains two integers $$$n$$$ and $$$m$$$ ($$$3 \leq n \leq 10^5$$$, $$$7 \leq m \leq 3 \cdot 10^5$$$) β the number of arrays given to you, and the length of each array. The next $$$n$$$ lines contains $$$m$$$ integers each, $$$c_{i,1}, c_{i,2}, \dots , c_{i,m}$$$. It is guaranteed that each element of the discarded array $$$b$$$ is in the range $$$[0,10^6]$$$, and therefore $$$0 \leq c_{i,j} \leq 3 \cdot 10^{11}$$$ for all possible pairs of $$$(i,j)$$$. It is guaranteed that the sum of $$$n \cdot m$$$ over all test cases does not exceed $$$10^6$$$. It is guaranteed that the input is generated according to the procedure above.
Output Specification: For each test case, output one line containing two integers β the index of the special array, and the number of times that Operation 2 was performed on it. It can be shown that under the constraints given in the problem, this value is unique and won't exceed $$$10^{18}$$$, so you can represent it as a $$$64$$$-bit integer. It can also be shown that the index of the special array is uniquely determined. In this problem, hacks are disabled.
Notes: NoteIn the first test case, the secret array $$$b$$$ is $$$[0, 1, 1, 1, 1, 1, 1, 1, 0]$$$. Array $$$c_1$$$ and array $$$c_2$$$ are generated by using operation 1. Array $$$c_3$$$ is generated by using operation 2.For Array $$$c_1$$$,you can choose $$$i=4$$$ and $$$j=5$$$ perform Operation 1 one time to generate it. For Array $$$c_2$$$, you can choose $$$i=6$$$ and $$$j=7$$$ perform Operation 1 one time to generate it. For Array $$$c_3$$$,you can choose $$$i=4$$$ and $$$j=5$$$ perform Operation 2 one time to generate it.In the second test case, the secret array $$$b$$$ is $$$[20, 20, 20, 20, 20, 20, 20]$$$. You can also find that array $$$c_1$$$ and array $$$c_2$$$ are generated by using Operation 1. Array $$$c_3$$$ is generated by using Operation 2.In the third test case, the secret array $$$b$$$ is $$$[20, 20, 20, 20, 20, 20, 20, 20, 20]$$$. You can also find that array $$$c_1$$$ and array $$$c_2$$$ are generated by using Operation 1. Array $$$c_3$$$ is generated by using Operation 2.
Code:
import sys
input= sys.stdin.readline
rn=lambda: [*map(int,input().split())]
for _ in range(*rn()):
n,m=rn()
b=[]
mm=0
for i in range(0,n):
a=sum([*map(lambda x,y:int(x)*y,input().split(),range(1,m+1))])
b.append(a)
if a>b[mm]:
# TODO: Your code here
print(mm+1,b[mm]-b[mm-1])
|
import sys
input= sys.stdin.readline
rn=lambda: [*map(int,input().split())]
for _ in range(*rn()):
n,m=rn()
b=[]
mm=0
for i in range(0,n):
a=sum([*map(lambda x,y:int(x)*y,input().split(),range(1,m+1))])
b.append(a)
if a>b[mm]:
{{completion}}
print(mm+1,b[mm]-b[mm-1])
|
mm=i
|
[{"input": "7\n3 9\n0 1 2 0 0 2 1 1 0\n0 1 1 1 2 0 0 2 0\n0 1 2 0 0 1 2 1 0\n3 7\n25 15 20 15 25 20 20\n26 14 20 14 26 20 20\n25 15 20 15 20 20 25\n3 9\n25 15 20 15 25 20 20 20 20\n26 14 20 14 26 20 20 20 20\n25 15 20 15 25 15 20 20 25\n3 11\n25 15 20 15 25 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20\n25 15 20 15 25 20 15 20 20 20 25\n3 13\n25 15 20 15 25 20 20 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20 20 20\n25 15 20 15 25 20 20 15 20 20 20 20 25\n3 15\n25 15 20 15 25 20 20 20 20 20 20 20 20 20 20\n26 14 20 14 26 20 20 20 20 20 20 20 20 20 20\n25 15 20 15 25 20 20 20 15 20 20 20 20 20 25\n3 9\n909459 479492 676924 224197 162866 164495 193268 742456 728277\n948845 455424 731850 327890 304150 237351 251763 225845 798316\n975446 401170 792914 272263 300770 242037 236619 334316 725899", "output": ["3 1\n3 10\n3 15\n3 20\n3 25\n3 30\n1 1378716"]}]
|
block_completion_002632
|
block
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.