message stringlengths 2 433k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers a_1, a_2, ..., a_n. You want to split it into exactly k non-empty non-intersecting subsegments such that each subsegment has odd sum (i. e. for each subsegment, the sum of all elements that belong to this subsegment is odd). It is impossible to rearrange (shuffle) the elements of a given array. Each of the n elements of the array a must belong to exactly one of the k subsegments.
Let's see some examples of dividing the array of length 5 into 3 subsegments (not necessarily with odd sums): [1, 2, 3, 4, 5] is the initial array, then all possible ways to divide it into 3 non-empty non-intersecting subsegments are described below:
* [1], [2], [3, 4, 5];
* [1], [2, 3], [4, 5];
* [1], [2, 3, 4], [5];
* [1, 2], [3], [4, 5];
* [1, 2], [3, 4], [5];
* [1, 2, 3], [4], [5].
Of course, it can be impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements. In this case print "NO". Otherwise, print "YES" and any possible division of the array. See the output format for the detailed explanation.
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries. Then q queries follow.
The first line of the query contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array and the number of subsegments, respectively.
The second line of the query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each query, print the answer to it. If it is impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements, print "NO" in the first line. Otherwise, print "YES" in the first line and any possible division of the array in the second line. The division can be represented as k integers r_1, r_2, ..., r_k such that 1 ≤ r_1 < r_2 < ... < r_k = n, where r_j is the right border of the j-th segment (the index of the last element that belongs to the j-th segment), so the array is divided into subsegments [1; r_1], [r_1 + 1; r_2], [r_2 + 1, r_3], ..., [r_{k - 1} + 1, n]. Note that r_k is always n but you should print it anyway.
Example
Input
3
5 3
7 18 3 14 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2
Output
YES
1 3 5
NO
NO | instruction | 0 | 84,311 | 12 | 168,622 |
Tags: constructive algorithms, math
Correct Solution:
```
t = int(input())
for q in range(t):
n, k = map(int, input().split())
A = list(map(int, input().split()))
if k == 1:
if sum(A) % 2 != 0:
print("YES")
print(n)
else:
print("NO")
else:
arr = []
total = 0
for i in range(len(A)):
total += A[i]
if total % 2 != 0:
arr.append(i+1)
total = 0
if len(arr) == k-1:
total = 0
total = sum(A[i+1:n])
if total % 2 != 0:
arr.append(n)
print("YES")
for j in arr:
print(j, end=" ")
print("")
break
if len(arr) == 0 or len(arr) < k:
print("NO")
``` | output | 1 | 84,311 | 12 | 168,623 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given an array a consisting of n integers a_1, a_2, ..., a_n. You want to split it into exactly k non-empty non-intersecting subsegments such that each subsegment has odd sum (i. e. for each subsegment, the sum of all elements that belong to this subsegment is odd). It is impossible to rearrange (shuffle) the elements of a given array. Each of the n elements of the array a must belong to exactly one of the k subsegments.
Let's see some examples of dividing the array of length 5 into 3 subsegments (not necessarily with odd sums): [1, 2, 3, 4, 5] is the initial array, then all possible ways to divide it into 3 non-empty non-intersecting subsegments are described below:
* [1], [2], [3, 4, 5];
* [1], [2, 3], [4, 5];
* [1], [2, 3, 4], [5];
* [1, 2], [3], [4, 5];
* [1, 2], [3, 4], [5];
* [1, 2, 3], [4], [5].
Of course, it can be impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements. In this case print "NO". Otherwise, print "YES" and any possible division of the array. See the output format for the detailed explanation.
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries. Then q queries follow.
The first line of the query contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array and the number of subsegments, respectively.
The second line of the query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each query, print the answer to it. If it is impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements, print "NO" in the first line. Otherwise, print "YES" in the first line and any possible division of the array in the second line. The division can be represented as k integers r_1, r_2, ..., r_k such that 1 ≤ r_1 < r_2 < ... < r_k = n, where r_j is the right border of the j-th segment (the index of the last element that belongs to the j-th segment), so the array is divided into subsegments [1; r_1], [r_1 + 1; r_2], [r_2 + 1, r_3], ..., [r_{k - 1} + 1, n]. Note that r_k is always n but you should print it anyway.
Example
Input
3
5 3
7 18 3 14 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2
Output
YES
1 3 5
NO
NO | instruction | 0 | 84,312 | 12 | 168,624 |
Tags: constructive algorithms, math
Correct Solution:
```
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n,k=map(int,input().split())
a=[int(j)%2 for j in input().split()]
sum1=sum(a)
if(sum1<k or abs(sum1-k)%2==1):
print("NO")
else:
print("YES")
l=[]
l.append(len(a))
k-=1
for i in range(len(a)):
if a[i]==1 and k>0:
l.append(i+1)
k-=1
l.sort()
print(*l)
``` | output | 1 | 84,312 | 12 | 168,625 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers a_1, a_2, ..., a_n. You want to split it into exactly k non-empty non-intersecting subsegments such that each subsegment has odd sum (i. e. for each subsegment, the sum of all elements that belong to this subsegment is odd). It is impossible to rearrange (shuffle) the elements of a given array. Each of the n elements of the array a must belong to exactly one of the k subsegments.
Let's see some examples of dividing the array of length 5 into 3 subsegments (not necessarily with odd sums): [1, 2, 3, 4, 5] is the initial array, then all possible ways to divide it into 3 non-empty non-intersecting subsegments are described below:
* [1], [2], [3, 4, 5];
* [1], [2, 3], [4, 5];
* [1], [2, 3, 4], [5];
* [1, 2], [3], [4, 5];
* [1, 2], [3, 4], [5];
* [1, 2, 3], [4], [5].
Of course, it can be impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements. In this case print "NO". Otherwise, print "YES" and any possible division of the array. See the output format for the detailed explanation.
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries. Then q queries follow.
The first line of the query contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array and the number of subsegments, respectively.
The second line of the query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each query, print the answer to it. If it is impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements, print "NO" in the first line. Otherwise, print "YES" in the first line and any possible division of the array in the second line. The division can be represented as k integers r_1, r_2, ..., r_k such that 1 ≤ r_1 < r_2 < ... < r_k = n, where r_j is the right border of the j-th segment (the index of the last element that belongs to the j-th segment), so the array is divided into subsegments [1; r_1], [r_1 + 1; r_2], [r_2 + 1, r_3], ..., [r_{k - 1} + 1, n]. Note that r_k is always n but you should print it anyway.
Example
Input
3
5 3
7 18 3 14 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2
Output
YES
1 3 5
NO
NO
Submitted Solution:
```
import os
import math
import operator
import sys
from collections import defaultdict
from io import BytesIO, IOBase
# Python3 Program to find
# Function to find the radius
# of the circumcircle
def main():
for _ in range(int(input())):
n,k=map(int,input().split())
arr=[int(k) for k in input().split()]
res=[]
lis=[]
for i in range(n):
if arr[i]%2!=0:
lis.append(i)
if len(lis)>=k and (len(lis)-k)%2==0:
print("YES")
for i in range(k-1):
print(lis[i]+1,end=" ")
print(n)
else:
print("NO")
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | instruction | 0 | 84,313 | 12 | 168,626 |
Yes | output | 1 | 84,313 | 12 | 168,627 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers a_1, a_2, ..., a_n. You want to split it into exactly k non-empty non-intersecting subsegments such that each subsegment has odd sum (i. e. for each subsegment, the sum of all elements that belong to this subsegment is odd). It is impossible to rearrange (shuffle) the elements of a given array. Each of the n elements of the array a must belong to exactly one of the k subsegments.
Let's see some examples of dividing the array of length 5 into 3 subsegments (not necessarily with odd sums): [1, 2, 3, 4, 5] is the initial array, then all possible ways to divide it into 3 non-empty non-intersecting subsegments are described below:
* [1], [2], [3, 4, 5];
* [1], [2, 3], [4, 5];
* [1], [2, 3, 4], [5];
* [1, 2], [3], [4, 5];
* [1, 2], [3, 4], [5];
* [1, 2, 3], [4], [5].
Of course, it can be impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements. In this case print "NO". Otherwise, print "YES" and any possible division of the array. See the output format for the detailed explanation.
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries. Then q queries follow.
The first line of the query contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array and the number of subsegments, respectively.
The second line of the query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each query, print the answer to it. If it is impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements, print "NO" in the first line. Otherwise, print "YES" in the first line and any possible division of the array in the second line. The division can be represented as k integers r_1, r_2, ..., r_k such that 1 ≤ r_1 < r_2 < ... < r_k = n, where r_j is the right border of the j-th segment (the index of the last element that belongs to the j-th segment), so the array is divided into subsegments [1; r_1], [r_1 + 1; r_2], [r_2 + 1, r_3], ..., [r_{k - 1} + 1, n]. Note that r_k is always n but you should print it anyway.
Example
Input
3
5 3
7 18 3 14 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2
Output
YES
1 3 5
NO
NO
Submitted Solution:
```
import sys
q = int(input())
for _ in range(q):
n, k = list(map(int, sys.stdin.readline().split()))
l = list(map(int, sys.stdin.readline().split()))
if n == 1:
if l[0] & 1:
print("YES")
print(1)
else:
print("NO")
else:
s = sum(l)
if k % 2 != s % 2:
print("NO")
else:
p = []
cnt = 0
for i in range(n):
if l[i] % 2 == 1:
p.append(i + 1)
cnt += 1
if cnt == k:
print("YES")
print(*p[:-1], end = " ")
print(n)
break
if cnt < k:
print("NO")
``` | instruction | 0 | 84,314 | 12 | 168,628 |
Yes | output | 1 | 84,314 | 12 | 168,629 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers a_1, a_2, ..., a_n. You want to split it into exactly k non-empty non-intersecting subsegments such that each subsegment has odd sum (i. e. for each subsegment, the sum of all elements that belong to this subsegment is odd). It is impossible to rearrange (shuffle) the elements of a given array. Each of the n elements of the array a must belong to exactly one of the k subsegments.
Let's see some examples of dividing the array of length 5 into 3 subsegments (not necessarily with odd sums): [1, 2, 3, 4, 5] is the initial array, then all possible ways to divide it into 3 non-empty non-intersecting subsegments are described below:
* [1], [2], [3, 4, 5];
* [1], [2, 3], [4, 5];
* [1], [2, 3, 4], [5];
* [1, 2], [3], [4, 5];
* [1, 2], [3, 4], [5];
* [1, 2, 3], [4], [5].
Of course, it can be impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements. In this case print "NO". Otherwise, print "YES" and any possible division of the array. See the output format for the detailed explanation.
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries. Then q queries follow.
The first line of the query contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array and the number of subsegments, respectively.
The second line of the query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each query, print the answer to it. If it is impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements, print "NO" in the first line. Otherwise, print "YES" in the first line and any possible division of the array in the second line. The division can be represented as k integers r_1, r_2, ..., r_k such that 1 ≤ r_1 < r_2 < ... < r_k = n, where r_j is the right border of the j-th segment (the index of the last element that belongs to the j-th segment), so the array is divided into subsegments [1; r_1], [r_1 + 1; r_2], [r_2 + 1, r_3], ..., [r_{k - 1} + 1, n]. Note that r_k is always n but you should print it anyway.
Example
Input
3
5 3
7 18 3 14 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2
Output
YES
1 3 5
NO
NO
Submitted Solution:
```
import sys
if __name__ == '__main__':
q = int(input())
result = []
for _ in range(q):
n, k = map(int, input().split())
lst = list(map(int, next(sys.stdin).split(' ')))
c_odd = 0
for i in lst:
if i % 2 == 1:
c_odd += 1
if c_odd < k or c_odd % 2 != k % 2:
result.append('NO')
else:
result.append('YES')
buff = []
for i, a in enumerate(lst, start=1):
if k == 1:
break
if a % 2 == 1:
buff.append(str(i))
k -= 1
buff.append(str(n))
result.append(' '.join(buff))
print('\n'.join(result))
``` | instruction | 0 | 84,315 | 12 | 168,630 |
Yes | output | 1 | 84,315 | 12 | 168,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers a_1, a_2, ..., a_n. You want to split it into exactly k non-empty non-intersecting subsegments such that each subsegment has odd sum (i. e. for each subsegment, the sum of all elements that belong to this subsegment is odd). It is impossible to rearrange (shuffle) the elements of a given array. Each of the n elements of the array a must belong to exactly one of the k subsegments.
Let's see some examples of dividing the array of length 5 into 3 subsegments (not necessarily with odd sums): [1, 2, 3, 4, 5] is the initial array, then all possible ways to divide it into 3 non-empty non-intersecting subsegments are described below:
* [1], [2], [3, 4, 5];
* [1], [2, 3], [4, 5];
* [1], [2, 3, 4], [5];
* [1, 2], [3], [4, 5];
* [1, 2], [3, 4], [5];
* [1, 2, 3], [4], [5].
Of course, it can be impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements. In this case print "NO". Otherwise, print "YES" and any possible division of the array. See the output format for the detailed explanation.
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries. Then q queries follow.
The first line of the query contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array and the number of subsegments, respectively.
The second line of the query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each query, print the answer to it. If it is impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements, print "NO" in the first line. Otherwise, print "YES" in the first line and any possible division of the array in the second line. The division can be represented as k integers r_1, r_2, ..., r_k such that 1 ≤ r_1 < r_2 < ... < r_k = n, where r_j is the right border of the j-th segment (the index of the last element that belongs to the j-th segment), so the array is divided into subsegments [1; r_1], [r_1 + 1; r_2], [r_2 + 1, r_3], ..., [r_{k - 1} + 1, n]. Note that r_k is always n but you should print it anyway.
Example
Input
3
5 3
7 18 3 14 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2
Output
YES
1 3 5
NO
NO
Submitted Solution:
```
q=int(input())
for i in range(q):
n,k=map(int,input().split())
a=list(map(int,input().split()))
o=[]
for j in range(n):
if(a[j]%2!=0):
o.append(j+1)
if(len(o)<k):
print("NO")
elif(k%2!=len(o)%2):
print("NO")
else:
print("YES")
for j in range(k-1):
print(o[j],end=" ")
print(n)
``` | instruction | 0 | 84,316 | 12 | 168,632 |
Yes | output | 1 | 84,316 | 12 | 168,633 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers a_1, a_2, ..., a_n. You want to split it into exactly k non-empty non-intersecting subsegments such that each subsegment has odd sum (i. e. for each subsegment, the sum of all elements that belong to this subsegment is odd). It is impossible to rearrange (shuffle) the elements of a given array. Each of the n elements of the array a must belong to exactly one of the k subsegments.
Let's see some examples of dividing the array of length 5 into 3 subsegments (not necessarily with odd sums): [1, 2, 3, 4, 5] is the initial array, then all possible ways to divide it into 3 non-empty non-intersecting subsegments are described below:
* [1], [2], [3, 4, 5];
* [1], [2, 3], [4, 5];
* [1], [2, 3, 4], [5];
* [1, 2], [3], [4, 5];
* [1, 2], [3, 4], [5];
* [1, 2, 3], [4], [5].
Of course, it can be impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements. In this case print "NO". Otherwise, print "YES" and any possible division of the array. See the output format for the detailed explanation.
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries. Then q queries follow.
The first line of the query contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array and the number of subsegments, respectively.
The second line of the query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each query, print the answer to it. If it is impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements, print "NO" in the first line. Otherwise, print "YES" in the first line and any possible division of the array in the second line. The division can be represented as k integers r_1, r_2, ..., r_k such that 1 ≤ r_1 < r_2 < ... < r_k = n, where r_j is the right border of the j-th segment (the index of the last element that belongs to the j-th segment), so the array is divided into subsegments [1; r_1], [r_1 + 1; r_2], [r_2 + 1, r_3], ..., [r_{k - 1} + 1, n]. Note that r_k is always n but you should print it anyway.
Example
Input
3
5 3
7 18 3 14 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2
Output
YES
1 3 5
NO
NO
Submitted Solution:
```
for _ in range(int(input())):
n,k=map(int,input().split())
arr=list(map(int,input().split()))
odd_count=0
s=0
final=[]
for i in range(len(arr)):
if arr[i]%2==1:
odd_count+=1
final.append(i+1)
jump=odd_count//k
if (odd_count%k)%2==1 or odd_count==0 or odd_count<k:
print("NO")
else:
print("YES")
ans=[]
for i in range(0,len(final),jump):
ans.append(final[i])
if len(ans)==k:
ans[-1]=n
print(*ans)
``` | instruction | 0 | 84,317 | 12 | 168,634 |
No | output | 1 | 84,317 | 12 | 168,635 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers a_1, a_2, ..., a_n. You want to split it into exactly k non-empty non-intersecting subsegments such that each subsegment has odd sum (i. e. for each subsegment, the sum of all elements that belong to this subsegment is odd). It is impossible to rearrange (shuffle) the elements of a given array. Each of the n elements of the array a must belong to exactly one of the k subsegments.
Let's see some examples of dividing the array of length 5 into 3 subsegments (not necessarily with odd sums): [1, 2, 3, 4, 5] is the initial array, then all possible ways to divide it into 3 non-empty non-intersecting subsegments are described below:
* [1], [2], [3, 4, 5];
* [1], [2, 3], [4, 5];
* [1], [2, 3, 4], [5];
* [1, 2], [3], [4, 5];
* [1, 2], [3, 4], [5];
* [1, 2, 3], [4], [5].
Of course, it can be impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements. In this case print "NO". Otherwise, print "YES" and any possible division of the array. See the output format for the detailed explanation.
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries. Then q queries follow.
The first line of the query contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array and the number of subsegments, respectively.
The second line of the query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each query, print the answer to it. If it is impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements, print "NO" in the first line. Otherwise, print "YES" in the first line and any possible division of the array in the second line. The division can be represented as k integers r_1, r_2, ..., r_k such that 1 ≤ r_1 < r_2 < ... < r_k = n, where r_j is the right border of the j-th segment (the index of the last element that belongs to the j-th segment), so the array is divided into subsegments [1; r_1], [r_1 + 1; r_2], [r_2 + 1, r_3], ..., [r_{k - 1} + 1, n]. Note that r_k is always n but you should print it anyway.
Example
Input
3
5 3
7 18 3 14 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2
Output
YES
1 3 5
NO
NO
Submitted Solution:
```
q=int(input())
for i in range(q):
n,k=map(int,input().split())
l=list(map(int,input().split()))
tsum=0
x=[]
aux=[]
for i in l:
tsum+=i
if(tsum%2==0 and k%2==1):
print("NO")
elif(tsum%2==1 and k%2==0):
print("NO")
else:
j=0
xsum=0
while(j<n and k!=0):
xsum+=l[j]
if(xsum%2==1):
x.append(j+1)
k-=1
xsum=0
j+=1
else:
j+=1
print("YES")
for i in range(len(x)-1):
aux.append(x[i])
aux.append(n)
print(*aux)
``` | instruction | 0 | 84,318 | 12 | 168,636 |
No | output | 1 | 84,318 | 12 | 168,637 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers a_1, a_2, ..., a_n. You want to split it into exactly k non-empty non-intersecting subsegments such that each subsegment has odd sum (i. e. for each subsegment, the sum of all elements that belong to this subsegment is odd). It is impossible to rearrange (shuffle) the elements of a given array. Each of the n elements of the array a must belong to exactly one of the k subsegments.
Let's see some examples of dividing the array of length 5 into 3 subsegments (not necessarily with odd sums): [1, 2, 3, 4, 5] is the initial array, then all possible ways to divide it into 3 non-empty non-intersecting subsegments are described below:
* [1], [2], [3, 4, 5];
* [1], [2, 3], [4, 5];
* [1], [2, 3, 4], [5];
* [1, 2], [3], [4, 5];
* [1, 2], [3, 4], [5];
* [1, 2, 3], [4], [5].
Of course, it can be impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements. In this case print "NO". Otherwise, print "YES" and any possible division of the array. See the output format for the detailed explanation.
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries. Then q queries follow.
The first line of the query contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array and the number of subsegments, respectively.
The second line of the query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each query, print the answer to it. If it is impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements, print "NO" in the first line. Otherwise, print "YES" in the first line and any possible division of the array in the second line. The division can be represented as k integers r_1, r_2, ..., r_k such that 1 ≤ r_1 < r_2 < ... < r_k = n, where r_j is the right border of the j-th segment (the index of the last element that belongs to the j-th segment), so the array is divided into subsegments [1; r_1], [r_1 + 1; r_2], [r_2 + 1, r_3], ..., [r_{k - 1} + 1, n]. Note that r_k is always n but you should print it anyway.
Example
Input
3
5 3
7 18 3 14 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2
Output
YES
1 3 5
NO
NO
Submitted Solution:
```
n = int(input())
for x in range(n):
p,q = map(int,input().split())
m = list(map(int,input().split()))
odd=[]
for i in range(len(m)):
if m[i]%2!=0:odd.append(i+1)
if(len(odd)-(q-1))%2==0 or len(odd)<q:
print('NO')
else:
print('YES')
odd[-1]=len(m)
print(*odd)
``` | instruction | 0 | 84,319 | 12 | 168,638 |
No | output | 1 | 84,319 | 12 | 168,639 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of n integers a_1, a_2, ..., a_n. You want to split it into exactly k non-empty non-intersecting subsegments such that each subsegment has odd sum (i. e. for each subsegment, the sum of all elements that belong to this subsegment is odd). It is impossible to rearrange (shuffle) the elements of a given array. Each of the n elements of the array a must belong to exactly one of the k subsegments.
Let's see some examples of dividing the array of length 5 into 3 subsegments (not necessarily with odd sums): [1, 2, 3, 4, 5] is the initial array, then all possible ways to divide it into 3 non-empty non-intersecting subsegments are described below:
* [1], [2], [3, 4, 5];
* [1], [2, 3], [4, 5];
* [1], [2, 3, 4], [5];
* [1, 2], [3], [4, 5];
* [1, 2], [3, 4], [5];
* [1, 2, 3], [4], [5].
Of course, it can be impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements. In this case print "NO". Otherwise, print "YES" and any possible division of the array. See the output format for the detailed explanation.
You have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries. Then q queries follow.
The first line of the query contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array and the number of subsegments, respectively.
The second line of the query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5 (∑ n ≤ 2 ⋅ 10^5).
Output
For each query, print the answer to it. If it is impossible to divide the initial array into exactly k subsegments in such a way that each of them will have odd sum of elements, print "NO" in the first line. Otherwise, print "YES" in the first line and any possible division of the array in the second line. The division can be represented as k integers r_1, r_2, ..., r_k such that 1 ≤ r_1 < r_2 < ... < r_k = n, where r_j is the right border of the j-th segment (the index of the last element that belongs to the j-th segment), so the array is divided into subsegments [1; r_1], [r_1 + 1; r_2], [r_2 + 1, r_3], ..., [r_{k - 1} + 1, n]. Note that r_k is always n but you should print it anyway.
Example
Input
3
5 3
7 18 3 14 1
5 4
1 2 3 4 5
6 2
1 2 8 4 10 2
Output
YES
1 3 5
NO
NO
Submitted Solution:
```
#code
for _ in range(int(input())):
n,k = map(int,input().split())
l = list(map(int,input().split()))
c=0
ind=[]
for i in range(len(l)-1,-1,-1):
if l[i]%2:
c+=1
ind.append(str(i+1))
if (c-k)%2==0:
print("YES")
print(" ".join(ind[:k][::-1]))
else:
print("NO")
``` | instruction | 0 | 84,320 | 12 | 168,640 |
No | output | 1 | 84,320 | 12 | 168,641 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0 | instruction | 0 | 84,321 | 12 | 168,642 |
Tags: brute force, implementation
Correct Solution:
```
INF = int (2e9)
n, k = list (map (int, input ().split ()))
a = list (map (int, input ().split ()))
a.sort()
a = [(x, 0) for x in a]
ans = INF
ha = {}
tail = n - 1
p = 0
def lowerbound (x):
l, r = 0, tail - 1
while (l <= r) :
mid = (l + r) >> 1
if (a[mid][0] >= x) :
r = mid - 1
else :
l = mid + 1
return r + 1
def find (x):
l = lowerbound (x[0])
r = lowerbound (x[0] + 1) - 1
while (l <= r) :
mid = (l + r) >> 1
if (a[mid][1] <= x[1]) :
r = mid - 1
else :
l = mid + 1
return r + 1
while (a[tail][0]):
flg = True
cnt = 0
val = a[tail][0]
if (a[tail - k + 1][0] == val) :
for j in range(k) :
cnt += a[tail - j][1]
ans = min (ans, cnt)
rem = k
while (a[tail][0] == val) :
if (rem > 0) :
tup = (a[tail][0] // 2, a[tail][1] + 1)
a.pop ()
a.insert(find (tup), tup)
rem -= 1
# print (a)
else :
a.pop ()
tail -= 1
print (ans)
``` | output | 1 | 84,321 | 12 | 168,643 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0 | instruction | 0 | 84,322 | 12 | 168,644 |
Tags: brute force, implementation
Correct Solution:
```
a,b=list(map(int,input().split()))
array=list(map(int,input().split()))
c=b-1
answer=[]
array.sort()
arr=list(range(1,array[-1]+1))
for it in arr:
element=it
current=0
count=0
for y in range(0,a):
copare=array[y]
if copare<element:
pass
elif current==b:
answer.append(count)
break
else:
moves=0
flag=5
while True:
if copare==element:
break
elif copare<element:
flag=6
break
else:
copare=int(copare//2)
moves+=1
if flag==6:
pass
else:
count+=moves
current+=1
if current==b:
answer.append(count)
array=array[0:b]
moves=0
for it in array:
while True:
if it==0:
break
else:
it=int(it//2)
moves+=1
answer.append(moves)
print(min(answer))
``` | output | 1 | 84,322 | 12 | 168,645 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0 | instruction | 0 | 84,323 | 12 | 168,646 |
Tags: brute force, implementation
Correct Solution:
```
N, K = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
lk = [0] * (1000000)
for n in l:
t = n
while t != 0:
lk[t] += 1
t //= 2
lk[0] = 99999999
g = 0
mn = 9999999
for i in range(len(lk) - 1, -1, -1):
if(lk[i] >= K):
g = i;
ed = []
for n in l:
if(n < g): ed.append(9999999)
elif(n == g): ed.append(0)
else:
t = n
c = 0
while True:
t //= 2
c += 1
if(t <= g):
if(t == g): ed.append(c)
else: ed.append(9999999)
break
ed.sort()
mn = min(mn, sum(ed[:K]))
print(mn)
# ed = []
# for n in l:
# if(n < g): ed.append(9999999)
# elif(n == g): ed.append(0)
# else:
# t = n
# c = 0
# while True:
# t //= 2
# c += 1
# if(t <= g):
# if(t == g): ed.append(c)
# else: ed.append(9999999)
# break
# ed.sort()
# print(sum(ed[:K]))
``` | output | 1 | 84,323 | 12 | 168,647 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0 | instruction | 0 | 84,324 | 12 | 168,648 |
Tags: brute force, implementation
Correct Solution:
```
n, k = map(int,input().split())
l = list(map(int,input().split()))
d = {}
for liczba in l:
ll = liczba
while ll > 0:
d[ll] = []
ll //= 2
for liczba in l:
i = 0
ll = liczba
while ll > 0:
d[ll].append(i)
ll //= 2
i += 1
wyn = 1000000000
for number in d:
if len(d[number]) < k:
continue
a = d[number].copy()
a.sort()
wyn = min(wyn, sum(a[:k]))
print(wyn)
``` | output | 1 | 84,324 | 12 | 168,649 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0 | instruction | 0 | 84,325 | 12 | 168,650 |
Tags: brute force, implementation
Correct Solution:
```
# import numpy as np
# def get_num_operations(m, x):
# if x < m: return big_number
# if x == m: return 0
# return 1 + get_num_operations(m, int(x / 2))
# big_number = 10000000
# n, k=map(int, input().split())
# elements_array = np.array(map(int, input().split()))
# print(1)
R=lambda:map(int,input().split())
n,k=R()
d={}
for x in R():
i=0
while x:l=d.setdefault(x,[]);l+=i,;x>>=1;i+=1
print(min(sum(sorted(d[x])[:k])for x in d if len(d[x])>=k))
# elements_array = np.zeros(n)
# sum_elements = 0
# i = 0
# for x in input().split():
# element = int(x)
# sum_elements += element
# elements_array[i] = element
# i += 1
# max_element = int(max(elements_array))
# best_result = big_number
# for m in range(0, max_element + 1):
# cur_results_array = np.full(n, big_number)
# i = 0
# for element in elements_array:
# cur_results_array[i] = get_num_operations(m, element)
# i += 1
# cur_operations = sum(np.sort(cur_results_array)[:k])
# best_result = min(best_result, cur_operations)
# print(best_result)
``` | output | 1 | 84,325 | 12 | 168,651 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0 | instruction | 0 | 84,326 | 12 | 168,652 |
Tags: brute force, implementation
Correct Solution:
```
# # n , com = map(int , input().split())
# # *a , = map(int , input().split())
# # test = [0 for i in range(n)]
# # for i in range(n):
# # test[i] = a[i]%2
# # print('mod2' , test)
# # test1 = [0 for i in range(n)]
# # m = min(a)
# # for i in range(n):
# # test[i] = a[i]-m
# # print('-min' , test1)
# # # com
# # a.sort()
# # print('digits for op' , a[:com+1])
# # a1 = a[:com+1]
# # test3 = []
# # for i in a1:
# # if i % 2 == 0:
# # test3.append(i)
# # print('even dig for op' , test3)
# # test4 = list(set(test3.copy()))
# # test6 = []
# # # print(n)
# # for i in test4:
# # # print(a.index(i))
# # pos = n - a.index(i) - 1
# # # print(pos)
# # if pos >= com:
# # test6.append(i)
# # print('possible' , test6)
# # test7 = []
# # for i in list(set(a)):
# # test7.append([i , a.count(i)])
# # if a.count(i) == com:
# # print('found' , i , 'else')
# # print(test7)
# # test7.sort(key = lambda t: t[1] ,reverse = True)
# # print(test7)
# # test6 = test6[::-1]
# # maxcntl = [t[0] for t in test7[:com+1]]
# # print(test6)
# # print(maxcntl)
# # for i in test6:
# # if i in maxcntl:
# # print('now===' , i)
# # # # # # # # # # # # # # # # # # # # # # # # # # #
# # n , com = map(int , input().split())
# # *a , = map(int , input().split())
# # flag = 0
# # test7 = []
# # for i in list(set(a)):
# # test7.append([i , a.count(i)])
# # if a.count(i) == com:
# # # print('found' , i , 'else')
# # flag = 1
# # if flag:
# # print(0)
# # else:
# # # a.sort()
# # # print('digits for op' , a[:com+1])
# # # a1 = a[:com+1]
# # a.sort()
# # a1 = a[:com+1]
# # test3 = []
# # for i in a1:
# # if i % 2 == 0:
# # test3.append(i)
# # # print('even dig for op' , test3)
# # test4 = list(set(test3.copy()))
# # test6 = []
# # # print(n)
# # for i in test4:
# # # print(a.index(i))
# # pos = n - a.index(i) - 1
# # # print(pos)
# # if pos >= com:
# # test6.append(i)
# # # print('possible' , test6)
# # test6 = test6[::-1]
# # maxcntl = [t[0] for t in test7[:com+1]]
# # # print(test6)
# # # print(maxcntl)
# # for i in test6:
# # if i in maxcntl:
# # # print('now===' , i)
# # element = i
# # print('e' , element)
# n , com = map(int , input().split())
# *a , = map(int , input().split())
# flag = 0
# test7 = []
# for i in list(set(a)):
# test7.append([i , a.count(i)])
# if a.count(i) == com:
# flag = 1
# if flag:
# print(0)
# else:
# a.sort()
# a1 = a[:com+1]
# test3 = []
# for i in a1:
# if i % 2 == 0:
# test3.append(i)
# test4 = list(set(test3.copy()))
# test6 = []
# for i in test4:
# pos = n - a.index(i) - 1
# if pos >= com:
# test6.append(i)
# test6 = test6[::-1]
# maxcntl = [t[0] for t in test7[:com+1]]
# for i in test6:
# if i in maxcntl:
# element = i
# # print('e' , element)
# # element is the base element for operttions
# # ppossible operations = higher elements than e
# cntbase = a.count(element)
# poss = []
# for i in a:
# if i > a+1:
# poss.append(i)
# if len(poss) + cntbase < com:
# print("error manage these")
vals = [[] for i in range(200*1000 + 11)]
ans = 10**5+7
n , k = map(int , input().split())
*a , = map(int , input().split())
for i in range(n):
x = a[i]
cur = 0
while x > 0:
vals[x].append(cur)
x //= 2
cur += 1 #check here
for i in range(200*1000):
new = vals[i]
new.sort()
if len(new) < k:
continue
ans = min(ans , sum(new[:k]))
print(ans)
``` | output | 1 | 84,326 | 12 | 168,653 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0 | instruction | 0 | 84,327 | 12 | 168,654 |
Tags: brute force, implementation
Correct Solution:
```
import math
n,k=map(int,input().split())
l=[int(i) for i in input().split()]
l.sort()
moves=[0]*(200001)
freq=[0]*(200001)
ans=1e9
for i in l:
freq[i]+=1
for i in range(len(l)):
count=0
a=l[i]
while a>1:
a=a//2
count+=1
if freq[a]<k:
freq[a]+=1
moves[a]+=(count)
#print(moves,freq,count,a)
for i in range(len(freq)):
if freq[i]>=k:
ans=min(ans,moves[i])
print(ans)
``` | output | 1 | 84,327 | 12 | 168,655 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0 | instruction | 0 | 84,328 | 12 | 168,656 |
Tags: brute force, implementation
Correct Solution:
```
n, k = map(int, input().split())
from collections import defaultdict
nums = list(map(int, input().split()))
cc = defaultdict(int)
aa = defaultdict(list)
for num in nums:
o = num
i = 0
while o != 0:
cc[o] += 1
aa[o].append(i)
i += 1
o //= 2
candidates = [name for name, count in cc.items() if count >= k]
m = float('inf')
for name in candidates:
m = min(m, sum(sorted(aa[name])[:k]))
print(m)
``` | output | 1 | 84,328 | 12 | 168,657 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0
Submitted Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
#from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
#from bisect import bisect_right as br #c++ upperbound br(array,element)
from collections import defaultdict
def main():
n,k=map(int,input().split(" "))
a=list(map(int,input().split(" ")))
dic=defaultdict(lambda:[])
for x in range(n):
cnt=0
while a[x]!=0:
dic[a[x]].append(cnt)
a[x]=a[x]//2
cnt+=1
dic[0].append(cnt)
ans=int(1e100)
for y in dic.values():
if len(y)>=k:
ans=min(ans,sum(sorted(y)[:k]))
print(ans)
#-----------------------------BOSS-------------------------------------!
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
``` | instruction | 0 | 84,329 | 12 | 168,658 |
Yes | output | 1 | 84,329 | 12 | 168,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0
Submitted Solution:
```
from collections import defaultdict
n, k = map(int, input().split())
a = sorted(list(map(int, input().split())))
costs = defaultdict(lambda: [])
for ai in a:
cost = 0
costs[ai].append(cost)
while ai != 0:
ai //= 2
cost += 1
costs[ai].append(cost)
min_cost = 99999999
for key, item in costs.items():
if len(item) >= k:
k_cost = sum(sorted(item[:k]))
if k_cost < min_cost:
min_cost = k_cost
print(min_cost)
``` | instruction | 0 | 84,330 | 12 | 168,660 |
Yes | output | 1 | 84,330 | 12 | 168,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0
Submitted Solution:
```
import math
import sys
from heapq import heappop
from heapq import heappush
from heapq import heapify
from bisect import insort
from sys import stdin,stdout
from collections import defaultdict
inp=lambda : int(stdin.readline())
sip=lambda : input()
mulip =lambda : map(int,input().split())
lst=lambda : list(map(int,stdin.readline().split()))
slst=lambda: list(sip())
arr2d= lambda x: [[int(j) for j in input().split()] for i in range(x)]
odds = lambda l: len(list(filter(lambda x: x%2!=0, l)))
evens = lambda l: len(list(filter(lambda x: x%2==0, l)))
mod = pow(10,9)+7
#-------------------------------------------------------
n, k = map(int, input().split())
A = [int(x) for x in input().split()]
vals = defaultdict(list)
for i in range(n):
x = A[i]
cnt = 0
while(x>0):
vals[x].append(cnt)
#print(x,":",vals[x])
x = x//2
cnt+=1
res = pow(10,10)
for i in range(2*pow(10,5)+1):
l = vals[i]
l = sorted(l)
if len(l)>=k:
res = min(res, sum(l[:k]))
print(res)
``` | instruction | 0 | 84,331 | 12 | 168,662 |
Yes | output | 1 | 84,331 | 12 | 168,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0
Submitted Solution:
```
from collections import defaultdict as DD
import sys
MOD=pow(10,9)+7
def IN(f=0):
if f==0:
return ( [int(i) for i in sys.stdin.readline().split()] )
else:
return ( int(sys.stdin.readline()) )
n,k=IN()
a=IN()
b=[]
d=DD(list)
for x in a:
i=0
while(x!=0):
d[x].append(i)
x=x//2
i+=1
d[0].append(i)
#print(d)
ans=9999999999999
for x in d:
if len(d[x])>=k:
r=d[x]
r.sort()
ans=min(ans,sum(r[:k]))
print(ans)
``` | instruction | 0 | 84,332 | 12 | 168,664 |
Yes | output | 1 | 84,332 | 12 | 168,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0
Submitted Solution:
```
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
# sys.setrecursionlimit(pow(10, 6))
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
n, k = sp()
arr = l()
arr.sort()
answer = inf
for i in set(arr):
res = 0
cnt = 0
# print(arr)
for j in range(n):
if arr[j] < i:
continue
c = 0
temp = arr[j]
while temp > i:
temp //= 2
c += 1
if temp == i:
res += c
cnt += 1
if cnt == k:
break
# print(i, res)
if cnt == k:
answer = min(answer, res)
out(answer)
``` | instruction | 0 | 84,333 | 12 | 168,666 |
No | output | 1 | 84,333 | 12 | 168,667 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0
Submitted Solution:
```
def fuck(num,i):
fuck = 0
while num >= i:
if num == i:
return fuck
num //= 2
fuck += 1
return False
lenK = list(map(int,input().split()))
lens = lenK[0]
K = lenK[1]
nums = list(map(int,input().split()))
nums.sort()
lists = [[nums[0],1]]
up = nums[0]
for i in nums[1:]:
if i == up:
lists[-1][1] += 1
else:
up = i
lists.append([i,1])
mis = -1
# print(lists)
for i in range(len(lists)):
thisN = lists[i][0]
thisP = 0
tk = K - lists[i][1]
if tk <= 0:
mis = 0
break
while tk > 0:
for j in range(i + 1,len(lists)):
dong = fuck(lists[j][0],thisN)
if dong != False:
thisP += min(tk,lists[j][1])*dong
tk -= lists[j][1]
if tk <= 0:
if mis == -1 or mis > thisP:
mis = thisP
# print(mis,thisN,i,lists[j])
break
if thisN == 0:
break
thisN //= 2
thisP += lists[i][1]
tk = K - lists[i][1]
print(int(mis))
``` | instruction | 0 | 84,334 | 12 | 168,668 |
No | output | 1 | 84,334 | 12 | 168,669 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0
Submitted Solution:
```
N, K = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
lk = [0] * (1000000)
for n in l:
t = n
while t != 0:
lk[t] += 1
t //= 2
lk[0] = 99999999
g = 0
for i in range(len(lk) - 1, -1, -1):
if(lk[i] >= K):
g = i
break
ed = []
for n in l:
if(n < g): ed.append(9999999)
elif(n == g): ed.append(0)
else:
t = n
c = 0
while t != 0:
t //= 2
c += 1
if(t <= g):
if(t == g): ed.append(c)
else: ed.append(9999999)
break
ed.sort()
print(sum(ed[:K]))
``` | instruction | 0 | 84,335 | 12 | 168,670 |
No | output | 1 | 84,335 | 12 | 168,671 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between easy and hard versions is the number of elements in the array.
You are given an array a consisting of n integers. In one move you can choose any a_i and divide it by 2 rounding down (in other words, in one move you can set a_i := ⌊(a_i)/(2)⌋).
You can perform such an operation any (possibly, zero) number of times with any a_i.
Your task is to calculate the minimum possible number of operations required to obtain at least k equal numbers in the array.
Don't forget that it is possible to have a_i = 0 after some operations, thus the answer always exists.
Input
The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 50) — the number of elements in the array and the number of equal numbers required.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
Print one integer — the minimum possible number of operations required to obtain at least k equal numbers in the array.
Examples
Input
5 3
1 2 2 4 5
Output
1
Input
5 3
1 2 3 4 5
Output
2
Input
5 3
1 2 3 3 3
Output
0
Submitted Solution:
```
N, K = [int(x) for x in input().split()]
l = [int(x) for x in input().split()]
lk = [0] * (2 * 10**5 + 1)
for n in l:
t = n
while t != 0:
lk[t] += 1
t //= 2
g = 20001
for i in range(len(lk) - 1, -1, -1):
if(lk[i] >= K):
g = i
break
ed = []
for n in l:
if(n < g): ed.append(9999999)
elif(n == g): ed.append(0)
else:
t = n
c = 0
while t != 0:
t //= 2
c += 1
if(t <= g):
if(t == g): ed.append(c)
else:
ed.append(9999999)
break
ed.sort()
print(sum(ed[:K]))
``` | instruction | 0 | 84,336 | 12 | 168,672 |
No | output | 1 | 84,336 | 12 | 168,673 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 84,406 | 12 | 168,812 |
Tags: dp
Correct Solution:
```
t=int(input())
while(t>0):
t-=1
n=int(input())
p=list(map(int, input().split()))
l=[]
j=0
for i in range(1, 2*n):
if j==i or p[j] > p[i]:
if i!=2*n-1:
continue
else:
l.append(i-j)
j=i
if i==2*n-1:
l.append(2*n-j)
m=[0]*n
ln=len(l)
for i in range(ln):
for j in range(n-1, -1, -1):
if j+l[i]+1<=n and m[j]:
m[j+l[i]]=1
if l[i]<=n:
m[l[i]-1]=1
if m[-1]==1:
print("YES")
else:
print("NO")
``` | output | 1 | 84,406 | 12 | 168,813 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 84,407 | 12 | 168,814 |
Tags: dp
Correct Solution:
```
def isSubsetSum(set, n, sum):
# The value of subset[i][j] will be
# true if there is a
# subset of set[0..j-1] with sum equal to i
subset =([[False for i in range(sum + 1)]
for i in range(n + 1)])
# If sum is 0, then answer is true
for i in range(n + 1):
subset[i][0] = True
# If sum is not 0 and set is empty,
# then answer is false
for i in range(1, sum + 1):
subset[0][i]= False
# Fill the subset table in botton up manner
for i in range(1, n + 1):
for j in range(1, sum + 1):
if j<set[i-1]:
subset[i][j] = subset[i-1][j]
if j>= set[i-1]:
subset[i][j] = (subset[i-1][j] or
subset[i - 1][j-set[i-1]])
# uncomment this code to print table
# for i in range(n + 1):
# for j in range(sum + 1):
# print (subset[i][j], end =" ")
# print()
return subset[n][sum]
for x in range(int(input())):
n = int(input())
m=list(map(int,input().split()))
k=0
l=0
z=0
a=[]
for i in range(2*n):
if m[i]>l:
z=max(k,z)
l=m[i]
a.append(k)
k=0
k+=1
a.append(k)
if z>n or k>n:
print('NO')
else:
p=len(a)
if (isSubsetSum(a, p, n) == True):
print('YES')
else:
print('NO')
``` | output | 1 | 84,407 | 12 | 168,815 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 84,408 | 12 | 168,816 |
Tags: dp
Correct Solution:
```
import time,math as mt,bisect,sys
from sys import stdin,stdout
from collections import deque
from fractions import Fraction
from collections import Counter
from collections import OrderedDict
pi=3.14159265358979323846264338327950
def II(): # to take integer input
return int(stdin.readline())
def IO(): # to take string input
return stdin.readline()
def IP(): # to take tuple as input
return map(int,stdin.readline().split())
def L(): # to take list as input
return list(map(int,stdin.readline().split()))
def P(x): # to print integer,list,string etc..
return stdout.write(str(x)+"\n")
def PI(x,y): # to print tuple separatedly
return stdout.write(str(x)+" "+str(y)+"\n")
def lcm(a,b): # to calculate lcm
return (a*b)//gcd(a,b)
def gcd(a,b): # to calculate gcd
if a==0:
return b
elif b==0:
return a
if a>b:
return gcd(a%b,b)
else:
return gcd(a,b%a)
def readTree(): # to read tree
v=int(input())
adj=[set() for i in range(v+1)]
for i in range(v-1):
u1,u2=In()
adj[u1].add(u2)
adj[u2].add(u1)
return adj,v
def bfs(adj,v): # a schema of bfs
visited=[False]*(v+1)
q=deque()
while q:
pass
def sieve():
li=[True]*1000001
li[0],li[1]=False,False
for i in range(2,len(li),1):
if li[i]==True:
for j in range(i*i,len(li),i):
li[j]=False
prime=[]
for i in range(1000001):
if li[i]==True:
prime.append(i)
return prime
def setBit(n):
count=0
while n!=0:
n=n&(n-1)
count+=1
return count
mx=10**7
spf=[mx]*(mx+1)
def SPF():
spf[1]=1
for i in range(2,mx+1):
if spf[i]==mx:
spf[i]=i
for j in range(i*i,mx+1,i):
if i<spf[j]:
spf[j]=i
return
#####################################################################################
mod=10**9+7
def solve():
n=II()
cpy=n
n=2*n
p=L()
i=n-1
la,lb=0,0
subset=[]
while i>=0:
mx=max(p[:i+1])
fnd=p.index(mx)
if la<lb:
la+=(n-fnd)
subset.append(n-fnd)
else:
lb+=(n-fnd)
subset.append(n-fnd)
i=fnd-1
n=fnd
ss=len(subset)
n=cpy
for ele in subset:
if ele>n:
print("NO")
return
dp=[[0 for i in range(2*n+1)] for i in range(ss)]
dp[ss-1][subset[ss-1]]=1
for j in range(ss-2,-1,-1):
dp[j][subset[j]]=1
for k in range(2*n+1):
if dp[j+1][k]==1:
dp[j][subset[j]+k]=1
dp[j][k]=1
if dp[0][n]==1:
P("YES")
return
P("NO")
return
t=II()
for i in range(t):
solve()
#######
#
#
####### # # # #### # # #
# # # # # # # # # # #
# #### # # #### #### # #
###### # # #### # # # # #
``` | output | 1 | 84,408 | 12 | 168,817 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 84,409 | 12 | 168,818 |
Tags: dp
Correct Solution:
```
import sys,os,io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
def fun():
s = sum(v)
n = len(v)
ps = s//2
dp = [[False]*(n+1) for i in range (ps+1)]
for i in range (n+1):
dp[0][i]=True
for i in range (1,ps+1):
dp[i][0]=False
for i in range (1,ps+1):
for j in range (1,n+1):
dp[i][j] = dp[i][j-1]
if (i>=v[j-1]):
dp[i][j] = dp[i][j] or dp[i-v[j-1]][j-1]
return dp[ps][n]
for _ in range (int(input())):
n = int(input())
a = [int(i)-1 for i in input().split()]
s = SortedList()
for i in a:
s.add(i)
v = []
ind = [-1]*(2*n)
for i in range (2*n):
ind[a[i]]=i
while(len(s)):
m = s[-1]
pos = ind[m]
v.append(len(a)-pos)
while(len(a)>pos):
s.remove(a.pop())
v.sort()
if fun():
print("YES")
else:
print("NO")
``` | output | 1 | 84,409 | 12 | 168,819 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 84,410 | 12 | 168,820 |
Tags: dp
Correct Solution:
```
from collections import deque
t=int(input())
while(t):
n=int(input())
a=list(map(int,input().split()))
u=[x+1 for x in range(2*n-1)]
if(a==u):
print("YES")
t-=1
continue
count,m=1,a[0]
b=deque()
for x in range(1,2*n):
if(a[x]>m):
m=a[x]
b.append(count)
count=1
else:
count+=1
b.append(count)
b=list(b)
f=0
weights = {0}
for item in b:
new_weights = [
weight + item for weight in weights if weight + item <= n]
weights = weights.union(new_weights)
if n in weights:
print("YES")
t-=1
f=1
break
if(f):
continue
print("NO")
t-=1
``` | output | 1 | 84,410 | 12 | 168,821 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 84,411 | 12 | 168,822 |
Tags: dp
Correct Solution:
```
tests = int(input())
for t in range(tests):
n = int(input())
ls = list(map(int, input().split()))
curr = ls[0]
groups = []
group_len = 1
for item in ls[1:]:
if curr > item:
group_len += 1
else:
groups.append(group_len)
group_len = 1
curr = item
groups.append(group_len)
group_len = len(groups)
dp = [None for i in range(group_len)]
if groups[0] < n:
dp[0] = [0, groups[0]]
else:
dp[0] = [0]
for i in range(1,group_len):
curr = groups[i]
previous_ls = dp[i-1]
new = set(previous_ls)
for prev in previous_ls:
if prev + curr <= n:
new.add(prev+curr)
dp[i] = list(new)
check=False
for item in dp[group_len-1]:
if item == n:
print('YES')
check=True
break
if not check:
print('NO')
``` | output | 1 | 84,411 | 12 | 168,823 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 84,412 | 12 | 168,824 |
Tags: dp
Correct Solution:
```
from math import inf, log2
class SegmentTree:
def __init__(self, array, func=max):
self.n = len(array)
self.size = 2**(int(log2(self.n-1))+1) if self.n != 1 else 1
self.func = func
self.default = 0 if self.func != min else inf
self.data = [self.default] * (2 * self.size)
self.process(array)
def process(self, array):
self.data[self.size : self.size+self.n] = array
for i in range(self.size-1, -1, -1):
self.data[i] = self.func(self.data[2*i], self.data[2*i+1])
def query(self, alpha, omega):
"""Returns the result of function over the range (inclusive)!"""
if alpha == omega:
return self.data[alpha + self.size]
res = self.default
alpha += self.size
omega += self.size + 1
while alpha < omega:
if alpha & 1:
res = self.func(res, self.data[alpha])
alpha += 1
if omega & 1:
omega -= 1
res = self.func(res, self.data[omega])
alpha >>= 1
omega >>= 1
return res
def update(self, index, value):
"""Updates the element at index to given value!"""
index += self.size
self.data[index] = value
index >>= 1
while index:
self.data[index] = self.func(self.data[2*index], self.data[2*index+1])
index >>= 1
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
from math import gcd, ceil
def isSubsetSum(set, n, sum):
# The value of subset[i][j] will be
# true if there is a
# subset of set[0..j-1] with sum equal to i
subset = ([[False for i in range(sum + 1)]
for i in range(n + 1)])
# If sum is 0, then answer is true
for i in range(n + 1):
subset[i][0] = True
# If sum is not 0 and set is empty,
# then answer is false
for i in range(1, sum + 1):
subset[0][i] = False
# Fill the subset table in botton up manner
for i in range(1, n + 1):
for j in range(1, sum + 1):
if j < set[i - 1]:
subset[i][j] = subset[i - 1][j]
if j >= set[i - 1]:
subset[i][j] = (subset[i - 1][j] or
subset[i - 1][j - set[i - 1]])
# uncomment this code to print table
# for i in range(n + 1):
# for j in range(sum + 1):
# print (subset[i][j], end =" ")
# print()
return subset[n][sum]
def pre(s):
n = len(s)
pi = [0] * n
for i in range(1, n):
j = pi[i - 1]
while j and s[i] != s[j]:
j = pi[j - 1]
if s[i] == s[j]:
j += 1
pi[i] = j
return pi
def prod(a):
ans = 1
for each in a:
ans = (ans * each)
return ans
def lcm(a, b): return a * b // gcd(a, b)
def binary(x, length=16):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def invert(x):
r = len(x)
ans = ['0']*r
for i in range(r):
if x[i] == '0':
ans[i] = '1'
return "".join(ans)
for _ in range(int(input()) if True else 1):
n = int(input())
#a, b = map(int, input().split())
#c, d = map(int, input().split())
a = list(map(int, input().split()))
st = SegmentTree(a, func=max)
co = 0
ans = []
for i in range(len(a)-1, -1, -1):
co += 1
if a[i] == st.query(0,i):
ans += [co]
co = 0
print("YES" if isSubsetSum(ans,len(ans),n) else "NO")
``` | output | 1 | 84,412 | 12 | 168,825 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | instruction | 0 | 84,413 | 12 | 168,826 |
Tags: dp
Correct Solution:
```
from bisect import *
from collections import *
from math import gcd,ceil,sqrt,floor,inf
from heapq import *
from itertools import *
from operator import add,mul,sub,xor,truediv,floordiv
from functools import *
#------------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
#------------------------------------------------------------------------
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
farr=[1]
ifa=[]
def fact(x,mod=0):
if mod:
while x>=len(farr):
farr.append(farr[-1]*len(farr)%mod)
else:
while x>=len(farr):
farr.append(farr[-1]*len(farr))
return farr[x]
def ifact(x,mod):
global ifa
ifa.append(pow(farr[-1],mod-2,mod))
for i in range(x,0,-1):
ifa.append(ifa[-1]*i%mod)
ifa=ifa[::-1]
def per(i,j,mod=0):
if i<j: return 0
if not mod:
return fact(i)//fact(i-j)
return farr[i]*ifa[i-j]%mod
def com(i,j,mod=0):
if i<j: return 0
if not mod:
return per(i,j)//fact(j)
return per(i,j,mod)*ifa[j]%mod
def catalan(n):
return com(2*n,n)//(n+1)
def linc(f,t,l,r):
while l<r:
mid=(l+r)//2
if t>f(mid):
l=mid+1
else:
r=mid
return l
def rinc(f,t,l,r):
while l<r:
mid=(l+r+1)//2
if t<f(mid):
r=mid-1
else:
l=mid
return l
def ldec(f,t,l,r):
while l<r:
mid=(l+r)//2
if t<f(mid):
l=mid+1
else:
r=mid
return l
def rdec(f,t,l,r):
while l<r:
mid=(l+r+1)//2
if t>f(mid):
r=mid-1
else:
l=mid
return l
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def binfun(x):
c=0
for w in arr:
c+=ceil(w/x)
return c
def lowbit(n):
return n&-n
def inverse(a,m):
a%=m
if a<=1: return a
return ((1-inverse(m,a)*m)//a)%m
class BIT:
def __init__(self,arr):
self.arr=arr
self.n=len(arr)-1
def update(self,x,v):
while x<=self.n:
self.arr[x]+=v
x+=x&-x
def query(self,x):
ans=0
while x:
ans+=self.arr[x]
x&=x-1
return ans
'''
class SMT:
def __init__(self,arr):
self.n=len(arr)-1
self.arr=[0]*(self.n<<2)
self.lazy=[0]*(self.n<<2)
def Build(l,r,rt):
if l==r:
self.arr[rt]=arr[l]
return
m=(l+r)>>1
Build(l,m,rt<<1)
Build(m+1,r,rt<<1|1)
self.pushup(rt)
Build(1,self.n,1)
def pushup(self,rt):
self.arr[rt]=self.arr[rt<<1]+self.arr[rt<<1|1]
def pushdown(self,rt,ln,rn):#lr,rn表区间数字数
if self.lazy[rt]:
self.lazy[rt<<1]+=self.lazy[rt]
self.lazy[rt<<1|1]=self.lazy[rt]
self.arr[rt<<1]+=self.lazy[rt]*ln
self.arr[rt<<1|1]+=self.lazy[rt]*rn
self.lazy[rt]=0
def update(self,L,R,c,l=1,r=None,rt=1):#L,R表示操作区间
if r==None: r=self.n
if L<=l and r<=R:
self.arr[rt]+=c*(r-l+1)
self.lazy[rt]+=c
return
m=(l+r)>>1
self.pushdown(rt,m-l+1,r-m)
if L<=m: self.update(L,R,c,l,m,rt<<1)
if R>m: self.update(L,R,c,m+1,r,rt<<1|1)
self.pushup(rt)
def query(self,L,R,l=1,r=None,rt=1):
if r==None: r=self.n
#print(L,R,l,r,rt)
if L<=l and R>=r:
return self.arr[rt]
m=(l+r)>>1
self.pushdown(rt,m-l+1,r-m)
ans=0
if L<=m: ans+=self.query(L,R,l,m,rt<<1)
if R>m: ans+=self.query(L,R,m+1,r,rt<<1|1)
return ans
'''
class DSU:#容量+路径压缩
def __init__(self,n):
self.c=[-1]*n
def same(self,x,y):
return self.find(x)==self.find(y)
def find(self,x):
if self.c[x]<0:
return x
self.c[x]=self.find(self.c[x])
return self.c[x]
def union(self,u,v):
u,v=self.find(u),self.find(v)
if u==v:
return False
if self.c[u]<self.c[v]:
u,v=v,u
self.c[u]+=self.c[v]
self.c[v]=u
return True
def size(self,x): return -self.c[self.find(x)]
class UFS:#秩+路径
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
def Prime(n):
c=0
prime=[]
flag=[0]*(n+1)
for i in range(2,n+1):
if not flag[i]:
prime.append(i)
c+=1
for j in range(c):
if i*prime[j]>n: break
flag[i*prime[j]]=prime[j]
if i%prime[j]==0: break
return prime
def dij(s,graph):
d={}
d[s]=0
heap=[(0,s)]
seen=set()
while heap:
dis,u=heappop(heap)
if u in seen:
continue
for v in graph[u]:
if v not in d or d[v]>d[u]+graph[u][v]:
d[v]=d[u]+graph[u][v]
heappush(heap,(d[v],v))
return d
def GP(it): return [(ch,len(list(g))) for ch,g in groupby(it)]
class DLN:
def __init__(self,val):
self.val=val
self.pre=None
self.next=None
class Trie:
def __init__(self,d):
if d>=0:
self.left=Trie(d-1)
else:
self.right=Trie(d-1)
self.c=0
def put(self,x,i):
if i==-1:
self.c=1
return
if x&1<<i:
self.left.put(x,i-1)
else:
self.right.put(x,i-1)
t=N()
for i in range(t):
n=N()
p=RLL()
cur=p[0]
c=1
res=[]
for i in range(1,n*2):
if cur>p[i]:
c+=1
else:
res.append(c)
cur=p[i]
c=1
res.append(c)
#print(res)
k=len(res)
dp=[0]*(n+1)
if res[0]<=n:
dp[res[0]]=1
dp[0]=1
for i in range(1,k):
for j in range(n,res[i]-1,-1):
dp[j]=dp[j]|dp[j-res[i]]
ans='YES' if dp[n] else 'NO'
print(ans)
'''
sys.setrecursionlimit(200000)
import threading
threading.stack_size(10**8)
t=threading.Thread(target=main)
t.start()
t.join()
'''
``` | output | 1 | 84,413 | 12 | 168,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
a = [*map(int, input().split())]
b = []
mx = 0
for i in range(2*n):
if a[i] > mx:
mx = a[i]
b.append(i + 1)
b.append(2*n + 1)
b = [j - i for i, j in zip(b[:-1], b[1:])]
ans = [[0] * (n + 1) for _ in range(len(b))]
b.sort()
for i in range(len(b)):
ans[i][0] = 1
for i in range(1, n + 1):
if i == b[0]:
ans[0][i] = 1
for i in range(1, len(b)):
for j in range(1, n + 1):
if b[i] <= j:
if ans[i - 1][j - b[i]]:
ans[i][j] = 1
ans[i][j] = max(ans[i][j], ans[i - 1][j])
print(['NO', 'YES'][ans[-1][-1]])
``` | instruction | 0 | 84,414 | 12 | 168,828 |
Yes | output | 1 | 84,414 | 12 | 168,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
from sys import stdin
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
t, = gil()
for _ in range(t):
n, = gil()
arr = gil()
getMaxIdx = [0]*n*2
prev = 0
for i in range(1, 2*n ):
if arr[i] > arr[prev] :
prev = i
getMaxIdx[i] = prev
coins = []
i = 2*n - 1
while i>0:
coins.append(i - getMaxIdx[i] + 1)
i = getMaxIdx[i] - 1
sums = [0]*(n+1)
sums[0] = 1
temp = []
for coin in coins :
for i in range(n+1):
if sums[i] and i+coin <= n and not sums[i+coin]:
temp.append(i+coin)
while len(temp):
sums[temp.pop()] = 1
if sums[-1] : break
print("YES" if sums[-1] else "NO")
``` | instruction | 0 | 84,415 | 12 | 168,830 |
Yes | output | 1 | 84,415 | 12 | 168,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
import heapq
for _ in range(int(input())):
n=int(input())
s=list(map(int,input().split()))
h=[]
for x in s:
h.append(-x)
h.sort()
dead=set()
num=[]
count=0
for x in s[::-1]:
count+=1
if x==-h[0]:
num.append(count)
count=0
dead.add(x)
while h!=[] and -h[0] in dead:
heapq.heappop(h)
dp=[0]*(n+1)
dp[0]=1
for x in num:
for i in range(n,-1,-1):
if dp[i]==1 and i+x<=n:
dp[i+x]=1
if dp[n]==1:
print('YES')
else:
print('NO')
``` | instruction | 0 | 84,416 | 12 | 168,832 |
Yes | output | 1 | 84,416 | 12 | 168,833 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
import sys
import collections
def input():
return sys.stdin.readline().rstrip()
def split_input():
return [int(i) for i in input().split()]
# tests = 1
tests = int(input())
for _ in range(tests):
n = int(input())
p = split_input()
s = set()
nextmax = 2*n
num = 0
l = []
for i in range(2*n-1, -1, -1):
num += 1
if p[i] == nextmax:
l.append(num)
num = 0
s.add(p[i])
nextmax -= 1
while (nextmax in s):
nextmax -= 1
else:
s.add(p[i])
dp = [[False for i in range(2*n+1)] for i in range(len(l))]
dp[0][l[0]] = True
for i in range(1, len(l)):
for j in range(2*n+1):
if l[i] > j:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = dp[i-1][j] or dp[i-1][j - l[i]]
if dp[len(l) - 1][n] == True:
print("YES")
else:
print("NO")
``` | instruction | 0 | 84,417 | 12 | 168,834 |
Yes | output | 1 | 84,417 | 12 | 168,835 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
def merge(a,b,n):
i,j = 0,0
ret = []
a.append(2*n+1)
b.append(2*n+1)
while i < n or j < n:
if (a[i] < b[j]):
ret.append(a[i])
i += 1
else:
ret.append(b[j])
j += 1
return ret
t = int(input().split()[0])
for case in range(t):
n = int(input().split()[0])
arr = list(map(int,input().split()))
ind = arr.index(2*n)-1
if (ind < n-1):
print("NO")
continue
check1,check2 = [],[]
for i in range(2*n):
if i > ind-n and i <= ind:
check1.append(arr[i])
else:
check2.append(arr[i])
if merge(check1,check2,n) == arr:
print("YES")
continue
if merge(arr[0:n],arr[n+1:2*n],n) == arr:
print("YES")
continue
print("NO")
``` | instruction | 0 | 84,418 | 12 | 168,836 |
No | output | 1 | 84,418 | 12 | 168,837 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
from math import *
from collections import *
from random import *
from bisect import *
import sys
input=sys.stdin.readline
d={'1':'0','0':'1'}
def isSub(set, n, sum):
subset =([[False for i in range(sum + 1)]
for i in range(n + 1)])
for i in range(n + 1):
subset[i][0] = True
for i in range(1, sum + 1):
subset[0][i]= False
for i in range(1, n + 1):
for j in range(1, sum + 1):
if j<set[i-1]:
subset[i][j] = subset[i-1][j]
if j>= set[i-1]:
subset[i][j] = (subset[i-1][j] or
subset[i - 1][j-set[i-1]])
return subset[n][sum]
t=int(input())
while(t):
t-=1
n=int(input())
a=list(map(int,input().split()))
r=[]
c=0
ref=2*n
for i in range(2*n-1,-1,-1):
if(a[i]==ref):
c+=1
r.append(c)
c=0
ref-=1
else:
c+=1
if(c):
r.append(c)
if(isSub(r,len(r),n)==True):
print("YES")
else:
print("NO")
``` | instruction | 0 | 84,419 | 12 | 168,838 |
No | output | 1 | 84,419 | 12 | 168,839 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
'''Author- Akshit Monga'''
def isSubsetSum(set, n, sum):
# Base Cases
if (sum == 0):
return True
if (n == 0 and sum != 0):
return False
# If last element is greater than
# sum, then ignore it
if (set[n - 1] > sum):
return isSubsetSum(set, n - 1, sum);
# else, check if sum can be obtained
# by any of the following
# (a) including the last element
# (b) excluding the last element
return isSubsetSum(
set, n - 1, sum) or isSubsetSum(
set, n - 1, sum - set[n - 1])
import sys
# input=sys.stdin.readline
t = int(input())
for _ in range(t):
n=int(input())
arr=[int(x) for x in input().split()]
counter=2*n
subsets=[]
count=0
temp=[]
for i in arr[::-1]:
if i==counter:
temp.append(i)
for k in range(counter,0,-1):
if k not in temp:
counter=k
break
# counter=min(temp)-1
temp=[]
subsets.append(count+1)
count=0
else:
temp.append(i)
count+=1
if count:
subsets.append(count)
# print(subsets)
if isSubsetSum(subsets,len(subsets),n):
print("YES")
else:
print("NO")
``` | instruction | 0 | 84,420 | 12 | 168,840 |
No | output | 1 | 84,420 | 12 | 168,841 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
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).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
b=[[a[0]]]
x=a[0]
c=[]
check=False
for i in range(1,2*n):
if not check:
if a[i]<x:
b[-1].append(a[i])
else:
c.append([a[i]])
y=a[i]
check=True
else:
if a[i]<y:
c[-1].append(a[i])
else:
b.append([a[i]])
x=a[i]
check=False
d=[0]*(len(b)+len(c))
for i in range(0,len(b)+len(c),2):
d[i]=len(b[i//2])
for i in range(1,len(b)+len(c),2):
d[i]=len(c[i//2])
i=0
a=0
b=0
cnt=0
check=False
while i<len(d):
if cnt%2==0 and i<len(d):
while a+d[i]<=n:
a+=d[i]
i+=1
if i==len(d):
break
elif i<len(d):
while b+d[i]<=n:
b+=d[i]
i+=1
if i==len(d):
break
if i<len(d):
if a+d[i]>n and b+d[i]>n:
check=True
break
cnt+=1
if a!=n or b!=n or check:
print("NO")
else:
print("YES")
``` | instruction | 0 | 84,421 | 12 | 168,842 |
No | output | 1 | 84,421 | 12 | 168,843 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given array a with n integers and m queries. The i-th query is given with three integers li, ri, xi.
For the i-th query find any position pi (li ≤ pi ≤ ri) so that api ≠ xi.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2·105) — the number of elements in a and the number of queries.
The second line contains n integers ai (1 ≤ ai ≤ 106) — the elements of the array a.
Each of the next m lines contains three integers li, ri, xi (1 ≤ li ≤ ri ≤ n, 1 ≤ xi ≤ 106) — the parameters of the i-th query.
Output
Print m lines. On the i-th line print integer pi — the position of any number not equal to xi in segment [li, ri] or the value - 1 if there is no such number.
Examples
Input
6 4
1 2 1 1 3 5
1 4 1
2 6 2
3 4 1
3 4 2
Output
2
6
-1
4 | instruction | 0 | 84,627 | 12 | 169,254 |
Tags: data structures, implementation
Correct Solution:
```
from sys import stdin
_data = iter(stdin.read().split('\n'))
def input():
while True:
return next(_data)
n ,m = map(int, input().split())
a = list(map(int, input().split()))
ans=[]
difPre=[-1 for i in range(n)]
for i in range(1,n):
if a[i]==a[i-1]:
difPre[i]=difPre[i-1]
else:
difPre[i]=i-1
for i in range(m):
l,r,x=map(int,input().split())
if a[r-1]!=x:
ans.append(str(r))
else:
if difPre[r-1]>=l-1:
ans.append(str(difPre[r-1]+1))
else:
ans.append('-1')
print('\n'.join(ans))
``` | output | 1 | 84,627 | 12 | 169,255 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given array a with n integers and m queries. The i-th query is given with three integers li, ri, xi.
For the i-th query find any position pi (li ≤ pi ≤ ri) so that api ≠ xi.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2·105) — the number of elements in a and the number of queries.
The second line contains n integers ai (1 ≤ ai ≤ 106) — the elements of the array a.
Each of the next m lines contains three integers li, ri, xi (1 ≤ li ≤ ri ≤ n, 1 ≤ xi ≤ 106) — the parameters of the i-th query.
Output
Print m lines. On the i-th line print integer pi — the position of any number not equal to xi in segment [li, ri] or the value - 1 if there is no such number.
Examples
Input
6 4
1 2 1 1 3 5
1 4 1
2 6 2
3 4 1
3 4 2
Output
2
6
-1
4 | instruction | 0 | 84,628 | 12 | 169,256 |
Tags: data structures, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
n, m = map(int, input().split())
a = list(map(int, input().split()))
b, c = [0], []
now = 0
for j in range(n - 1):
if a[j] ^ a[j + 1]:
now += 1
c.append(j)
b.append(now)
c.append(n)
for _ in range(m):
l, r, p = map(int, input().split())
x = c[b[l - 1]]
y = x + 1
if a[l - 1] ^p:
ans = l
elif y >= r:
ans = -1
else:
ans = x + 1 if a[x] ^ p else y + 1
print(ans)
``` | output | 1 | 84,628 | 12 | 169,257 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given array a with n integers and m queries. The i-th query is given with three integers li, ri, xi.
For the i-th query find any position pi (li ≤ pi ≤ ri) so that api ≠ xi.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2·105) — the number of elements in a and the number of queries.
The second line contains n integers ai (1 ≤ ai ≤ 106) — the elements of the array a.
Each of the next m lines contains three integers li, ri, xi (1 ≤ li ≤ ri ≤ n, 1 ≤ xi ≤ 106) — the parameters of the i-th query.
Output
Print m lines. On the i-th line print integer pi — the position of any number not equal to xi in segment [li, ri] or the value - 1 if there is no such number.
Examples
Input
6 4
1 2 1 1 3 5
1 4 1
2 6 2
3 4 1
3 4 2
Output
2
6
-1
4 | instruction | 0 | 84,629 | 12 | 169,258 |
Tags: data structures, implementation
Correct Solution:
```
import collections
import math
n ,m = map(int, input().split())
A = list(map(int, input().split()))
ans, f = [], [0] * n
f[0] = -1
for i in range(1, n):
if A[i] != A[i - 1]:
f[i] = i - 1
else:
f[i] = f[i - 1]
for i in range(m):
l, r, x = map(int, input().split())
#q.append([l - 1, r - 1, x])
#for i in range(m):
if A[r - 1] != x:
ans.append(r)
elif f[r - 1] >= l - 1:
ans.append(f[r - 1] + 1)
else:
ans.append(-1)
print('\n'.join(str(x) for x in ans))
``` | output | 1 | 84,629 | 12 | 169,259 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given array a with n integers and m queries. The i-th query is given with three integers li, ri, xi.
For the i-th query find any position pi (li ≤ pi ≤ ri) so that api ≠ xi.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2·105) — the number of elements in a and the number of queries.
The second line contains n integers ai (1 ≤ ai ≤ 106) — the elements of the array a.
Each of the next m lines contains three integers li, ri, xi (1 ≤ li ≤ ri ≤ n, 1 ≤ xi ≤ 106) — the parameters of the i-th query.
Output
Print m lines. On the i-th line print integer pi — the position of any number not equal to xi in segment [li, ri] or the value - 1 if there is no such number.
Examples
Input
6 4
1 2 1 1 3 5
1 4 1
2 6 2
3 4 1
3 4 2
Output
2
6
-1
4 | instruction | 0 | 84,630 | 12 | 169,260 |
Tags: data structures, implementation
Correct Solution:
```
from itertools import combinations, accumulate, groupby, count
from sys import stdout, stdin, setrecursionlimit
from io import BytesIO, IOBase
from collections import *
from random import *
from bisect import *
from string import *
from queue import *
from heapq import *
from math import *
from os import *
from re import *
####################################---fast-input-output----#########################################
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = read(self._fd, max(fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = read(self._fd, max(fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
stdin, stdout = IOWrapper(stdin), IOWrapper(stdout)
def fast(): return stdin.readline().strip()
def zzz(): return [int(i) for i in fast().split()]
z, zz = input, lambda: list(map(int, z().split()))
szz, graph, mod, szzz = lambda: sorted(
zz()), {}, 10**9 + 7, lambda: sorted(zzz())
def lcd(xnum1, xnum2): return (xnum1 * xnum2 // gcd(xnum1, xnum2))
def print(answer, end='\n'): stdout.write(str(answer) + end)
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
###########################---Some Rule For Me To Follow---#################################
"""
--instants of Reading problem continuously try to understand them.
--If you Know some , Then you probably don't know him !
"""
###########################---START-CODING---###############################################
# num = int(z())
# lst = []
# for _ in range(num):
# arr = zzz()
# lst.append(arr)
# left = 0
# right = 10**9 + 1
# while right - left > 1:
# curr = (right + left) // 2
# currSet = set()
# for i in range(num):
# msk = 0
# for j in range(5):
# if lst[i][j] >= curr:
# msk |= 1 << j
# currSet.add(msk)
# flag = False
# for x in currSet:
# for y in currSet:
# for k in currSet:
# if x | y | k == 31:
# flag = True
# if flag:
# left = curr
# else:
# right = curr
# print(left)
n, m = zzz()
arr = zzz()
new = [0] * (n + 1)
for i in range(n - 2, -1, -1):
if arr[i] == arr[i + 1]:
new[i] = new[i + 1]
else:
new[i] = i + 1
res = [0] * (m)
for _ in range(m):
l, r, x = zzz()
ans = -1
if arr[l - 1] != x:
ans = l
else:
if new[l - 1] != new[r - 1]:
ans = new[l - 1] + 1
res[_] = ans
for i in res:
print(i)
``` | output | 1 | 84,630 | 12 | 169,261 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given array a with n integers and m queries. The i-th query is given with three integers li, ri, xi.
For the i-th query find any position pi (li ≤ pi ≤ ri) so that api ≠ xi.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2·105) — the number of elements in a and the number of queries.
The second line contains n integers ai (1 ≤ ai ≤ 106) — the elements of the array a.
Each of the next m lines contains three integers li, ri, xi (1 ≤ li ≤ ri ≤ n, 1 ≤ xi ≤ 106) — the parameters of the i-th query.
Output
Print m lines. On the i-th line print integer pi — the position of any number not equal to xi in segment [li, ri] or the value - 1 if there is no such number.
Examples
Input
6 4
1 2 1 1 3 5
1 4 1
2 6 2
3 4 1
3 4 2
Output
2
6
-1
4 | instruction | 0 | 84,631 | 12 | 169,262 |
Tags: data structures, implementation
Correct Solution:
```
import sys
def preprocess(arr):
left_i = -1
prev = arr[0]
preprocessed = []
for i, k in enumerate(arr):
if prev != k:
prev = k
left_i = i
preprocessed.append(left_i)
return preprocessed
def query(arr, pre, l, r, x):
if arr[r-1] != x:
return r
if pre[r-1] >= l:
return pre[r-1]
return -1
def solve():
n, m = map(int, sys.stdin.readline().split())
arr = list(map(int, sys.stdin.readline().split()))
pre = preprocess(arr)
for _ in range(m):
l, r, x = map(int, sys.stdin.readline().split())
yield str(query(arr, pre, l, r, x))
def main():
sys.stdout.write("\n".join(solve()))
main()
``` | output | 1 | 84,631 | 12 | 169,263 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given array a with n integers and m queries. The i-th query is given with three integers li, ri, xi.
For the i-th query find any position pi (li ≤ pi ≤ ri) so that api ≠ xi.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2·105) — the number of elements in a and the number of queries.
The second line contains n integers ai (1 ≤ ai ≤ 106) — the elements of the array a.
Each of the next m lines contains three integers li, ri, xi (1 ≤ li ≤ ri ≤ n, 1 ≤ xi ≤ 106) — the parameters of the i-th query.
Output
Print m lines. On the i-th line print integer pi — the position of any number not equal to xi in segment [li, ri] or the value - 1 if there is no such number.
Examples
Input
6 4
1 2 1 1 3 5
1 4 1
2 6 2
3 4 1
3 4 2
Output
2
6
-1
4 | instruction | 0 | 84,632 | 12 | 169,264 |
Tags: data structures, implementation
Correct Solution:
```
from sys import *
n, m = [int(t) for t in input().split()]
vec = [0 for t in range(n)]
pre = [0 for t in range(n)]
for idx, val in enumerate([int(t) for t in stdin.readline().split()]):
vec[idx] = val
pre[idx] = -1 if idx == 0 else (idx-1 if vec[idx-1] != val else pre[idx-1])
ans = [0 for t in range(m)]
for q in range(m):
l, r, x = [int(t) for t in stdin.readline().split()]
l -= 1
r -= 1
if vec[l] == x and vec[r] == x:
ans[q] = (-1 if pre[r] < l else pre[r]+1)
else:
ans[q] = (l+1 if vec[l] != x else r+1)
print("\n".join([str(t) for t in ans]))
``` | output | 1 | 84,632 | 12 | 169,265 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given array a with n integers and m queries. The i-th query is given with three integers li, ri, xi.
For the i-th query find any position pi (li ≤ pi ≤ ri) so that api ≠ xi.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2·105) — the number of elements in a and the number of queries.
The second line contains n integers ai (1 ≤ ai ≤ 106) — the elements of the array a.
Each of the next m lines contains three integers li, ri, xi (1 ≤ li ≤ ri ≤ n, 1 ≤ xi ≤ 106) — the parameters of the i-th query.
Output
Print m lines. On the i-th line print integer pi — the position of any number not equal to xi in segment [li, ri] or the value - 1 if there is no such number.
Examples
Input
6 4
1 2 1 1 3 5
1 4 1
2 6 2
3 4 1
3 4 2
Output
2
6
-1
4 | instruction | 0 | 84,633 | 12 | 169,266 |
Tags: data structures, implementation
Correct Solution:
```
from collections import defaultdict
import bisect
from itertools import accumulate
import os
import sys
import math
from decimal import *
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input(): return sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------]]
n,m=map(int,input().split())
a=list(map(int,input().split()))
b=[]
for i in range(n):
if i==0 or a[i]!=a[i-1]:
b.append(i)
else:
b.append(b[i-1])
ans=[]
for i in range(m):
l,r,x=map(int,input().split())
ans.append(r if a[r-1]!=x else (b[r-1] if b[r-1]>=l else -1))
print('\n'.join(map(str,ans)))
``` | output | 1 | 84,633 | 12 | 169,267 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given array a with n integers and m queries. The i-th query is given with three integers li, ri, xi.
For the i-th query find any position pi (li ≤ pi ≤ ri) so that api ≠ xi.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2·105) — the number of elements in a and the number of queries.
The second line contains n integers ai (1 ≤ ai ≤ 106) — the elements of the array a.
Each of the next m lines contains three integers li, ri, xi (1 ≤ li ≤ ri ≤ n, 1 ≤ xi ≤ 106) — the parameters of the i-th query.
Output
Print m lines. On the i-th line print integer pi — the position of any number not equal to xi in segment [li, ri] or the value - 1 if there is no such number.
Examples
Input
6 4
1 2 1 1 3 5
1 4 1
2 6 2
3 4 1
3 4 2
Output
2
6
-1
4 | instruction | 0 | 84,634 | 12 | 169,268 |
Tags: data structures, implementation
Correct Solution:
```
from sys import *
n, m = [int(t) for t in input().split()]
vec = []
pre = []
for idx, val in enumerate([int(t) for t in stdin.readline().split()]):
vec.append(val)
last = -1 if idx == 0 else (idx-1 if vec[idx-1] != val else pre[idx-1])
pre.append(last)
ans = []
for q in range(m):
l, r, x = [int(t) for t in stdin.readline().split()]
l -= 1
r -= 1
if vec[l] == x and vec[r] == x:
ans.append(str(-1 if pre[r] < l else pre[r]+1))
else:
ans.append(str(l+1 if vec[l] != x else r+1))
print("\n".join(ans))
# PYPY !!
``` | output | 1 | 84,634 | 12 | 169,269 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.