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 two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO". | instruction | 0 | 57,289 | 12 | 114,578 |
Tags: brute force
Correct Solution:
```
# list( map(int, input().split()) )
rw = int(input())
for ewqr in range(rw):
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
aset = set(a)
bset = set(b)
c = aset & bset
c = list(c)
if c == []:
print('NO')
else:
print('YES')
print(1, c[0])
``` | output | 1 | 57,289 | 12 | 114,579 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO". | instruction | 0 | 57,290 | 12 | 114,580 |
Tags: brute force
Correct Solution:
```
def common_elements(list1, list2):
return [element for element in list1 if element in list2]
t = int(input())
while t>0:
al, bl = [int(x) for x in input().split()]
a = [str(int(x)) for x in input().split()]
b = [str(int(x)) for x in input().split()]
'''ccc = common_elements(a, b)
ccc = sorted(ccc, key=len)
if len(ccc)>0:
print("YES")
print(f'{len(ccc[0])} {" ".join(ccc[0])}')
else: print("NO")'''
found = False
for x in a:
if x in b:
found = True
print("YES")
print(f'1 {x}')
break
if not found:print("NO")
t-=1
``` | output | 1 | 57,290 | 12 | 114,581 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO". | instruction | 0 | 57,291 | 12 | 114,582 |
Tags: brute force
Correct Solution:
```
input=__import__('sys').stdin.readline
for _ in range(int(input())):
input()
ans=set(map(int,input().split()))&set(map(int,input().split()))
if ans:print('YES');print(1,ans.pop())
else:print('NO')
``` | output | 1 | 57,291 | 12 | 114,583 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO". | instruction | 0 | 57,292 | 12 | 114,584 |
Tags: brute force
Correct Solution:
```
for i in range(int(input())):
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
for j in range(len(a)):
if a[j] in b:
print("YES")
print(1, a[j])
break
else:
print("NO")
``` | output | 1 | 57,292 | 12 | 114,585 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO". | instruction | 0 | 57,293 | 12 | 114,586 |
Tags: brute force
Correct Solution:
```
t = int(input())
for _ in range(t):
n,m = map(int,input().split())
a = set(map(int,input().split()))
b = set(map(int,input().split()))
v = list(a & b)
if v:
print("YES")
print(1,v[0])
else:
print("NO")
``` | output | 1 | 57,293 | 12 | 114,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO".
Submitted Solution:
```
def sub():
N,M=input().split()
N=int(N)
M=int(M)
a1=[int(i) for i in input().split()][:N]
b1=[int(i) for i in input().split()][:M]
a1.sort()
for i in a1:
for j in b1:
if i==j:
print("YES")
return print("1 {}".format(i))
return print("NO")
if __name__ == "__main__":
testcase=int(input())
for k in range(testcase):
sub()
``` | instruction | 0 | 57,294 | 12 | 114,588 |
Yes | output | 1 | 57,294 | 12 | 114,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO".
Submitted Solution:
```
t=int(input())
while t>0:
a=[int(x)for x in input().split()]
n=a[0];m=a[1];
a=[int(x)for x in input().split()]
b=[int(x)for x in input().split()]
k=0
for i in a:
for j in b:
if j==i:
num=i
k=1
break
if k==1:
break
if k==1:
print("YES")
print(1,num)
else:
print("NO")
t-=1
``` | instruction | 0 | 57,295 | 12 | 114,590 |
Yes | output | 1 | 57,295 | 12 | 114,591 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO".
Submitted Solution:
```
for _ in range(int(input())):
n,m=map(int,input().split())
a=set(map(int,input().split()))
b=set(map(int,input().split()))
x=a.intersection(b)
if(len(x)!=0):
print("YES")
z=x.pop()
print(1,z)
else:
print("NO")
``` | instruction | 0 | 57,296 | 12 | 114,592 |
Yes | output | 1 | 57,296 | 12 | 114,593 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO".
Submitted Solution:
```
import sys
import math
def II():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
def MI():
return map(int, sys.stdin.readline().split())
def SI():
return sys.stdin.readline().strip()
t = II()
for q in range(t):
n,m = MI()
a = LI()
b = LI()
ans = 0
boo = False
for i in range(n):
for j in range(m):
if a[i] == b[j]:
ans = a[i]
boo = True
break
if boo:
break
if boo:
print("YES")
print(1,ans)
else:
print("NO")
``` | instruction | 0 | 57,297 | 12 | 114,594 |
Yes | output | 1 | 57,297 | 12 | 114,595 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO".
Submitted Solution:
```
def solve():
x,y=map(int,input().split())
dc={}
s=list(map(int,input().split()))
z=list(map(int,input().split()))
for n in z:
dc[n]=1
for n in s:
if n in dc:
print('YES')
print(n)
return
print('NO')
for _ in range(int(input())):
solve()
``` | instruction | 0 | 57,298 | 12 | 114,596 |
No | output | 1 | 57,298 | 12 | 114,597 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO".
Submitted Solution:
```
t=int(input())
for i in range(0,t):
c=[]
n,m = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
#if a is larger
if n>=m:
for j in range(0,m):
if b[j] in a:
a = a[a.index(b[j]):]
c.append(b[j])
#if b is larger
elif n<=m:
for j in range(0,n):
if a[j] in b:
c.append(a[j])
b = b[b.index(a[j]):]
if len(c)!=0:
print("YES")
print(len(c), *c)
elif len(c)==0:
print("NO")
``` | instruction | 0 | 57,299 | 12 | 114,598 |
No | output | 1 | 57,299 | 12 | 114,599 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO".
Submitted Solution:
```
t=int(input())
for i in range(t):
n,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
found=0
if len(a)>len(b):
for j in range(len(a)):
if a[j] in b:
print('YES')
print(1 ,a[j])
found=1
break
if found==0:
print('NO')
else:
for j in range(len(b)):
if b[j] in a:
print('YES')
print(1 ,a[j])
found=1
break
if found==0:
print('NO')
``` | instruction | 0 | 57,300 | 12 | 114,600 |
No | output | 1 | 57,300 | 12 | 114,601 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays of integers a_1,…,a_n and b_1,…,b_m.
Your task is to find a non-empty array c_1,…,c_k that is a subsequence of a_1,…,a_n, and also a subsequence of b_1,…,b_m. If there are multiple answers, find one of the smallest possible length. If there are still multiple of the smallest possible length, find any. If there are no such arrays, you should report about it.
A sequence a is a subsequence of a sequence b if a can be obtained from b by deletion of several (possibly, zero) elements. For example, [3,1] is a subsequence of [3,2,1] and [4,3,1], but not a subsequence of [1,3,3,7] and [3,10,4].
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains two integers n and m (1≤ n,m≤ 1000) — the lengths of the two arrays.
The second line of each test case contains n integers a_1,…,a_n (1≤ a_i≤ 1000) — the elements of the first array.
The third line of each test case contains m integers b_1,…,b_m (1≤ b_i≤ 1000) — the elements of the second array.
It is guaranteed that the sum of n and the sum of m across all test cases does not exceed 1000 (∑_{i=1}^t n_i, ∑_{i=1}^t m_i≤ 1000).
Output
For each test case, output "YES" if a solution exists, or "NO" otherwise.
If the answer is "YES", on the next line output an integer k (1≤ k≤ 1000) — the length of the array, followed by k integers c_1,…,c_k (1≤ c_i≤ 1000) — the elements of the array.
If there are multiple solutions with the smallest possible k, output any.
Example
Input
5
4 5
10 8 6 4
1 2 3 4 5
1 1
3
3
1 1
3
2
5 3
1000 2 2 2 3
3 1 5
5 5
1 2 3 4 5
1 2 3 4 5
Output
YES
1 4
YES
1 3
NO
YES
1 3
YES
1 2
Note
In the first test case, [4] is a subsequence of [10, 8, 6, 4] and [1, 2, 3, 4, 5]. This array has length 1, it is the smallest possible length of a subsequence of both a and b.
In the third test case, no non-empty subsequences of both [3] and [2] exist, so the answer is "NO".
Submitted Solution:
```
# import math
# from collections import Counter
#from collections import defaultdict
#from collections import deque
# from bisect import bisect_left as bl, bisect_right as br
# from itertools import accumulate,permutations as perm,combinations as comb
# import heapq
# from functools import reduce
# from fractions import Fraction
def main():
t = Iint()
for _ in range(t):
n, m = Imap()
a = set(Imap())
b = set(Imap())
a = a & b
if len(a) == 0:
print("NO")
else:
for ai in a:
print("YES")
print(ai)
break
# IO region
FIO = 1
def I(): return input()
def Iint(): return int(input())
def Ilist(): return list(map(int, input().split())) # int list
def Imap(): return map(int, input().split()) # int map
def Plist(li, s=' '): print(s.join(map(str, li))) # non string list
# /IO region
en = enumerate
if not FIO:
if __name__ == '__main__':
main()
exit()
else:
from io import BytesIO, IOBase
import sys
import os
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")
# endregion
if __name__ == '__main__':
main()
``` | instruction | 0 | 57,301 | 12 | 114,602 |
No | output | 1 | 57,301 | 12 | 114,603 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Levko loves array a1, a2, ... , an, consisting of integers, very much. That is why Levko is playing with array a, performing all sorts of operations with it. Each operation Levko performs is of one of two types:
1. Increase all elements from li to ri by di. In other words, perform assignments aj = aj + di for all j that meet the inequation li ≤ j ≤ ri.
2. Find the maximum of elements from li to ri. That is, calculate the value <image>.
Sadly, Levko has recently lost his array. Fortunately, Levko has records of all operations he has performed on array a. Help Levko, given the operation records, find at least one suitable array. The results of all operations for the given array must coincide with the record results. Levko clearly remembers that all numbers in his array didn't exceed 109 in their absolute value, so he asks you to find such an array.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 5000) — the size of the array and the number of operations in Levko's records, correspondingly.
Next m lines describe the operations, the i-th line describes the i-th operation. The first integer in the i-th line is integer ti (1 ≤ ti ≤ 2) that describes the operation type. If ti = 1, then it is followed by three integers li, ri and di (1 ≤ li ≤ ri ≤ n, - 104 ≤ di ≤ 104) — the description of the operation of the first type. If ti = 2, then it is followed by three integers li, ri and mi (1 ≤ li ≤ ri ≤ n, - 5·107 ≤ mi ≤ 5·107) — the description of the operation of the second type.
The operations are given in the order Levko performed them on his array.
Output
In the first line print "YES" (without the quotes), if the solution exists and "NO" (without the quotes) otherwise.
If the solution exists, then on the second line print n integers a1, a2, ... , an (|ai| ≤ 109) — the recovered array.
Examples
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 8
Output
YES
4 7 4 7
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 13
Output
NO | instruction | 0 | 57,451 | 12 | 114,902 |
Tags: greedy, implementation
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
n,m = Ri()
lis = []
for i in range(m):
lis.append(Ri())
ans = [10**9]*n
for i in range(m-1,-1,-1):
if lis[i][0] == 2:
for j in range(lis[i][1]-1,lis[i][2]):
ans[j] = min(ans[j], lis[i][3])
else:
for j in range(lis[i][1]-1,lis[i][2]):
if ans[j] != 10**9:
ans[j]-=lis[i][3]
for i in range(n):
if ans[i] == 10**9:
ans[i] = -10**9
temp = ans[:]
# print(temp)
flag = True
for i in range(m):
if lis[i][0] == 2:
t= -10**9
for j in range(lis[i][1]-1,lis[i][2]):
t = max(t, temp[j])
if t != lis[i][3]:
flag = False
break
else:
for j in range(lis[i][1]-1,lis[i][2]):
temp[j]+=lis[i][3]
# print(temp, ans)
if flag :
YES()
print(*ans)
else:
NO()
# print(-1)
``` | output | 1 | 57,451 | 12 | 114,903 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Levko loves array a1, a2, ... , an, consisting of integers, very much. That is why Levko is playing with array a, performing all sorts of operations with it. Each operation Levko performs is of one of two types:
1. Increase all elements from li to ri by di. In other words, perform assignments aj = aj + di for all j that meet the inequation li ≤ j ≤ ri.
2. Find the maximum of elements from li to ri. That is, calculate the value <image>.
Sadly, Levko has recently lost his array. Fortunately, Levko has records of all operations he has performed on array a. Help Levko, given the operation records, find at least one suitable array. The results of all operations for the given array must coincide with the record results. Levko clearly remembers that all numbers in his array didn't exceed 109 in their absolute value, so he asks you to find such an array.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 5000) — the size of the array and the number of operations in Levko's records, correspondingly.
Next m lines describe the operations, the i-th line describes the i-th operation. The first integer in the i-th line is integer ti (1 ≤ ti ≤ 2) that describes the operation type. If ti = 1, then it is followed by three integers li, ri and di (1 ≤ li ≤ ri ≤ n, - 104 ≤ di ≤ 104) — the description of the operation of the first type. If ti = 2, then it is followed by three integers li, ri and mi (1 ≤ li ≤ ri ≤ n, - 5·107 ≤ mi ≤ 5·107) — the description of the operation of the second type.
The operations are given in the order Levko performed them on his array.
Output
In the first line print "YES" (without the quotes), if the solution exists and "NO" (without the quotes) otherwise.
If the solution exists, then on the second line print n integers a1, a2, ... , an (|ai| ≤ 109) — the recovered array.
Examples
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 8
Output
YES
4 7 4 7
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 13
Output
NO | instruction | 0 | 57,452 | 12 | 114,904 |
Tags: greedy, implementation
Correct Solution:
```
n, m = map(int, input().split())
a = [int(1e9)] * n
extra = [0] * n
query = list()
for _ in range(m):
t, l, r, x = map(int, input().split())
l -= 1
r -= 1
query.append((t, l, r, x))
if t == 1:
for j in range(l, r+1):
extra[j] += x
else:
for j in range(l, r+1):
a[j] = min(a[j], x - extra[j])
extra = a[:]
for t, l, r, x in query:
if t == 1:
for j in range(l, r+1):
a[j] += x
else:
val = -10**9
for j in range(l, r+1):
val = max(val, a[j])
if not val == x:
print('NO')
exit()
print('YES')
print(*extra)
``` | output | 1 | 57,452 | 12 | 114,905 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Levko loves array a1, a2, ... , an, consisting of integers, very much. That is why Levko is playing with array a, performing all sorts of operations with it. Each operation Levko performs is of one of two types:
1. Increase all elements from li to ri by di. In other words, perform assignments aj = aj + di for all j that meet the inequation li ≤ j ≤ ri.
2. Find the maximum of elements from li to ri. That is, calculate the value <image>.
Sadly, Levko has recently lost his array. Fortunately, Levko has records of all operations he has performed on array a. Help Levko, given the operation records, find at least one suitable array. The results of all operations for the given array must coincide with the record results. Levko clearly remembers that all numbers in his array didn't exceed 109 in their absolute value, so he asks you to find such an array.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 5000) — the size of the array and the number of operations in Levko's records, correspondingly.
Next m lines describe the operations, the i-th line describes the i-th operation. The first integer in the i-th line is integer ti (1 ≤ ti ≤ 2) that describes the operation type. If ti = 1, then it is followed by three integers li, ri and di (1 ≤ li ≤ ri ≤ n, - 104 ≤ di ≤ 104) — the description of the operation of the first type. If ti = 2, then it is followed by three integers li, ri and mi (1 ≤ li ≤ ri ≤ n, - 5·107 ≤ mi ≤ 5·107) — the description of the operation of the second type.
The operations are given in the order Levko performed them on his array.
Output
In the first line print "YES" (without the quotes), if the solution exists and "NO" (without the quotes) otherwise.
If the solution exists, then on the second line print n integers a1, a2, ... , an (|ai| ≤ 109) — the recovered array.
Examples
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 8
Output
YES
4 7 4 7
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 13
Output
NO | instruction | 0 | 57,453 | 12 | 114,906 |
Tags: greedy, implementation
Correct Solution:
```
n, m = map(int, input().split())
a = [10**9 for _ in range(n)]
extra = [0 for _ in range(n)]
query = list()
for _ in range(m):
t, l, r, x = map(int, input().split())
l -= 1
r -= 1
query.append((t, l, r, x))
if t == 1:
for j in range(l, r + 1):
extra[j] += x
else:
for j in range(l, r + 1):
a[j] = min(a[j], x - extra[j])
extra = a.copy()
for t, l, r, x in query:
if t == 1:
for j in range(l, r + 1):
a[j] += x
else:
val = -10**9
for j in range(l, r + 1):
val = max(val, a[j])
if not val == x:
print('NO')
exit(0)
print('YES')
for x in extra:
print(x, end=' ')
``` | output | 1 | 57,453 | 12 | 114,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Levko loves array a1, a2, ... , an, consisting of integers, very much. That is why Levko is playing with array a, performing all sorts of operations with it. Each operation Levko performs is of one of two types:
1. Increase all elements from li to ri by di. In other words, perform assignments aj = aj + di for all j that meet the inequation li ≤ j ≤ ri.
2. Find the maximum of elements from li to ri. That is, calculate the value <image>.
Sadly, Levko has recently lost his array. Fortunately, Levko has records of all operations he has performed on array a. Help Levko, given the operation records, find at least one suitable array. The results of all operations for the given array must coincide with the record results. Levko clearly remembers that all numbers in his array didn't exceed 109 in their absolute value, so he asks you to find such an array.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 5000) — the size of the array and the number of operations in Levko's records, correspondingly.
Next m lines describe the operations, the i-th line describes the i-th operation. The first integer in the i-th line is integer ti (1 ≤ ti ≤ 2) that describes the operation type. If ti = 1, then it is followed by three integers li, ri and di (1 ≤ li ≤ ri ≤ n, - 104 ≤ di ≤ 104) — the description of the operation of the first type. If ti = 2, then it is followed by three integers li, ri and mi (1 ≤ li ≤ ri ≤ n, - 5·107 ≤ mi ≤ 5·107) — the description of the operation of the second type.
The operations are given in the order Levko performed them on his array.
Output
In the first line print "YES" (without the quotes), if the solution exists and "NO" (without the quotes) otherwise.
If the solution exists, then on the second line print n integers a1, a2, ... , an (|ai| ≤ 109) — the recovered array.
Examples
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 8
Output
YES
4 7 4 7
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 13
Output
NO
Submitted Solution:
```
n, k = map(int, input().split())
a = [[] for i in range(k)]
ans = [0]*n
for i in range(k):
t,l,r,d = map(int, input().split())
a[i].append(t)
a[i].append(l-1)
a[i].append(r-1)
a[i].append(d)
#print(*a)
for i in range(k-1, -1, -1):
if a[i][0] == 2:
for j in range(a[i][1],a[i][2]+1):
if ans[j] == max(ans[j:a[i][2]+1]):
ans[j] = a[i][3]
elif ans[j]>a[i][3]:
print('NO')
exit()
else:
for j in range(a[i][1],a[i][2]+1):
ans[j]=max(0,ans[j]-a[i][3])
print(*ans)
``` | instruction | 0 | 57,454 | 12 | 114,908 |
No | output | 1 | 57,454 | 12 | 114,909 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Levko loves array a1, a2, ... , an, consisting of integers, very much. That is why Levko is playing with array a, performing all sorts of operations with it. Each operation Levko performs is of one of two types:
1. Increase all elements from li to ri by di. In other words, perform assignments aj = aj + di for all j that meet the inequation li ≤ j ≤ ri.
2. Find the maximum of elements from li to ri. That is, calculate the value <image>.
Sadly, Levko has recently lost his array. Fortunately, Levko has records of all operations he has performed on array a. Help Levko, given the operation records, find at least one suitable array. The results of all operations for the given array must coincide with the record results. Levko clearly remembers that all numbers in his array didn't exceed 109 in their absolute value, so he asks you to find such an array.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 5000) — the size of the array and the number of operations in Levko's records, correspondingly.
Next m lines describe the operations, the i-th line describes the i-th operation. The first integer in the i-th line is integer ti (1 ≤ ti ≤ 2) that describes the operation type. If ti = 1, then it is followed by three integers li, ri and di (1 ≤ li ≤ ri ≤ n, - 104 ≤ di ≤ 104) — the description of the operation of the first type. If ti = 2, then it is followed by three integers li, ri and mi (1 ≤ li ≤ ri ≤ n, - 5·107 ≤ mi ≤ 5·107) — the description of the operation of the second type.
The operations are given in the order Levko performed them on his array.
Output
In the first line print "YES" (without the quotes), if the solution exists and "NO" (without the quotes) otherwise.
If the solution exists, then on the second line print n integers a1, a2, ... , an (|ai| ≤ 109) — the recovered array.
Examples
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 8
Output
YES
4 7 4 7
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 13
Output
NO
Submitted Solution:
```
n, k = map(int, input().split())
a = [[] for i in range(k)]
ans = [0]*n
for i in range(k):
t,l,r,d = map(int, input().split())
a[i].append(t)
a[i].append(l-1)
a[i].append(r-1)
a[i].append(d)
#print(*a)
for i in range(k-1, -1, -1):
if a[i][0] == 2:
for j in range(a[i][1],a[i][2]+1):
if ans[j] == max(ans[j:a[i][2]+1]):
ans[j] = a[i][3]
elif ans[j]>a[i][3]:
print('NO')
exit()
else:
for j in range(a[i][1],a[i][2]+1):
ans[j]=max(0,ans[j]-a[i][3])
print('YES')
print(*ans)
``` | instruction | 0 | 57,455 | 12 | 114,910 |
No | output | 1 | 57,455 | 12 | 114,911 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Levko loves array a1, a2, ... , an, consisting of integers, very much. That is why Levko is playing with array a, performing all sorts of operations with it. Each operation Levko performs is of one of two types:
1. Increase all elements from li to ri by di. In other words, perform assignments aj = aj + di for all j that meet the inequation li ≤ j ≤ ri.
2. Find the maximum of elements from li to ri. That is, calculate the value <image>.
Sadly, Levko has recently lost his array. Fortunately, Levko has records of all operations he has performed on array a. Help Levko, given the operation records, find at least one suitable array. The results of all operations for the given array must coincide with the record results. Levko clearly remembers that all numbers in his array didn't exceed 109 in their absolute value, so he asks you to find such an array.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 5000) — the size of the array and the number of operations in Levko's records, correspondingly.
Next m lines describe the operations, the i-th line describes the i-th operation. The first integer in the i-th line is integer ti (1 ≤ ti ≤ 2) that describes the operation type. If ti = 1, then it is followed by three integers li, ri and di (1 ≤ li ≤ ri ≤ n, - 104 ≤ di ≤ 104) — the description of the operation of the first type. If ti = 2, then it is followed by three integers li, ri and mi (1 ≤ li ≤ ri ≤ n, - 5·107 ≤ mi ≤ 5·107) — the description of the operation of the second type.
The operations are given in the order Levko performed them on his array.
Output
In the first line print "YES" (without the quotes), if the solution exists and "NO" (without the quotes) otherwise.
If the solution exists, then on the second line print n integers a1, a2, ... , an (|ai| ≤ 109) — the recovered array.
Examples
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 8
Output
YES
4 7 4 7
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 13
Output
NO
Submitted Solution:
```
n, m = map(int, input().split())
a = [1e9] * n
extra = [0] * n
query = list()
for _ in range(m):
t, l, r, x = map(int, input().split())
l -= 1
r -= 1
query.append((t, l, r, x))
if t == 1:
for j in range(l, r+1):
extra[j] += x
else:
for j in range(l, r+1):
a[j] = min(a[j], x - extra[j])
extra = a.copy()
for t, l, r, x in query:
if t == 1:
for j in range(l, r+1):
a[j] += x
else:
val = -10**9
for j in range(l, r+1):
val = max(val, a[j])
if not val == x:
print('NO')
exit()
print('YES')
print(*extra)
``` | instruction | 0 | 57,456 | 12 | 114,912 |
No | output | 1 | 57,456 | 12 | 114,913 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Levko loves array a1, a2, ... , an, consisting of integers, very much. That is why Levko is playing with array a, performing all sorts of operations with it. Each operation Levko performs is of one of two types:
1. Increase all elements from li to ri by di. In other words, perform assignments aj = aj + di for all j that meet the inequation li ≤ j ≤ ri.
2. Find the maximum of elements from li to ri. That is, calculate the value <image>.
Sadly, Levko has recently lost his array. Fortunately, Levko has records of all operations he has performed on array a. Help Levko, given the operation records, find at least one suitable array. The results of all operations for the given array must coincide with the record results. Levko clearly remembers that all numbers in his array didn't exceed 109 in their absolute value, so he asks you to find such an array.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 5000) — the size of the array and the number of operations in Levko's records, correspondingly.
Next m lines describe the operations, the i-th line describes the i-th operation. The first integer in the i-th line is integer ti (1 ≤ ti ≤ 2) that describes the operation type. If ti = 1, then it is followed by three integers li, ri and di (1 ≤ li ≤ ri ≤ n, - 104 ≤ di ≤ 104) — the description of the operation of the first type. If ti = 2, then it is followed by three integers li, ri and mi (1 ≤ li ≤ ri ≤ n, - 5·107 ≤ mi ≤ 5·107) — the description of the operation of the second type.
The operations are given in the order Levko performed them on his array.
Output
In the first line print "YES" (without the quotes), if the solution exists and "NO" (without the quotes) otherwise.
If the solution exists, then on the second line print n integers a1, a2, ... , an (|ai| ≤ 109) — the recovered array.
Examples
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 8
Output
YES
4 7 4 7
Input
4 5
1 2 3 1
2 1 2 8
2 3 4 7
1 1 3 3
2 3 4 13
Output
NO
Submitted Solution:
```
def operacao(tipo, l, r, d):
if (tipo == 1):
for i in range(l, r + 1):
mod[i] += d
else:
cont = 0
for i in range(l, r + 1):
x = d - mod[i]
if (x < array[i]):
array[i] = x
if (x > array[i]): cont += 1
if (cont == r + 1 - l):
return False
return True
s = input().split()
n = int(s[0])
m = int(s[1])
deu = True
array = [float("inf")] * n
mod = [0] * n
for i in range(0, m):
s = list(map(int, input().split()))
if (not operacao(s[0], s[1] - 1, s[2] - 1, s[3])):
deu = False
break
if (deu):
print("YES")
for i in range(0, n):
print(array[i], end=" ")
print()
else:
print("NO")
``` | instruction | 0 | 57,457 | 12 | 114,914 |
No | output | 1 | 57,457 | 12 | 114,915 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a1, a2, ..., an.
Determine a real number x such that the weakness of the sequence a1 - x, a2 - x, ..., an - x is as small as possible.
The weakness of a sequence is defined as the maximum value of the poorness over all segments (contiguous subsequences) of a sequence.
The poorness of a segment is defined as the absolute value of sum of the elements of segment.
Input
The first line contains one integer n (1 ≤ n ≤ 200 000), the length of a sequence.
The second line contains n integers a1, a2, ..., an (|ai| ≤ 10 000).
Output
Output a real number denoting the minimum possible weakness of a1 - x, a2 - x, ..., an - x. Your answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
3
1 2 3
Output
1.000000000000000
Input
4
1 2 3 4
Output
2.000000000000000
Input
10
1 10 2 9 3 8 4 7 5 6
Output
4.500000000000000
Note
For the first case, the optimal value of x is 2 so the sequence becomes - 1, 0, 1 and the max poorness occurs at the segment "-1" or segment "1". The poorness value (answer) equals to 1 in this case.
For the second sample the optimal value of x is 2.5 so the sequence becomes - 1.5, - 0.5, 0.5, 1.5 and the max poorness occurs on segment "-1.5 -0.5" or "0.5 1.5". The poorness value (answer) equals to 2 in this case. | instruction | 0 | 57,556 | 12 | 115,112 |
Tags: ternary search
Correct Solution:
```
def main():
input()
a = list(map(int, input().split()))
def f(a):
maxend = maxnow = 0
for x in a:
maxend = max(0, maxend + x)
maxnow = max(maxnow, maxend)
return maxnow
f1 = lambda x: f(i - x for i in a)
f2 = lambda x: f(x - i for i in a)
Max = max(abs(i) for i in a)
L, R = -Max, Max
eps = 10 ** -8
for i in range(100):
m = (L + R) / 2
v1, v2 = f1(m), f2(m)
if abs(v1 - v2) < eps:
break
if v1 > v2:
L = m
else:
R = m
print(v1)
main()
``` | output | 1 | 57,556 | 12 | 115,113 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a1, a2, ..., an.
Determine a real number x such that the weakness of the sequence a1 - x, a2 - x, ..., an - x is as small as possible.
The weakness of a sequence is defined as the maximum value of the poorness over all segments (contiguous subsequences) of a sequence.
The poorness of a segment is defined as the absolute value of sum of the elements of segment.
Input
The first line contains one integer n (1 ≤ n ≤ 200 000), the length of a sequence.
The second line contains n integers a1, a2, ..., an (|ai| ≤ 10 000).
Output
Output a real number denoting the minimum possible weakness of a1 - x, a2 - x, ..., an - x. Your answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
3
1 2 3
Output
1.000000000000000
Input
4
1 2 3 4
Output
2.000000000000000
Input
10
1 10 2 9 3 8 4 7 5 6
Output
4.500000000000000
Note
For the first case, the optimal value of x is 2 so the sequence becomes - 1, 0, 1 and the max poorness occurs at the segment "-1" or segment "1". The poorness value (answer) equals to 1 in this case.
For the second sample the optimal value of x is 2.5 so the sequence becomes - 1.5, - 0.5, 0.5, 1.5 and the max poorness occurs on segment "-1.5 -0.5" or "0.5 1.5". The poorness value (answer) equals to 2 in this case. | instruction | 0 | 57,557 | 12 | 115,114 |
Tags: ternary search
Correct Solution:
```
def max_sum(x):
ans = now = 0
for v in a:
now += v - x
now = max(now, 0)
ans = max(ans, now)
return ans
def min_sum(x):
ans = now = 0
for v in a:
now += v - x
now = min(now, 0)
ans = min(ans, now)
return ans
n = int(input())
a = [int(x) for x in input().split()]
l = min(a)
r = max(a)
for _ in range(50):
x = (r + l) / 2
A = abs(max_sum(x))
B = abs(min_sum(x))
if A < B:
r = x
else:
l = x
print(max(A, B))
``` | output | 1 | 57,557 | 12 | 115,115 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a1, a2, ..., an.
Determine a real number x such that the weakness of the sequence a1 - x, a2 - x, ..., an - x is as small as possible.
The weakness of a sequence is defined as the maximum value of the poorness over all segments (contiguous subsequences) of a sequence.
The poorness of a segment is defined as the absolute value of sum of the elements of segment.
Input
The first line contains one integer n (1 ≤ n ≤ 200 000), the length of a sequence.
The second line contains n integers a1, a2, ..., an (|ai| ≤ 10 000).
Output
Output a real number denoting the minimum possible weakness of a1 - x, a2 - x, ..., an - x. Your answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
3
1 2 3
Output
1.000000000000000
Input
4
1 2 3 4
Output
2.000000000000000
Input
10
1 10 2 9 3 8 4 7 5 6
Output
4.500000000000000
Note
For the first case, the optimal value of x is 2 so the sequence becomes - 1, 0, 1 and the max poorness occurs at the segment "-1" or segment "1". The poorness value (answer) equals to 1 in this case.
For the second sample the optimal value of x is 2.5 so the sequence becomes - 1.5, - 0.5, 0.5, 1.5 and the max poorness occurs on segment "-1.5 -0.5" or "0.5 1.5". The poorness value (answer) equals to 2 in this case. | instruction | 0 | 57,558 | 12 | 115,116 |
Tags: ternary search
Correct Solution:
```
def max_sum(nums, shift):
res = 0
res_m = 0
cur_sum = 0
cur_m_sum = 0
for i in range(len(nums)):
cur_sum += (nums[i] + shift)
cur_m_sum += (nums[i] + shift)
res = max(res, cur_sum)
cur_sum = max(0, cur_sum)
res_m = min(res_m, cur_m_sum)
cur_m_sum = min(0, cur_m_sum)
return res, -res_m
def weaks(nums, shift):
return max_sum(nums, shift)
def main():
int(input())
nums = list(map(int, input().split()))
l = -10000
r = 10000
ans = max(weaks(nums, 0))
w1 = 1
w2 = -1
PREC = 10**-6
while abs(w1 - w2) >= PREC and abs(w1 - w2) > PREC * max(w1, w2):
m = (r + l)/2
# print (w1,w2,r,l,m)
w1, w2 = weaks(nums, m)
# print(w1, w2)
if w1 > w2:
r = m
else:
l = m
print ((w1 + w2) / 2)
# print (weaks([1,2,3],-2500.0))
main()
``` | output | 1 | 57,558 | 12 | 115,117 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a1, a2, ..., an.
Determine a real number x such that the weakness of the sequence a1 - x, a2 - x, ..., an - x is as small as possible.
The weakness of a sequence is defined as the maximum value of the poorness over all segments (contiguous subsequences) of a sequence.
The poorness of a segment is defined as the absolute value of sum of the elements of segment.
Input
The first line contains one integer n (1 ≤ n ≤ 200 000), the length of a sequence.
The second line contains n integers a1, a2, ..., an (|ai| ≤ 10 000).
Output
Output a real number denoting the minimum possible weakness of a1 - x, a2 - x, ..., an - x. Your answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
3
1 2 3
Output
1.000000000000000
Input
4
1 2 3 4
Output
2.000000000000000
Input
10
1 10 2 9 3 8 4 7 5 6
Output
4.500000000000000
Note
For the first case, the optimal value of x is 2 so the sequence becomes - 1, 0, 1 and the max poorness occurs at the segment "-1" or segment "1". The poorness value (answer) equals to 1 in this case.
For the second sample the optimal value of x is 2.5 so the sequence becomes - 1.5, - 0.5, 0.5, 1.5 and the max poorness occurs on segment "-1.5 -0.5" or "0.5 1.5". The poorness value (answer) equals to 2 in this case. | instruction | 0 | 57,559 | 12 | 115,118 |
Tags: ternary search
Correct Solution:
```
def weakness(a, x):
a = [elem-x for elem in a]
acumulado = maximo = 0
for elem in a:
if acumulado + elem > 0:
acumulado += elem
else:
acumulado = 0
if acumulado > maximo:
maximo = acumulado
acumulado = minimo = 0
for elem in a:
if acumulado + elem < 0:
acumulado += elem
else:
acumulado = 0
if acumulado < minimo:
minimo = acumulado
return max(maximo, -minimo)
n, a = input(), list(map(int, input().split()))
inf, sup = min(a), max(a)
for _ in range(70):
c1, c2 = (2*inf+sup)/3, (inf+2*sup)/3
if weakness(a, c1) < weakness(a, c2):
sup = c2
else:
inf = c1
print(weakness(a, (inf+sup)/2))
``` | output | 1 | 57,559 | 12 | 115,119 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a1, a2, ..., an.
Determine a real number x such that the weakness of the sequence a1 - x, a2 - x, ..., an - x is as small as possible.
The weakness of a sequence is defined as the maximum value of the poorness over all segments (contiguous subsequences) of a sequence.
The poorness of a segment is defined as the absolute value of sum of the elements of segment.
Input
The first line contains one integer n (1 ≤ n ≤ 200 000), the length of a sequence.
The second line contains n integers a1, a2, ..., an (|ai| ≤ 10 000).
Output
Output a real number denoting the minimum possible weakness of a1 - x, a2 - x, ..., an - x. Your answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
3
1 2 3
Output
1.000000000000000
Input
4
1 2 3 4
Output
2.000000000000000
Input
10
1 10 2 9 3 8 4 7 5 6
Output
4.500000000000000
Note
For the first case, the optimal value of x is 2 so the sequence becomes - 1, 0, 1 and the max poorness occurs at the segment "-1" or segment "1". The poorness value (answer) equals to 1 in this case.
For the second sample the optimal value of x is 2.5 so the sequence becomes - 1.5, - 0.5, 0.5, 1.5 and the max poorness occurs on segment "-1.5 -0.5" or "0.5 1.5". The poorness value (answer) equals to 2 in this case. | instruction | 0 | 57,560 | 12 | 115,120 |
Tags: ternary search
Correct Solution:
```
""" Python 3 compatibility tools. """
from __future__ import division, print_function
import itertools
import sys
import os
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
input = raw_input
range = xrange
filter = itertools.ifilter
map = itertools.imap
zip = itertools.izip
def is_it_local():
script_dir = str(os.getcwd()).split('/')
username = "dipta007"
return username in script_dir
def READ(fileName):
if is_it_local():
sys.stdin = open(f'./{fileName}', 'r')
# 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")
if not is_it_local():
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
def input1(type=int):
return type(input())
def input2(type=int):
[a, b] = list(map(type, input().split()))
return a, b
def input3(type=int):
[a, b, c] = list(map(type, input().split()))
return a, b, c
def input_array(type=int):
return list(map(type, input().split()))
def input_string():
s = input()
return list(s)
if is_it_local():
def debug(*args):
st = ""
for arg in args:
st += f"{arg} "
print(st)
else:
def debug(*args):
pass
##############################################################
arr = []
def fun(x):
cum = 0
res = 0
for v in arr:
nw = (v-x)
cum += nw
cum = max(cum, 0)
res = max(res, cum)
# print(v, nw, cum, res)
cum = 0
for v in arr:
nw = -(v-x)
cum += nw
cum = max(cum, 0)
res = max(res, cum)
# print(v, nw, cum, res)
return res
def main():
global arr
n = input1()
arr = input_array()
low = -10000
high = 10000
loop = 100
# print(fun(2.0))
# return
while loop > 0:
loop -= 1
m1 = ( low * 2.0 + high ) / 3.0
m2 = ( low + high * 2.0) / 3.0
y1 = fun(m1)
y2 = fun(m2)
# print(y1, y2)
if y1 > y2:
low = m1
else:
high = m2
# print("res", low, high, (low + high) / 2.0)
print(fun((low + high) / 2.0))
pass
if __name__ == '__main__':
# READ('in.txt')
main()
``` | output | 1 | 57,560 | 12 | 115,121 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a1, a2, ..., an.
Determine a real number x such that the weakness of the sequence a1 - x, a2 - x, ..., an - x is as small as possible.
The weakness of a sequence is defined as the maximum value of the poorness over all segments (contiguous subsequences) of a sequence.
The poorness of a segment is defined as the absolute value of sum of the elements of segment.
Input
The first line contains one integer n (1 ≤ n ≤ 200 000), the length of a sequence.
The second line contains n integers a1, a2, ..., an (|ai| ≤ 10 000).
Output
Output a real number denoting the minimum possible weakness of a1 - x, a2 - x, ..., an - x. Your answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
3
1 2 3
Output
1.000000000000000
Input
4
1 2 3 4
Output
2.000000000000000
Input
10
1 10 2 9 3 8 4 7 5 6
Output
4.500000000000000
Note
For the first case, the optimal value of x is 2 so the sequence becomes - 1, 0, 1 and the max poorness occurs at the segment "-1" or segment "1". The poorness value (answer) equals to 1 in this case.
For the second sample the optimal value of x is 2.5 so the sequence becomes - 1.5, - 0.5, 0.5, 1.5 and the max poorness occurs on segment "-1.5 -0.5" or "0.5 1.5". The poorness value (answer) equals to 2 in this case. | instruction | 0 | 57,561 | 12 | 115,122 |
Tags: ternary search
Correct Solution:
```
n = int(input())
A = list(map(int,input().split()))
def f(A,x,sign=1):
cur = 0
mn = 0
ans = -1<<32
if sign == 1:
for y in A:
cur += y-x
ans = max(ans, cur - mn)
mn = min(cur, mn)
else:
for y in A:
cur -= y-x
ans = max(ans, cur - mn)
mn = min(cur, mn)
return ans
lo,hi = -10000,10000
nt = 100
while nt:
nt -= 1
mid = (lo+hi)/2
X = f(A,mid,sign=1)
Y = f(A,mid,sign=-1)
if X > Y:
lo = mid
else:
hi = mid
print(abs(f(A,lo)))
``` | output | 1 | 57,561 | 12 | 115,123 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a1, a2, ..., an.
Determine a real number x such that the weakness of the sequence a1 - x, a2 - x, ..., an - x is as small as possible.
The weakness of a sequence is defined as the maximum value of the poorness over all segments (contiguous subsequences) of a sequence.
The poorness of a segment is defined as the absolute value of sum of the elements of segment.
Input
The first line contains one integer n (1 ≤ n ≤ 200 000), the length of a sequence.
The second line contains n integers a1, a2, ..., an (|ai| ≤ 10 000).
Output
Output a real number denoting the minimum possible weakness of a1 - x, a2 - x, ..., an - x. Your answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
3
1 2 3
Output
1.000000000000000
Input
4
1 2 3 4
Output
2.000000000000000
Input
10
1 10 2 9 3 8 4 7 5 6
Output
4.500000000000000
Note
For the first case, the optimal value of x is 2 so the sequence becomes - 1, 0, 1 and the max poorness occurs at the segment "-1" or segment "1". The poorness value (answer) equals to 1 in this case.
For the second sample the optimal value of x is 2.5 so the sequence becomes - 1.5, - 0.5, 0.5, 1.5 and the max poorness occurs on segment "-1.5 -0.5" or "0.5 1.5". The poorness value (answer) equals to 2 in this case. | instruction | 0 | 57,562 | 12 | 115,124 |
Tags: ternary search
Correct Solution:
```
def cal(x, li, sign):
sum = 0
ans = 0
for i in range(0,n):
sum += (li[i]-x)*sign
if sum < 0:
sum = 0
if sum > ans:
ans = sum
return ans
n = int(input())
li = [int(x) for x in input().split()]
r = max(li)
l = min(li)
ans = -1
mn = 99999999
for i in range(30):
k = (r+l)/2
a1 = cal(k, li, 1)
a2 = cal(k, li, -1)
if abs(a1) < abs(a2):
r = k
else:
l = k
if abs(abs(a1)-abs(a2)) < mn:
mn = abs(abs(a1)-abs(a2))
ans = abs(a1)
if abs(a2) > abs(a1):
ans = abs(a1)
#print('a1='+str(a1))
#print('a2='+str(a2))
if r-l < 1e-6:
break
print(ans)
``` | output | 1 | 57,562 | 12 | 115,125 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a sequence of n integers a1, a2, ..., an.
Determine a real number x such that the weakness of the sequence a1 - x, a2 - x, ..., an - x is as small as possible.
The weakness of a sequence is defined as the maximum value of the poorness over all segments (contiguous subsequences) of a sequence.
The poorness of a segment is defined as the absolute value of sum of the elements of segment.
Input
The first line contains one integer n (1 ≤ n ≤ 200 000), the length of a sequence.
The second line contains n integers a1, a2, ..., an (|ai| ≤ 10 000).
Output
Output a real number denoting the minimum possible weakness of a1 - x, a2 - x, ..., an - x. Your answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
3
1 2 3
Output
1.000000000000000
Input
4
1 2 3 4
Output
2.000000000000000
Input
10
1 10 2 9 3 8 4 7 5 6
Output
4.500000000000000
Note
For the first case, the optimal value of x is 2 so the sequence becomes - 1, 0, 1 and the max poorness occurs at the segment "-1" or segment "1". The poorness value (answer) equals to 1 in this case.
For the second sample the optimal value of x is 2.5 so the sequence becomes - 1.5, - 0.5, 0.5, 1.5 and the max poorness occurs on segment "-1.5 -0.5" or "0.5 1.5". The poorness value (answer) equals to 2 in this case. | instruction | 0 | 57,563 | 12 | 115,126 |
Tags: ternary search
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
def f(x):
mx, cur = 0, 0
for i in range(n):
cur = max(cur, 0) + a[i] - x
mx = max(mx, cur)
cur = 0
for i in range(n):
cur = max(cur, 0) + x - a[i]
mx = max(mx, cur)
return mx
L, R = min(a), max(a) + 1
for t in range(100):
d = (R - L) / 3
x1, x2 = L + d, R - d
if f(x1) > f(x2):
L = x1
else:
R = x2
print('{:.10f}'.format(f(L)))
``` | output | 1 | 57,563 | 12 | 115,127 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a sequence of n integers a1, a2, ..., an.
Determine a real number x such that the weakness of the sequence a1 - x, a2 - x, ..., an - x is as small as possible.
The weakness of a sequence is defined as the maximum value of the poorness over all segments (contiguous subsequences) of a sequence.
The poorness of a segment is defined as the absolute value of sum of the elements of segment.
Input
The first line contains one integer n (1 ≤ n ≤ 200 000), the length of a sequence.
The second line contains n integers a1, a2, ..., an (|ai| ≤ 10 000).
Output
Output a real number denoting the minimum possible weakness of a1 - x, a2 - x, ..., an - x. Your answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
3
1 2 3
Output
1.000000000000000
Input
4
1 2 3 4
Output
2.000000000000000
Input
10
1 10 2 9 3 8 4 7 5 6
Output
4.500000000000000
Note
For the first case, the optimal value of x is 2 so the sequence becomes - 1, 0, 1 and the max poorness occurs at the segment "-1" or segment "1". The poorness value (answer) equals to 1 in this case.
For the second sample the optimal value of x is 2.5 so the sequence becomes - 1.5, - 0.5, 0.5, 1.5 and the max poorness occurs on segment "-1.5 -0.5" or "0.5 1.5". The poorness value (answer) equals to 2 in this case.
Submitted Solution:
```
n = int(input())
A = list(map(int, input().split()))
def max_subarray(A):
max_ending_here = max_so_far = 0
for x in A:
max_ending_here = max(0, max_ending_here + x)
max_so_far = max(max_so_far, max_ending_here)
return max_so_far
def f1(x):
return max_subarray(a-x for a in A)
def f2(x):
return max_subarray(-a+x for a in A)
m = max(abs(a) for a in A)
l, r = -m, m
for _ in range(100):
mid = (l+r) / 2
v1, v2 = f1(mid), f2(mid)
if abs(v1 - v2) < 1e-8:
break
elif v1 > v2:
l = mid
else:
r = mid
print(v1)
``` | instruction | 0 | 57,565 | 12 | 115,130 |
Yes | output | 1 | 57,565 | 12 | 115,131 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3 | instruction | 0 | 57,635 | 12 | 115,270 |
Tags: dfs and similar, dsu, math
Correct Solution:
```
#####################################
import atexit, io, sys, collections, math, heapq, fractions,copy, os
from io import BytesIO, IOBase
##################################### python 3 START
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")
##################################### python 3 END
#AHIMOTUVWXY
#[bd][i][lmo][u][vwx]
n,k = list(map(int, input().split()))
pis = list(map(int, input().split()))
parent =[i for i in range(n)]
size = [1 for i in range(n)]
def f(u,parent):
if parent[u] != u:
parent[u] = f(parent[u],parent)
return parent[u]
for i in range(k):
u,v = list(map(int, input().split()))
u-=1
v-=1
pu,pv = f(u,parent), f(v,parent)
if pu != pv:
if size[pu] <= size[pv]:
parent[pu] = pv
size[pv] += size[pu]
else:
parent[pv] = pu
size[pu] += size[pv]
cc = collections.defaultdict(list)
for u in range(len(pis)):
cc[f(u,parent)].append(pis[u])
h = {}
for k in cc:
cc[k].sort()
h[k] = len(cc[k])
for u in range(len(pis)):
pu = f(u,parent)
h[pu] -= 1
pis[u] = cc[pu][h[pu]]
print (' '.join(list(map(str,pis))))
``` | output | 1 | 57,635 | 12 | 115,271 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3 | instruction | 0 | 57,636 | 12 | 115,272 |
Tags: dfs and similar, dsu, math
Correct Solution:
```
import sys
n, m = map(int, sys.stdin.buffer.readline().decode('utf-8').split(' '))
a = list(map(int, sys.stdin.buffer.readline().decode('utf-8').split(' ')))
adj = [[] for _ in range(n)]
for u, v in (map(int, line.decode('utf-8').split()) for line in sys.stdin.buffer):
adj[u-1].append(v-1)
adj[v-1].append(u-1)
visited = [0]*n
for i in range(n):
if visited[i]:
continue
visited[i] = 1
num = [a[i]]
i_list = [i]
stack = [i]
while stack:
v = stack.pop()
for dest in adj[v]:
if not visited[dest]:
visited[dest] = 1
num.append(a[dest])
i_list.append(dest)
stack.append(dest)
num.sort(reverse=True)
i_list.sort()
for j, v in zip(i_list, num):
a[j] = v
sys.stdout.buffer.write(' '.join(map(str, a)).encode('utf-8'))
``` | output | 1 | 57,636 | 12 | 115,273 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3 | instruction | 0 | 57,637 | 12 | 115,274 |
Tags: dfs and similar, dsu, math
Correct Solution:
```
from collections import defaultdict
import sys
input = sys.stdin.readline
N, M = map(int, input().split())
parent = [i for i in range(N)]
rank = [0] * N
def find(i):
if parent[i] == i:
return i
else:
parent[i] = find(parent[i])
return parent[i]
def same(x, y):
return find(x) == find(y)
def unite(x, y):
x = find(x)
y = find(y)
if x == y:
return
if rank[x] > rank[y]:
parent[y] = x
else:
parent[x] = y
if rank[x] == rank[y]:
rank[y] += 1
P = list(map(int, input().split()))
for i in range(M):
a, b = map(int, input().split())
a, b = a - 1, b - 1
unite(a, b)
d = defaultdict(list)
cnt = defaultdict(int)
for i in range(N):
d[find(i)].append(P[i])
for i in range(N):
if find(i) == i:
d[i] = sorted(d[i], reverse=True)
ans = []
for i in range(N):
k = find(i)
ans.append(d[k][cnt[k]])
cnt[k] += 1
print(' '.join(map(str, ans)))
``` | output | 1 | 57,637 | 12 | 115,275 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3 | instruction | 0 | 57,638 | 12 | 115,276 |
Tags: dfs and similar, dsu, math
Correct Solution:
```
from sys import stdout, stdin, setrecursionlimit
from bisect import insort,bisect_right,bisect_left
from io import BytesIO, IOBase
from collections import *
from itertools import *
from random import *
from string import *
from queue import *
from heapq import *
from math import *
from re import *
from os import *
####################################---fast-input-output----#########################################
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, 8192))
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, 8192))
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)
graph, mod, szzz = {}, 10**9 + 7, lambda: sorted(zzz())
def getStr(): return input()
def getInt(): return int(input())
def listStr(): return list(input())
def getStrs(): return input().split()
def isInt(s): return '0' <= s[0] <= '9'
def input(): return stdin.readline().strip()
def zzz(): return [int(i) for i in input().split()]
def output(answer, end='\n'): stdout.write(str(answer) + end)
def lcd(xnum1, xnum2): return (xnum1 * xnum2 // gcd(xnum1, xnum2))
def primeNums():
N = 10**5
SN = int(sqrt(N))
sieve = [i for i in range(N+1)]
sieve[1] = 0
for i in sieve:
if i > SN:
break
if i == 0:
continue
for j in range(2*i, N+1, i):
sieve[j] = 0
prime = [i for i in range(N+1) if sieve[i] != 0]
return prime
def primeFactor(n):
lst = []
mx=int(sqrt(n))+1
for i in prime:
if i>mx:break
while n%i==0:
lst.append(i)
n//=i
if n>1:
lst.append(n)
return lst
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
daysInMounth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
#################################################---Some Rule For Me To Follow---#################################
"""
--instants of Reading problem continuously try to understand them.
--If you Know some-one , Then you probably don't know him !
--Try & again try, maybe you're just one statement away!
"""
##################################################---START-CODING---###############################################
n,m = zzz()
arr = [0]+zzz()
for i in range(n):
graph[i+1]=[]
for _ in range(m):
x,y=zzz()
graph[x].append(y)
graph[y].append(x)
vis = [0]*(n+1)
# print(graph)
def dfs(u):
lst = [arr[u]]
ind = [u]
que = deque([u])
vis[u] = 1
while que:
p=que.pop()
for i in graph[p]:
if vis[i]:continue
lst.append(arr[i])
vis[i]=1
ind.append(i)
que.append(i)
lst = sorted(lst,reverse=True)
ind = sorted(ind)
# print(lst)
# print(ind)
for i,j in zip(lst,ind):
arr[j]=i
for i in range(1,n+1):
if vis[i]:continue
dfs(i)
for i in range(1,n+1):
output(arr[i],' ')
print()
``` | output | 1 | 57,638 | 12 | 115,277 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3 | instruction | 0 | 57,639 | 12 | 115,278 |
Tags: dfs and similar, dsu, math
Correct Solution:
```
from collections import defaultdict as df
from sys import stdin,stdout
from collections import deque
p=set()
n,m=list(map(int,stdin.readline().split()))
a=list(map(int,stdin.readline().rstrip().split()))
a.insert(0,0)
d=df(list)
visited=[0]*(n+1)
for i in range(m):
c,l=list(map(int,stdin.readline().split()))
if c==l:
continue
if (min(c,l),max(c,l)) not in p:
p.add((min(c,l),max(c,l)))
d[c].append(l)
d[l].append(c)
mainans=[0]*(n+1)
#print(d)
#print(d)
for i in range(1,n+1):
if visited[i]==False:
ans=[]
motagota=[]
#print(i)
h=deque()
ans.append(a[i])
motagota.append(i)
visited[i]=True
h.append(i)
#print(h)
while(len(h)>0):
g=h.pop()
for j in d[g]:
if visited[j]==False:
visited[j]=True
ans.append(a[j])
motagota.append(j)
h.append(j)
#print(ans)
#print(ans)
ans.sort(reverse=True)
motagota.sort()
for j in range(len(ans)):
mainans[motagota[j]]=ans[j]
mainans.pop(0)
for i in range(len(mainans)):
stdout.write(str(mainans[i])+' ')
``` | output | 1 | 57,639 | 12 | 115,279 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3 | instruction | 0 | 57,640 | 12 | 115,280 |
Tags: dfs and similar, dsu, math
Correct Solution:
```
from sys import stdout, stdin, setrecursionlimit
from bisect import insort,bisect_right,bisect_left
from io import BytesIO, IOBase
from collections import *
from itertools import *
from random import *
from string import *
from queue import *
from heapq import *
from math import *
from re import *
from os import *
####################################---fast-input-output----#########################################
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, 8192))
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, 8192))
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)
graph, mod, szzz = {}, 10**9 + 7, lambda: sorted(zzz())
def getStr(): return input()
def getInt(): return int(input())
def listStr(): return list(input())
def getStrs(): return input().split()
def isInt(s): return '0' <= s[0] <= '9'
def input(): return stdin.readline().strip()
def zzz(): return [int(i) for i in input().split()]
def output(answer, end='\n'): stdout.write(str(answer) + end)
def lcd(xnum1, xnum2): return (xnum1 * xnum2 // gcd(xnum1, xnum2))
def primeNums():
N = 10**5
SN = int(sqrt(N))
sieve = [i for i in range(N+1)]
sieve[1] = 0
for i in sieve:
if i > SN:
break
if i == 0:
continue
for j in range(2*i, N+1, i):
sieve[j] = 0
prime = [i for i in range(N+1) if sieve[i] != 0]
return prime
def primeFactor(n):
lst = []
mx=int(sqrt(n))+1
for i in prime:
if i>mx:break
while n%i==0:
lst.append(i)
n//=i
if n>1:
lst.append(n)
return lst
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
daysInMounth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
#################################################---Some Rule For Me To Follow---#################################
"""
--instants of Reading problem continuously try to understand them.
--If you Know some-one , Then you probably don't know him !
--Try & again try, maybe you're just one statement away!
"""
##################################################---START-CODING---###############################################
n,m = zzz()
arr = [0]+zzz()
for i in range(n):
graph[i+1]=[]
for _ in range(m):
x,y=zzz()
graph[x].append(y)
graph[y].append(x)
vis = [0]*(n+1)
# print(graph)
def dfs(u):
lst = [arr[u]]
ind = [u]
que = deque([u])
vis[u] = 1
while que:
p=que.pop()
for i in graph[p]:
if vis[i]:continue
lst.append(arr[i])
vis[i]=1
ind.append(i)
que.append(i)
lst = sorted(lst,reverse=True)
ind = sorted(ind)
# print(lst)
# print(ind)
for i,j in zip(lst,ind):
arr[j]=i
for i in range(1,n+1):
if vis[i]:continue
dfs(i)
print(*arr[1:])
``` | output | 1 | 57,640 | 12 | 115,281 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3 | instruction | 0 | 57,641 | 12 | 115,282 |
Tags: dfs and similar, dsu, math
Correct Solution:
```
import sys
input=sys.stdin.readline
def make_set(v):
parent[v]=v
def find_set(v):
if v == parent[v]:
return v
else:
parent[v]=find_set(parent[v])
return parent[v]
def union_sets(a,b):
a = find_set(a)
b = find_set(b)
if a != b:
if rank[a]<rank[b]:
a,b=b,a
parent[b] = a
if rank[a]==rank[b]:
rank[a]+=1
n,m=list(map(int,input().split()))
arr=list(map(int,input().split()))
parent=[i for i in range(n)]
rank=[0]*(n)
for i in range(m):
a,b=list(map(int,input().split()))
a=a-1
b=b-1
union_sets(a,b)
b={}
for i in range(n):
if find_set(i) not in b.keys():
b[find_set(i)]=[]
b[find_set(i)].append(i)
e=[0]*n
for i in b:
b[i].sort()
c=[]
for j in range(len(b[i])):
c.append(arr[b[i][j]])
c.sort(reverse=True)
for j in range(len(b[i])):
e[b[i][j]]=c[j]
print(*e)
``` | output | 1 | 57,641 | 12 | 115,283 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3 | instruction | 0 | 57,642 | 12 | 115,284 |
Tags: dfs and similar, dsu, math
Correct Solution:
```
#####################################
import atexit, io, sys, collections, math, heapq, fractions,copy, os
from io import BytesIO, IOBase
##################################### python 3 START
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")
##################################### python 3 END
n,k = list(map(int, input().split()))
pis = list(map(int, input().split()))
parent,size =[i for i in range(n)] ,[1 for i in range(n)]
def f(u,parent):
if parent[u] != u: parent[u] = f(parent[u],parent)
return parent[u]
for _ in range(k):
u,v = list(map(int, input().split()))
u -=1
v -=1
pu,pv = f(u,parent), f(v,parent)
if pu != pv:
if size[pu] <= size[pv]:
parent[pu] = pv
size[pv] += size[pu]
else:
parent[pv] = pu
size[pu] += size[pv]
cc = collections.defaultdict(list)
for u in range(len(pis)):
cc[f(u,parent)].append(pis[u])
h = [0 for _ in range(n)]
for k in cc:
cc[k].sort()
h[k] = len(cc[k])
for u in range(len(pis)):
pu = f(u,parent)
h[pu] -= 1
pis[u] = cc[pu][h[pu]]
print (' '.join(list(map(str,pis))))
``` | output | 1 | 57,642 | 12 | 115,285 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3
Submitted Solution:
```
#------------------Important Modules------------------#
from sys import stdin,stdout
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import *
from random import *
from itertools import permutations
input=stdin.readline
prin=stdout.write
from random import sample
from collections import Counter,deque
from fractions import *
from math import sqrt,ceil,log2,gcd,cos,pi,floor
from copy import deepcopy
#dist=[0]*(n)
mod=10**9+7
mod2=998244353
class DisjSet:
def __init__(self, n):
self.rank = [1] * n
self.parent = [i for i in range(n)]
# Finds set of given item x
def find(self, x):
if (self.parent[x] != x):
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
# Do union of two sets represented
# by x and y.
def union(self, x, y):
# Find current sets of x and y
xset = self.find(x)
yset = self.find(y)
if xset == yset:
return
if self.rank[xset] < self.rank[yset]:
self.parent[xset] = yset
elif self.rank[xset] > self.rank[yset]:
self.parent[yset] = xset
else:
self.parent[yset] = xset
self.rank[xset] = self.rank[xset] + 1
def ps(n):
cp=0;lk=0;arr={}
lk=0;ap=n
cc=0
while n%2==0:
n=n//2
cc=1
if cc==1:
lk+=1
for ps in range(3,ceil(sqrt(n))+1,2):
#print(ps)
cc=0
while n%ps==0:
n=n//ps
cc=1
lk+=1 if cc==1 else 0
if n!=1:
lk+=1
if lk==1:
return False
#print(arr)
return True
#count=0
#dp=[[0 for i in range(m)] for j in range(n)]
#[int(x) for x in input().strip().split()]
def gcd(x, y):
while(y):
x, y = y, x % y
return x
# Driver Code
def factorials(n,r):
#This calculates ncr mod 10**9+7
slr=n;dpr=r
qlr=1;qs=1
mod=10**9+7
for ip in range(n-r+1,n):
qlr=(qlr*ip)%mod
for ij in range(1,r):
qs=(qs*ij)%mod
#print(qlr,qs)
ans=(qlr*modInverse(qs))%mod
return ans
def modInverse(b):
qr=10**9+7
return pow(b, qr - 2,qr)
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
def power(arr):
listrep = arr
subsets = []
for i in range(2**len(listrep)):
subset = []
for k in range(len(listrep)):
if i & 1<<k:
subset.append(listrep[k])
subsets.append(subset)
return subsets
def pda(n) :
list=[];su=0
for i in range(1, int(sqrt(n) + 1)) :
if (n % i == 0) :
if (n // i == i) :
list.append(i)
su+=i
else :
list.append(n//i);list.append(i)
su+=i;su+=n//i
# The list will be printed in reverse
return su
def dis(xa,ya,xb,yb):
return sqrt((xa-xb)**2+(ya-yb)**2)
#### END ITERATE RECURSION ####
#===============================================================================================
#----------Input functions--------------------#
def ii():
return int(input())
def ilist():
return [int(x) for x in input().strip().split()]
def islist():
return list(map(str,input().split().rstrip()))
def inp():
return input().strip()
def google(test):
return "Case #"+str(test)+": ";
def overlap(x1,y1,x2,y2):
if x2>y1:
return y1-x2
if y1>y2:
return y2-x2
return y1-x2;
###-------------------------CODE STARTS HERE--------------------------------###########
def dist(x1,y1,x2,y2):
return sqrt((x1-x2)**2+(y1-y2)**2)
def sieve(n):
prime = [True for i in range(n + 1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 1
prime[0]= False
prime[1]= False
ans=[]
for i in range(1,n+1):
if prime[i]:
ans.append(i)
return ans
def prod(arr):
n=len(arr)
k=1
for j in range(n):
k*=arr[j]
return k
def SumOfDigits(s):
su=0
while (s):
su+=s%10
s=s//10
return su
def std():
return stdout.flush()
#########################################################################################
#def valid(sec,hr,min,nano):
def finds(s):
att=0
i=1
while i<len(s):
att=int(s[:i])
j=i
cc=0
while j<len(s):
att+=1
sk=att
news=str(sk)
rr=len(news)
#print(i,j,news,rr,s[j:j+rr])
if news==s[j:j+rr]:
#print(i,j,news,rr,s[j:j+rr])
j+=rr
#continue
else:
cc=1
break
if cc==0:
return True
i+=1
return False
#print(finds('78910'))
arr=[]
for i in range(1,10001):
s=str(i)
j=i
while len(s)<=7:
j+=1
s+=str(j)
arr.append(int(s))
arr.sort()
def subs(arr):
res = set()
pre = {0}
for x in arr:
pre = {x | y for y in pre} | {x}
res |= pre
return len(res)
def sl(n):
return (n*(n+1))//2
#t=ii()
t=1
for pl in range(t):
n,m=ilist()
#arr=[0]
arr=ilist()
ob=DisjSet(n)
for i in range(m):
a,b=ilist()
a-=1;b-=1
ob.union(a,b)
finds=[0]*n
for i in range(n):
finds[i]=ob.find(i)
dicts={}
for i in range(n):
if finds[i] in dicts:
dicts[finds[i]].append(i)
else:
dicts[finds[i]]=[i]
brr=[0]*n
for ij in dicts:
temp=dicts[ij]
news=[]
for pj in temp:
news.append(arr[pj])
news.sort()
news=news[::-1]
co=0
for jj in temp:
brr[jj]=news[co]
co+=1
print(*brr)
``` | instruction | 0 | 57,643 | 12 | 115,286 |
Yes | output | 1 | 57,643 | 12 | 115,287 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3
Submitted Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def solve(n,p,path):
se, x, fin = [1] * (n + 1), 1, [0] * n
while x != len(se):
se[x], jj, curr, inde, vals = 0, 0, [x], [x - 1], [p[x - 1]]
while jj != len(curr):
zz = curr[jj]
for y in path[zz]:
if se[y]:
curr.append(y)
inde.append(y-1)
vals.append(p[y-1])
se[y] = 0
jj += 1
inde.sort()
vals.sort()
for ind, i in enumerate(inde):
fin[i] = vals[-ind - 1]
while x != n + 1 and not se[x]:
x += 1
for i in fin:
print(i, end=' ')
def main():
n, m = map(int, input().split())
p = list(map(int, input().split()))
path = [[] for _ in range(n + 1)]
for _ in range(m):
u1, v1 = map(int, input().split())
path[u1].append(v1)
path[v1].append(u1)
solve(n,p,path)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main()
``` | instruction | 0 | 57,644 | 12 | 115,288 |
Yes | output | 1 | 57,644 | 12 | 115,289 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3
Submitted Solution:
```
from collections import deque
def bfs(n):
q = deque()
q.append(n)
visited[n]=1
data = []
pos = []
while q:
top = q[0]
data.append(a[top-1])
pos.append(top-1)
q.popleft()
for x in v[top]:
if visited[x]==0:
q.append(x)
visited[x]=1
#print(data)
data.sort(reverse=True)
for i in range(len(data)):
a[pos[i]] = data[i]
return a
n,m = map(int,input().split())
a = list(map(int,input().split()))
visited = [0]*100
v = [[] for i in range(n+1)]
for _ in range(m):
x,y = map(int,input().split())
v[x].append(y)
v[y].append(x)
for i in range(1,n+1):
if visited[i]==0:
bfs(i)
print(" ".join(map(str,a)))
``` | instruction | 0 | 57,645 | 12 | 115,290 |
No | output | 1 | 57,645 | 12 | 115,291 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3
Submitted Solution:
```
def add_edge(G, u, v):
if G.get(aj):
G[aj].append(bj)
else:
G[aj] = [bj]
if G.get(bj):
G[bj].append(aj)
else:
G[bj] = [aj]
def conn_comp(G):
visited = [False] * len(G)
stack = []
set_cc = []
for u in G.keys():
cc =[]
if not visited[u]:
stack.append(u)
i = 0
while stack:
v = stack.pop()
for neighbor in G[v]:
if not visited[neighbor]:
stack.append(neighbor)
visited[v] = True
cc.append(v)
if cc:
set_cc.append(cc)
return set_cc
n,m = list( map(int, input().split()))
p = list( map(lambda x: int(x) - 1, input().split()))
G = {}
for j in range(m):
aj,bj = list( map(int, input().split()))
aj,bj = aj - 1, bj - 1 # making it zero index
add_edge(G,aj,bj)
set_cc = conn_comp(G)
# import numpy as np
# p_np = np.array(p)
# for cc in set_cc:
# p_np[cc] = np.sort(p_np[cc])[::-1]
# p = p_np.tolist()
for cc in set_cc:
temp = [p[i] for i in cc]
temp.sort(reverse=True)
for j,i in enumerate(cc):
p[i] = temp[j]
print(*p)
``` | instruction | 0 | 57,646 | 12 | 115,292 |
No | output | 1 | 57,646 | 12 | 115,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3
Submitted Solution:
```
nm = list(map(int, input().split()))
n = nm[0]
m = nm[1]
lst = list(map(int, input().split()))
dct = {}
for i in range(n):
dct[lst[i]] = i
parents = [i for i in range(10**6+1)]
ranks = [1 for i in range(10**6+1)]
def find_parent(n):
if(n == parents[n]):
return n
return find_parent(parents[n])
def union(n1, n2):
p1 = find_parent(n1)
p2 = find_parent(n2)
if(p1 == p2):
return None
if ranks[p1] > ranks[p2]:
parents[p2] = p1
ranks[p1] += ranks[p2]
else:
parents[p1] = p2
ranks[p2] += ranks[p1]
lst1 = [[] for i in range(10**6+1)]
res = [0 for i in range(10**6+1)]
for i in range(m):
ab = list(map(int, input().split()))
a = ab[0]
b = ab[1]
union(a,b)
for i in range(1, n+1):
par = find_parent(i)
lst1[par].append(i)
res[i] = par
for i in range(1, n+1):
x = lst1[res[i]][-1]
lst1[res[i]].pop()
res[i] = x
print(res[1:n+1])
``` | instruction | 0 | 57,647 | 12 | 115,294 |
No | output | 1 | 57,647 | 12 | 115,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a permutation of the numbers 1, 2, ..., n and m pairs of positions (aj, bj).
At each step you can choose a pair from the given positions and swap the numbers in that positions. What is the lexicographically maximal permutation one can get?
Let p and q be two permutations of the numbers 1, 2, ..., n. p is lexicographically smaller than the q if a number 1 ≤ i ≤ n exists, so pk = qk for 1 ≤ k < i and pi < qi.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 106) — the length of the permutation p and the number of pairs of positions.
The second line contains n distinct integers pi (1 ≤ pi ≤ n) — the elements of the permutation p.
Each of the last m lines contains two integers (aj, bj) (1 ≤ aj, bj ≤ n) — the pairs of positions to swap. Note that you are given a positions, not the values to swap.
Output
Print the only line with n distinct integers p'i (1 ≤ p'i ≤ n) — the lexicographically maximal permutation one can get.
Example
Input
9 6
1 2 3 4 5 6 7 8 9
1 4
4 7
2 5
5 8
3 6
6 9
Output
7 8 9 4 5 6 1 2 3
Submitted Solution:
```
def add_edge(G, u, v):
if G.get(aj):
G[aj].append(bj)
else:
G[aj] = [bj]
if G.get(bj):
G[bj].append(aj)
else:
G[bj] = [aj]
def conn_comp(G):
visited = [False] * len(G)
stack = []
set_cc = []
for u in G.keys():
cc =[]
if not visited[u]:
stack.append(u)
i = 0
while stack:
v = stack.pop()
for neighbor in G[v]:
if not visited[neighbor]:
stack.append(neighbor)
visited[v] = True
cc.append(v)
if cc:
set_cc.append(cc)
return set_cc
n,m = list( map(int, input().split()))
p = list( map(int, input().split()))
G = {}
for j in range(m):
aj,bj = list( map(int, input().split()))
aj,bj = aj - 1, bj - 1 # making it zero index
add_edge(G,aj,bj)
set_cc = conn_comp(G)
# import numpy as np
# p_np = np.array(p)
# for cc in set_cc:
# p_np[cc] = np.sort(p_np[cc])[::-1]
# p = p_np.tolist()
for cc in set_cc:
temp = [p[i] for i in cc]
temp.sort(reverse=True)
for j,i in enumerate(cc):
p[i] = temp[j]
print(*p)
``` | instruction | 0 | 57,648 | 12 | 115,296 |
No | output | 1 | 57,648 | 12 | 115,297 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an integer sequence A of length N and an integer K. You will perform the following operation on this sequence Q times:
* Choose a contiguous subsequence of length K, then remove the smallest element among the K elements contained in the chosen subsequence (if there are multiple such elements, choose one of them as you like).
Let X and Y be the values of the largest and smallest element removed in the Q operations. You would like X-Y to be as small as possible. Find the smallest possible value of X-Y when the Q operations are performed optimally.
Constraints
* 1 \leq N \leq 2000
* 1 \leq K \leq N
* 1 \leq Q \leq N-K+1
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K Q
A_1 A_2 ... A_N
Output
Print the smallest possible value of X-Y.
Examples
Input
5 3 2
4 3 1 5 2
Output
1
Input
10 1 6
1 1 2 3 5 8 13 21 34 55
Output
7
Input
11 7 5
24979445 861648772 623690081 433933447 476190629 262703497 211047202 971407775 628894325 731963982 822804784
Output
451211184 | instruction | 0 | 57,834 | 12 | 115,668 |
"Correct Solution:
```
import bisect
n,k,q = map(int,input().split())
a = list(map(int,input().split()))
if q == 1:
print(0)
exit()
ls = [-1,n]
b = sorted(((a[i],i) for i in range(n)))
ansls = [b[q-1][0]-b[0][0]]
space = [n]
qc = q
for i,x in enumerate(b):
for j in range(i,n):
idx = bisect.bisect_left(ls,b[j][1])
if space[idx-1] < k:
continue
qc -= 1
space[idx-1] -= 1
if qc == 0:
ansls.append(b[j][0]-x[0])
break
ins = bisect.bisect_left(ls,x[1])
ls.insert(ins,x[1])
space = []
qc = q
for j in range(1,i+3):
space.append(ls[j]-ls[j-1]-1)
print(min(ansls))
``` | output | 1 | 57,834 | 12 | 115,669 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an integer sequence A of length N and an integer K. You will perform the following operation on this sequence Q times:
* Choose a contiguous subsequence of length K, then remove the smallest element among the K elements contained in the chosen subsequence (if there are multiple such elements, choose one of them as you like).
Let X and Y be the values of the largest and smallest element removed in the Q operations. You would like X-Y to be as small as possible. Find the smallest possible value of X-Y when the Q operations are performed optimally.
Constraints
* 1 \leq N \leq 2000
* 1 \leq K \leq N
* 1 \leq Q \leq N-K+1
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K Q
A_1 A_2 ... A_N
Output
Print the smallest possible value of X-Y.
Examples
Input
5 3 2
4 3 1 5 2
Output
1
Input
10 1 6
1 1 2 3 5 8 13 21 34 55
Output
7
Input
11 7 5
24979445 861648772 623690081 433933447 476190629 262703497 211047202 971407775 628894325 731963982 822804784
Output
451211184 | instruction | 0 | 57,835 | 12 | 115,670 |
"Correct Solution:
```
n,k,q=map(int,input().split())
l=list(map(int,input().split()))
ans=10**10
for i in range(n):
x=l[i]
tmp=[]
z=[]
for j in range(n):
if l[j]>=x:
tmp.append(l[j])
if l[j]<x or j==n-1:
tmp.sort()
if len(tmp)-k+1>0:
z+=tmp[:len(tmp)-k+1]
tmp=[]
z.sort()
if len(z)>=q:
ans=min(ans,z[q-1]-x)
print(ans)
``` | output | 1 | 57,835 | 12 | 115,671 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an integer sequence A of length N and an integer K. You will perform the following operation on this sequence Q times:
* Choose a contiguous subsequence of length K, then remove the smallest element among the K elements contained in the chosen subsequence (if there are multiple such elements, choose one of them as you like).
Let X and Y be the values of the largest and smallest element removed in the Q operations. You would like X-Y to be as small as possible. Find the smallest possible value of X-Y when the Q operations are performed optimally.
Constraints
* 1 \leq N \leq 2000
* 1 \leq K \leq N
* 1 \leq Q \leq N-K+1
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K Q
A_1 A_2 ... A_N
Output
Print the smallest possible value of X-Y.
Examples
Input
5 3 2
4 3 1 5 2
Output
1
Input
10 1 6
1 1 2 3 5 8 13 21 34 55
Output
7
Input
11 7 5
24979445 861648772 623690081 433933447 476190629 262703497 211047202 971407775 628894325 731963982 822804784
Output
451211184 | instruction | 0 | 57,836 | 12 | 115,672 |
"Correct Solution:
```
from itertools import*
N,K,Q,*A=map(int,open(0).read().split())
s=sorted
print(min((s(sum((v[:max(0,len(v)-K+1)]for v in(k*s(v)for k,v in groupby(A,lambda a:a>=Y))),[]))[Q-1:]+[2e9])[0]-Y for Y in A))
``` | output | 1 | 57,836 | 12 | 115,673 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an integer sequence A of length N and an integer K. You will perform the following operation on this sequence Q times:
* Choose a contiguous subsequence of length K, then remove the smallest element among the K elements contained in the chosen subsequence (if there are multiple such elements, choose one of them as you like).
Let X and Y be the values of the largest and smallest element removed in the Q operations. You would like X-Y to be as small as possible. Find the smallest possible value of X-Y when the Q operations are performed optimally.
Constraints
* 1 \leq N \leq 2000
* 1 \leq K \leq N
* 1 \leq Q \leq N-K+1
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K Q
A_1 A_2 ... A_N
Output
Print the smallest possible value of X-Y.
Examples
Input
5 3 2
4 3 1 5 2
Output
1
Input
10 1 6
1 1 2 3 5 8 13 21 34 55
Output
7
Input
11 7 5
24979445 861648772 623690081 433933447 476190629 262703497 211047202 971407775 628894325 731963982 822804784
Output
451211184 | instruction | 0 | 57,837 | 12 | 115,674 |
"Correct Solution:
```
from itertools import groupby, chain
N, K, Q, *A = map(int, open(0).read().split())
ans = float("inf")
for Y in set(A):
G = (sorted(v) for k, v in groupby(A, key=lambda a: a >= Y) if k)
C = list(chain.from_iterable(v[:len(v) - K + 1]for v in G if len(v) >= K))
if len(C) >= Q:
C.sort()
X = C[Q - 1]
ans = min(ans, X - Y)
print(ans)
``` | output | 1 | 57,837 | 12 | 115,675 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an integer sequence A of length N and an integer K. You will perform the following operation on this sequence Q times:
* Choose a contiguous subsequence of length K, then remove the smallest element among the K elements contained in the chosen subsequence (if there are multiple such elements, choose one of them as you like).
Let X and Y be the values of the largest and smallest element removed in the Q operations. You would like X-Y to be as small as possible. Find the smallest possible value of X-Y when the Q operations are performed optimally.
Constraints
* 1 \leq N \leq 2000
* 1 \leq K \leq N
* 1 \leq Q \leq N-K+1
* 1 \leq A_i \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K Q
A_1 A_2 ... A_N
Output
Print the smallest possible value of X-Y.
Examples
Input
5 3 2
4 3 1 5 2
Output
1
Input
10 1 6
1 1 2 3 5 8 13 21 34 55
Output
7
Input
11 7 5
24979445 861648772 623690081 433933447 476190629 262703497 211047202 971407775 628894325 731963982 822804784
Output
451211184
Submitted Solution:
```
import heapq
N, K, Q = [int(_) for _ in input().split()]
A = [int(_) for _ in input().split()]
sA = sorted(A)
A += [-1]
ans = float('inf')
for amin in sA:
cand = []
dp = []
for i in range(N + 1):
a = A[i]
if a >= amin:
heapq.heappush(dp, a)
if len(dp) and a < amin:
m = len(dp) - K + 1
for _ in range(m):
heapq.heappush(cand, heapq.heappop(dp))
dp = []
y = float('inf')
if len(cand) < Q:
break
for _ in range(Q - 1):
heapq.heappop(cand)
ans = min(ans, heapq.heappop(cand) - amin)
print(ans)
``` | instruction | 0 | 57,842 | 12 | 115,684 |
Yes | output | 1 | 57,842 | 12 | 115,685 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which reads a sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and swap specified elements by a list of the following operation:
* swapRange($b, e, t$): For each integer $k$ ($0 \leq k < (e - b)$, swap element $(b + k)$ and element $(t + k)$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b_i < e_i \leq n$
* $0 \leq t_i < t_i + (e_i - b_i) \leq n$
* Given swap ranges do not overlap each other
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ...,\; a_{n-1}$
$q$
$b_1 \; e_1 \; t_1$
$b_2 \; e_2 \; t_2$
:
$b_{q} \; e_{q} \; t_{q}$
In the first line, $n$ (the number of elements in $A$) is given. In the second line, $a_i$ (each element in $A$) are given. In the third line, the number of queries $q$ is given and each query is given by three integers $b_i \; e_i \; t_i$ in the following $q$ lines.
Output
Print all elements of $A$ in a line after performing the given operations. Put a single space character between adjacency elements and a newline at the end of the last element.
Example
Input
11
1 2 3 4 5 6 7 8 9 10 11
1
1 4 7
Output
1 8 9 10 5 6 7 2 3 4 11 | instruction | 0 | 57,969 | 12 | 115,938 |
"Correct Solution:
```
def solve():
from sys import stdin
f_i = stdin
n = f_i.readline()
A = f_i.readline().split()
q = int(f_i.readline())
for i in range(q):
b, e, t = map(int, f_i.readline().split())
w = e - b
if b < t:
A = A[:b] + A[t:t+w] + A[b+w:t] + A[b:b+w] + A[t+w:]
else:
A = A[:t] + A[b:b+w] + A[t+w:b] + A[t:t+w] + A[b+w:]
print(' '.join(A))
solve()
``` | output | 1 | 57,969 | 12 | 115,939 |
Provide a correct Python 3 solution for this coding contest problem.
Write a program which reads a sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and swap specified elements by a list of the following operation:
* swapRange($b, e, t$): For each integer $k$ ($0 \leq k < (e - b)$, swap element $(b + k)$ and element $(t + k)$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b_i < e_i \leq n$
* $0 \leq t_i < t_i + (e_i - b_i) \leq n$
* Given swap ranges do not overlap each other
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ...,\; a_{n-1}$
$q$
$b_1 \; e_1 \; t_1$
$b_2 \; e_2 \; t_2$
:
$b_{q} \; e_{q} \; t_{q}$
In the first line, $n$ (the number of elements in $A$) is given. In the second line, $a_i$ (each element in $A$) are given. In the third line, the number of queries $q$ is given and each query is given by three integers $b_i \; e_i \; t_i$ in the following $q$ lines.
Output
Print all elements of $A$ in a line after performing the given operations. Put a single space character between adjacency elements and a newline at the end of the last element.
Example
Input
11
1 2 3 4 5 6 7 8 9 10 11
1
1 4 7
Output
1 8 9 10 5 6 7 2 3 4 11 | instruction | 0 | 57,970 | 12 | 115,940 |
"Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
q = int(input())
for _ in range(q):
b,e,t = map(int, input().split())
x = a[t:t+e-b]
a[t:t+e-b] = a[b:e]
a[b:e] = x
print(" ".join(map(str,a)))
``` | output | 1 | 57,970 | 12 | 115,941 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.