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 |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have array of n numbers a_{1}, a_{2}, …, a_{n}.
Rearrange these numbers to satisfy |a_{1} - a_{2}| ≤ |a_{2} - a_{3}| ≤ … ≤ |a_{n-1} - a_{n}|, where |x| denotes absolute value of x. It's always possible to find such rearrangement.
Note that all numbers in a are not necessarily different. In other words, some numbers of a may be same.
You have to answer independent t test cases.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^{4}) — the number of test cases.
The first line of each test case contains single integer n (3 ≤ n ≤ 10^{5}) — the length of array a. It is guaranteed that the sum of values of n over all test cases in the input does not exceed 10^{5}.
The second line of each test case contains n integers a_{1}, a_{2}, …, a_{n} (-10^{9} ≤ a_{i} ≤ 10^{9}).
Output
For each test case, print the rearranged version of array a which satisfies given condition. If there are multiple valid rearrangements, print any of them.
Example
Input
2
6
5 -2 4 8 6 5
4
8 1 4 2
Output
5 5 4 6 8 -2
1 2 4 8
Note
In the first test case, after given rearrangement, |a_{1} - a_{2}| = 0 ≤ |a_{2} - a_{3}| = 1 ≤ |a_{3} - a_{4}| = 2 ≤ |a_{4} - a_{5}| = 2 ≤ |a_{5} - a_{6}| = 10. There are other possible answers like "5 4 5 6 -2 8".
In the second test case, after given rearrangement, |a_{1} - a_{2}| = 1 ≤ |a_{2} - a_{3}| = 2 ≤ |a_{3} - a_{4}| = 4. There are other possible answers like "2 4 8 1".
Submitted Solution:
```
from functools import cmp_to_key
num = int(input())
def cmp(a,b):
global prev
if abs(int(a)-int(b)) < prev:
prev = abs(int(a)-int(b))
return -1
else:
return 1
for _ in range(num):
l = int(input())
lis = input().split(' ')
prev = 9e999
lis = sorted(lis,key=cmp_to_key(cmp))
print(' '.join(lis))
``` | instruction | 0 | 13,452 | 12 | 26,904 |
No | output | 1 | 13,452 | 12 | 26,905 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You have array of n numbers a_{1}, a_{2}, …, a_{n}.
Rearrange these numbers to satisfy |a_{1} - a_{2}| ≤ |a_{2} - a_{3}| ≤ … ≤ |a_{n-1} - a_{n}|, where |x| denotes absolute value of x. It's always possible to find such rearrangement.
Note that all numbers in a are not necessarily different. In other words, some numbers of a may be same.
You have to answer independent t test cases.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^{4}) — the number of test cases.
The first line of each test case contains single integer n (3 ≤ n ≤ 10^{5}) — the length of array a. It is guaranteed that the sum of values of n over all test cases in the input does not exceed 10^{5}.
The second line of each test case contains n integers a_{1}, a_{2}, …, a_{n} (-10^{9} ≤ a_{i} ≤ 10^{9}).
Output
For each test case, print the rearranged version of array a which satisfies given condition. If there are multiple valid rearrangements, print any of them.
Example
Input
2
6
5 -2 4 8 6 5
4
8 1 4 2
Output
5 5 4 6 8 -2
1 2 4 8
Note
In the first test case, after given rearrangement, |a_{1} - a_{2}| = 0 ≤ |a_{2} - a_{3}| = 1 ≤ |a_{3} - a_{4}| = 2 ≤ |a_{4} - a_{5}| = 2 ≤ |a_{5} - a_{6}| = 10. There are other possible answers like "5 4 5 6 -2 8".
In the second test case, after given rearrangement, |a_{1} - a_{2}| = 1 ≤ |a_{2} - a_{3}| = 2 ≤ |a_{3} - a_{4}| = 4. There are other possible answers like "2 4 8 1".
Submitted Solution:
```
import sys
input = sys.stdin.readline
def main():
t = int(input())
for _ in range(t):
N = int(input())
A = [int(x) for x in input().split()]
A.sort()
ans = []
for i in range(N // 2):
ans.append(A[-i - 1])
ans.append(A[1])
if N % 2 == 1:
ans.append(A[N // 2 + 1])
print(*reversed(ans))
if __name__ == '__main__':
main()
``` | instruction | 0 | 13,453 | 12 | 26,906 |
No | output | 1 | 13,453 | 12 | 26,907 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick has some permutation consisting of p integers from 1 to n. A segment [l, r] (l ≤ r) is a set of elements pi satisfying l ≤ i ≤ r.
Nick calls a pair of segments [a0, a1] and [b0, b1] (1 ≤ a0 ≤ a1 < b0 ≤ b1 ≤ n) good if all their (a1 - a0 + b1 - b0 + 2) elements, when sorted in ascending order, form an arithmetic progression with a difference of 1. That is, when they sorted in ascending order, the elements are in the form {x, x + 1, x + 2, ..., x + m - 1}, for some x and m.
Your task is to find the number of distinct pairs of good segments in the given permutation. Two pairs of segments are considered distinct if the sets of elements contained in these pairs of segments are distinct. For example, any segment [l, r] (l < r) can be represented as a pair of segments, as [l, i] and [i + 1, r] (l ≤ i ≤ r). As all these pairs consist of the same set of elements, they are considered identical.
See the notes accompanying the sample tests for clarification.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the permutation size. The second line contains n space-separated distinct integers pi, (1 ≤ pi ≤ n).
Output
Print a single integer — the number of good pairs of segments of permutation p.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 3
Output
3
Input
5
1 4 5 3 2
Output
10
Input
5
5 4 3 1 2
Output
10
Note
In the first sample the following pairs of segments are good: ([1, 1], [2, 2]); ([2, 2], [3, 3]); ([1, 2], [3, 3]). Pair of segments ([1, 1], [2, 3]) is by definition equivalent to pair ([1, 2], [3, 3]), since both of them covers the same set of elements, namely {1, 2, 3}.
In the third sample the following pairs of segments are good: ([4, 4], [5, 5]); ([3, 3],[4, 5]); ([2, 2],[3, 5]); ([1, 1],[2, 5]); ([3, 3],[5, 5]); ([2, 3],[5, 5]); ([1, 3],[5, 5]); ([2, 2],[3, 3]); ([1, 1],[2, 3]); ([1, 1],[2, 2]).
Submitted Solution:
```
a = int(input())
b = input()
print(a*(a-1)/2)
``` | instruction | 0 | 13,564 | 12 | 27,128 |
No | output | 1 | 13,564 | 12 | 27,129 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Nick has some permutation consisting of p integers from 1 to n. A segment [l, r] (l ≤ r) is a set of elements pi satisfying l ≤ i ≤ r.
Nick calls a pair of segments [a0, a1] and [b0, b1] (1 ≤ a0 ≤ a1 < b0 ≤ b1 ≤ n) good if all their (a1 - a0 + b1 - b0 + 2) elements, when sorted in ascending order, form an arithmetic progression with a difference of 1. That is, when they sorted in ascending order, the elements are in the form {x, x + 1, x + 2, ..., x + m - 1}, for some x and m.
Your task is to find the number of distinct pairs of good segments in the given permutation. Two pairs of segments are considered distinct if the sets of elements contained in these pairs of segments are distinct. For example, any segment [l, r] (l < r) can be represented as a pair of segments, as [l, i] and [i + 1, r] (l ≤ i ≤ r). As all these pairs consist of the same set of elements, they are considered identical.
See the notes accompanying the sample tests for clarification.
Input
The first line contains integer n (1 ≤ n ≤ 3·105) — the permutation size. The second line contains n space-separated distinct integers pi, (1 ≤ pi ≤ n).
Output
Print a single integer — the number of good pairs of segments of permutation p.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2 3
Output
3
Input
5
1 4 5 3 2
Output
10
Input
5
5 4 3 1 2
Output
10
Note
In the first sample the following pairs of segments are good: ([1, 1], [2, 2]); ([2, 2], [3, 3]); ([1, 2], [3, 3]). Pair of segments ([1, 1], [2, 3]) is by definition equivalent to pair ([1, 2], [3, 3]), since both of them covers the same set of elements, namely {1, 2, 3}.
In the third sample the following pairs of segments are good: ([4, 4], [5, 5]); ([3, 3],[4, 5]); ([2, 2],[3, 5]); ([1, 1],[2, 5]); ([3, 3],[5, 5]); ([2, 3],[5, 5]); ([1, 3],[5, 5]); ([2, 2],[3, 3]); ([1, 1],[2, 3]); ([1, 1],[2, 2]).
Submitted Solution:
```
a = int(input())
b = input()
print(int(a*(a-1)/2))
``` | instruction | 0 | 13,565 | 12 | 27,130 |
No | output | 1 | 13,565 | 12 | 27,131 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39 | instruction | 0 | 13,599 | 12 | 27,198 |
Tags: implementation
Correct Solution:
```
n,q=map(int,input().split())
a=list(map(int, input().split()))
b=0
s=''
for i in range(q):
l=list(map(int, input().split()))
if l[0]==3:
s+=str(a[l[1]-1]+b)+'\n'
elif l[0]==2:
b+=l[1]
elif l[0]==1:
a[l[1]-1]= l[2]-b
print(s)
``` | output | 1 | 13,599 | 12 | 27,199 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39 | instruction | 0 | 13,600 | 12 | 27,200 |
Tags: implementation
Correct Solution:
```
n,m=input().split()
a=input().split()
soma=0
dic ={}
total=0
for x in range(int(m)):
b=input().split()
v=int(b[1])
if(b[0]=="1"):
b[2]=int(b[2])
a[v-1]=b[2]
dic[v] = soma
elif(b[0]=="2"):
soma=soma+v
elif(b[0]=="3"):
if v in dic:
total =soma-dic[v]
print(int(a[v-1])+ total)
else:
print(int(a[v-1]) + soma)
``` | output | 1 | 13,600 | 12 | 27,201 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39 | instruction | 0 | 13,601 | 12 | 27,202 |
Tags: implementation
Correct Solution:
```
import sys
import itertools
import collections
def rs(x=''): return sys.stdin.readline().strip() if len(x) == 0 else input(x).strip()
def ri(x=''): return int(rs(x))
def rm(x=''): return map(str, rs(x).split())
def rl(x=''): return rs(x).split()
def rmi(x=''): return map(int, rs(x).split())
def rli(x=''): return [int(x) for x in rs(x).split()]
def println(val): sys.stdout.write(str(val) + '\n')
def solve(testCase):
n, m = rmi()
a = rli()
queries = [tuple(rmi()) for _ in range(m)]
add = 0
mark = [0] * n
inc = 0
for t, *operation in queries:
if t == 1:
vi, x = operation
vi -= 1
a[vi] = x
mark[vi] = -add
elif t == 2:
y = operation[0]
add += y
inc += 1
elif t == 3:
idx = operation[0]
idx -= 1
# print('!', add, a[idx], mark[idx])
print(add + a[idx] + mark[idx])
for _ in range(ri() if 0 else 1):
solve(_ + 1)
``` | output | 1 | 13,601 | 12 | 27,203 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39 | instruction | 0 | 13,602 | 12 | 27,204 |
Tags: implementation
Correct Solution:
```
n,m=map(int,input().split())
l=[int(x) for x in input().split()]
curr=0
for _ in range(m):
temp=input().split()
if temp[0]=="1":
x=int(temp[1])
y=int(temp[2])
l[x-1]=y
l[x-1]=l[x-1]-curr
elif temp[0]=="2":
curr+=int(temp[1])
else:
x=int(temp[1])
print(l[x-1]+curr)
``` | output | 1 | 13,602 | 12 | 27,205 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39 | instruction | 0 | 13,603 | 12 | 27,206 |
Tags: implementation
Correct Solution:
```
n, m = map(int, input().split())
arr = [int(i) for i in input().split()]
res, s = 0, ""
for i in range(m):
b = [int(x) for x in input().split()]
if b[0] == 1:
arr[b[1] - 1] = b[2] - res
elif b[0] == 2:
res += b[1]
else:
s += str(arr[b[1] - 1] + res) + '\n'
print(s)
``` | output | 1 | 13,603 | 12 | 27,207 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39 | instruction | 0 | 13,604 | 12 | 27,208 |
Tags: implementation
Correct Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
#from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
#from bisect import bisect_right as br #c++ upperbound br(array,element)
def main():
n,m=map(int,input().split(" "))
a=list(map(int,input().split(" ")))
op=[0 for x in range(n)]
cur=0
for x in range(m):
temp=list(map(int,input().split(" ")))
if temp[0]==1:
a[temp[1]-1]=temp[2]
op[temp[1]-1]=-cur
elif temp[0]==2:
cur+=temp[1]
else:
print(a[temp[1]-1]+op[temp[1]-1]+cur)
#-----------------------------BOSS-------------------------------------!
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
``` | output | 1 | 13,604 | 12 | 27,209 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39 | instruction | 0 | 13,605 | 12 | 27,210 |
Tags: implementation
Correct Solution:
```
"""
n=int(z())
for _ in range(int(z())):
x=int(z())
l=list(map(int,z().split()))
n=int(z())
l=sorted(list(map(int,z().split())))[::-1]
a,b=map(int,z().split())
l=set(map(int,z().split()))
led=(6,2,5,5,4,5,6,3,7,6)
vowel={'a':0,'e':0,'i':0,'o':0,'u':0}
color4=["G", "GB", "YGB", "YGBI", "OYGBI" ,"OYGBIV",'ROYGBIV' ]
"""
#!/usr/bin/env python
#pyrival orz
import os
import sys
from io import BytesIO, IOBase
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
def main():
try:
n, m = invr()
a = inlt()
s = 0
for _ in range(m):
t = inlt()
if t[0] == 1:
a[t[1]-1] = t[2] - s
elif t[0] == 2:
s += t[1]
else:
print(a[t[1]-1] + s)
except Exception as e:
print(e)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
``` | output | 1 | 13,605 | 12 | 27,211 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39 | instruction | 0 | 13,606 | 12 | 27,212 |
Tags: implementation
Correct Solution:
```
from sys import stdin, stdout
m=int(input().split()[1])
a=[int(x) for x in stdin.readline().split()]
s,o=0,''
for i in range(m):
x=[int(x) for x in stdin.readline().split()]
if x[0]==1:
a[x[1]-1]=x[2]-s
elif x[0]==2:
s+=x[1]
else:
o+=str(a[x[1]-1]+s)+'\n'
stdout.write(o)
``` | output | 1 | 13,606 | 12 | 27,213 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39
Submitted Solution:
```
n,m = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
query = []
for _ in range(m):
query.append([int(x) for x in input().split()])
add = [0 for i in range(n)]
netadd = 0
for q in query:
t = q[0]
v = q[1]
x = 0
if len(q) == 3:
x = q[2]
if t == 3:
print(arr[v -1]+netadd - add[v-1])
elif t == 2:
netadd += v
else:
arr[v-1] = x
add[v-1] = netadd
``` | instruction | 0 | 13,607 | 12 | 27,214 |
Yes | output | 1 | 13,607 | 12 | 27,215 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39
Submitted Solution:
```
n , m = map(int, input().split())
l = list(map(int, input().split()))
tmp,s = 0,""
for i in range(m):
op = list(map(int, input().split()))
if op[0] == 1:
l[op[1]-1] = op[-1] - tmp
elif op[0] == 2 :
tmp += op[-1]
else:
s+=f"{l[op[-1]-1]+tmp}\n"
print(s)
``` | instruction | 0 | 13,609 | 12 | 27,218 |
Yes | output | 1 | 13,609 | 12 | 27,219 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39
Submitted Solution:
```
n, m = [int(x) for x in input().split()]
lista = [int(x) for x in input().split()]
soma = 0
dic = {}
for i in range(m):
entrada = input().split()
a = entrada[0]
b = int(entrada[1])
if a == "1":
lista[b-1] = int(entrada[2])
dic[b] = soma
elif a == "2":
soma += b
elif a == "3":
if b in dic:
total = soma - dic[b]
print(lista[b-1] + total)
else:
print(lista[b-1] + soma)
``` | instruction | 0 | 13,610 | 12 | 27,220 |
Yes | output | 1 | 13,610 | 12 | 27,221 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39
Submitted Solution:
```
n, m = map(int, input().split())
a = [0] + list(map(int, input().split()))
S = 0
for i in range(m):
q = list(map(int, input().split()))
if q[0] == 3: print(a[q[1]] + S)
if q[0] == 2: S += q[1]
if q[0] == 1: a[q[1]] += q[2]
``` | instruction | 0 | 13,612 | 12 | 27,224 |
No | output | 1 | 13,612 | 12 | 27,225 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39
Submitted Solution:
```
n, m = map(int, input().split())
numbers = list(map(int, input().split()))
copy = [0] * n
results = []
accumulator = 0
for i in range(m):
inputs = input().split()
if inputs[0] == "3":
results.append(numbers[int(inputs[1])-1] + accumulator + copy[int(inputs[1])-1])
elif inputs[0] == "2":
accumulator += int(inputs[1])
else:
copy[int(inputs[1]) - 1] -= accumulator
numbers[int(inputs[1]) - 1] = int(inputs[2])
print(*results, sep="\n")
``` | instruction | 0 | 13,613 | 12 | 27,226 |
No | output | 1 | 13,613 | 12 | 27,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sereja has got an array, consisting of n integers, a1, a2, ..., an. Sereja is an active boy, so he is now going to complete m operations. Each operation will have one of the three forms:
1. Make vi-th array element equal to xi. In other words, perform the assignment avi = xi.
2. Increase each array element by yi. In other words, perform n assignments ai = ai + yi (1 ≤ i ≤ n).
3. Take a piece of paper and write out the qi-th array element. That is, the element aqi.
Help Sereja, complete all his operations.
Input
The first line contains integers n, m (1 ≤ n, m ≤ 105). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the original array.
Next m lines describe operations, the i-th line describes the i-th operation. The first number in the i-th line is integer ti (1 ≤ ti ≤ 3) that represents the operation type. If ti = 1, then it is followed by two integers vi and xi, (1 ≤ vi ≤ n, 1 ≤ xi ≤ 109). If ti = 2, then it is followed by integer yi (1 ≤ yi ≤ 104). And if ti = 3, then it is followed by integer qi (1 ≤ qi ≤ n).
Output
For each third type operation print value aqi. Print the values in the order, in which the corresponding queries follow in the input.
Examples
Input
10 11
1 2 3 4 5 6 7 8 9 10
3 2
3 9
2 10
3 1
3 10
1 1 10
2 10
2 10
3 1
3 10
3 9
Output
2
9
11
20
30
40
39
Submitted Solution:
```
x,k = input().split()
x = int(x)
k = int(k)
a = list(map(int,input().split()))
for i in range(k):
y = list(map(int,input().split()))
if(y[0] == 1):
a[y[1]] = y[2]
elif(y[0] == 2):
for j in range(x):
a[j] += y[1]
else:
print(a[y[1]-1])
``` | instruction | 0 | 13,614 | 12 | 27,228 |
No | output | 1 | 13,614 | 12 | 27,229 |
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 | 13,617 | 12 | 27,234 |
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 | 13,617 | 12 | 27,235 |
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 | 13,618 | 12 | 27,236 |
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 | 13,618 | 12 | 27,237 |
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 | 13,619 | 12 | 27,238 |
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 | 13,619 | 12 | 27,239 |
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 | 13,620 | 12 | 27,240 |
No | output | 1 | 13,620 | 12 | 27,241 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0 | instruction | 0 | 13,754 | 12 | 27,508 |
Tags: data structures
Correct Solution:
```
from bisect import *
d = [{}, {}]
i = [0, 0]
for q in range(int(input())):
a, t, x = map(int, input().split())
for k in [0, 1]:
d[k][x] = d[k].get(x, [])
i[k] = bisect(d[k][x], t)
if a < 3: d[-a][x].insert(i[-a], t)
else: print(i[1] - i[0])
``` | output | 1 | 13,754 | 12 | 27,509 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0 | instruction | 0 | 13,755 | 12 | 27,510 |
Tags: data structures
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
new = lambda xx: (xx|xx-1)+1
def buildBIT(bit,n):
for i in range(1,n+1):
x = new(i)
if x <= n:
bit[x] += bit[i]
def pointUpdate(bit,point,n,diff):
while point <= n:
bit[point] += diff
point = new(point)
def calculatePrefix(bit,point):
su = 0
while point:
su += bit[point]
point &= point-1
return su
def rangeQuery(bit,start,stop):
# [start,stop]
return calculatePrefix(bit,stop)-calculatePrefix(bit,start-1)
def compressCoordinate(lst):
return {i:ind+1 for ind,i in enumerate(sorted(set(lst)))}
def main():
from collections import defaultdict
n = int(input())
dct = defaultdict(list)
oper = [list(map(int,input().split())) for _ in range(n)]
for a,t,x in oper:
dct[x].append(t)
new = {i:compressCoordinate(dct[i]) for i in dct}
for i in range(n):
oper[i][1] = new[oper[i][2]][oper[i][1]]
bit = {i:[0]*(len(dct[i])+1) for i in dct}
for a,t,x in oper:
if a == 1:
pointUpdate(bit[x],t,len(bit[x])-1,1)
elif a == 2:
pointUpdate(bit[x],t,len(bit[x])-1,-1)
else:
print(calculatePrefix(bit[x],t))
# 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()
``` | output | 1 | 13,755 | 12 | 27,511 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0 | instruction | 0 | 13,756 | 12 | 27,512 |
Tags: data structures
Correct Solution:
```
from bisect import *
u, v = {}, {}
for q in range(int(input())):
a, t, x = map(int, input().split())
if x not in u: u[x], v[x] = [], []
if a < 3: insort([v, u][-a][x], t)
else: print(bisect(u[x], t) - bisect(v[x], t))
``` | output | 1 | 13,756 | 12 | 27,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0 | instruction | 0 | 13,757 | 12 | 27,514 |
Tags: data structures
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2**51, func=lambda a, b: a & b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n=int(input())
q=defaultdict(list)
que=[]
ind=defaultdict(list)
ans=defaultdict(int)
for i in range(n):
a,c,b=map(int,input().split())
ind[b].append(c)
q[b].append((a,c))
que.append((a,b,c))
for i in ind:
ind[i].sort()
inde=defaultdict(int)
for j in range(len(ind[i])):
inde[ind[i][j]]=j
e=[0]*len(ind[i])
s=SegmentTree(e)
for j in q[i]:
a,c=j
if a==1:
e[inde[c]]+=1
s.__setitem__(inde[c],e[inde[c]])
elif a==2:
e[inde[c]] -= 1
s.__setitem__(inde[c], e[inde[c]])
else:
ans[c]=s.query(0,inde[c])
for i in range(n):
a,b,c=que[i]
if a==3:
print(ans[c])
``` | output | 1 | 13,757 | 12 | 27,515 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
Submitted Solution:
```
n, c = int(input()), 0
a, t, x = [], [], []
for i in range(n):
ar = [int(i) for i in input().split()]
a.append(ar[0])
t.append(ar[1])
x.append(ar[2])
v = [0] * max(t)
for i in range(n):
if a[i] == 1:
v[t[i]-1] = x[i]
elif a[i] == 2:
for j in range(n):
if v[j] == x[i] and c < 1:
v[j] = 0
c += 1
elif a[i] == 3:
print(v.count(x[i]))
``` | instruction | 0 | 13,758 | 12 | 27,516 |
No | output | 1 | 13,758 | 12 | 27,517 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
Submitted Solution:
```
n = int(input())
command = []
for i in range(n):
command.append(input().split(' '))
temp = []
for i in range(n):
temp.append(int(command[i][1]))
m = max(temp)
state = [None]*m
for i in range(m):
state[i]=['n']
res = []
c = 0
for i in range(n):
a = int(command[i][0])
t = int(command[i][1])
x = int(command[i][2])
if a == 1:
if state[t-1][0] == 'n':
state[t-1][0] = x
else:
state[t-1].append(x)
elif a == 2:
for j in range(t):
if x in state[j]:
state[j].remove(x)
if len(state[j]) == 0:
state[j].append('n')
break
elif a == 3:
for j in range(t):
c += state[j].count(x)
res.append(c)
c=0
for i in range(len(res)):
print(res[i])
``` | instruction | 0 | 13,759 | 12 | 27,518 |
No | output | 1 | 13,759 | 12 | 27,519 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
Submitted Solution:
```
n = int(input())
command = []
for i in range(n):
command.append(input().split(' '))
temp = []
for i in range(n):
temp.append(int(command[i][1]))
m = max(temp)
state = [None]*m
for i in range(m):
state[i]=['n']
res = []
c = 0
for i in range(n):
a = int(command[i][0])
t = int(command[i][1])
x = int(command[i][2])
if a == 1:
if state[t-1][0] == 'n':
state[t-1][0] = x
else:
state[t-1].append(x)
elif a == 2:
for j in range(t):
if x in state[j]:
state[j].remove(x)
break
elif a == 3:
for j in range(t):
c += state[j].count(x)
res.append(c)
c=0
for i in range(len(res)):
print(res[i])
``` | instruction | 0 | 13,760 | 12 | 27,520 |
No | output | 1 | 13,760 | 12 | 27,521 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
Submitted Solution:
```
n = int(input())
command = []
for i in range(n):
command.append(input().split(' '))
temp = []
for i in range(n):
temp.append(int(command[i][1]))
m = max(temp)
state = [None]*m
for i in range(m):
state[i]=['n']
res = []
c = 0
for i in range(n):
a = int(command[i][0])
t = int(command[i][1])
x = int(command[i][2])
if a == 1:
if state[t-1][0] == 'n':
state[t-1][0] = x
else:
state[t-1].append(x)
elif a == 2:
for j in range(t):
if x in state[j]:
state[j].remove(x)
if len(state[j]) == 1:
state[j].append('n')
break
elif a == 3:
for j in range(t):
c += state[j].count(x)
res.append(c)
c=0
for i in range(len(res)):
print(res[i])
``` | instruction | 0 | 13,761 | 12 | 27,522 |
No | output | 1 | 13,761 | 12 | 27,523 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8 | instruction | 0 | 13,788 | 12 | 27,576 |
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
import sys
from array import array # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def prepare(n, *a):
acc = 0
sub_max = -10**9
left_min = 0
left_max = 0
lmin2, lmax2 = 0, -10**9
for i, x in enumerate(a):
acc += x
sub_max = max(sub_max, acc - left_min)
left_min = min(left_min, acc)
left_max = max(left_max, acc)
if i > 0:
lmax2 = max(lmax2, acc)
if i < n - 1:
lmin2 = min(lmin2, acc)
return left_min, left_max, acc, sub_max, lmin2, lmax2
n, m = map(int, input().split())
small_a = [(0, 0, 0, 0, 0, 0)]
for _ in range(n):
small_a.append(prepare(*map(int, input().split())))
indexes = tuple(map(int, input().split()))
left_min, _, acc, ans, left_min2, _ = small_a[indexes[0]]
for i in indexes[1:]:
ans = max(
ans,
small_a[i][3],
acc + small_a[i][1] - left_min2,
acc + small_a[i][5] - left_min
)
left_min2 = min(left_min, acc + small_a[i][4])
left_min = min(left_min, acc + small_a[i][0])
acc += small_a[i][2]
print(ans)
``` | output | 1 | 13,788 | 12 | 27,577 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8 | instruction | 0 | 13,789 | 12 | 27,578 |
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
if __name__ == "__main__":
i = input().split()
N = int(i[0])
M = int(i[1])
arrList = []
leftMax = []
rightMax = []
listTotal = []
rightSum = []
for i in range(N):
inputList = [int(x) for x in input().split()]
list = inputList[1:inputList[0] + 1]
listTotal.append(0)
leftMax.append(-999999)
rightMax.append(-999999)
rightSum.append(-999999)
rightIter = 0
for j in list:
listTotal[i] += j
rightIter += j
leftMax[i] = max(leftMax[i], listTotal[i])
rightSum[i] = max(rightSum[i], rightIter)
rightIter = 0 if rightIter < 0 else rightIter
rightMax[i] = rightIter
arrList.append(list)
idxOrder = [int(x) for x in input().split()][0:M]
maxSum = -99999999
currMax = 0
for i in idxOrder:
bestTot = max(maxSum, rightSum[i - 1])
bestSum = max(currMax + leftMax[i - 1], currMax + listTotal[i - 1])
maxSum = max(bestSum, bestTot)
currMax = max(currMax + listTotal[i - 1], rightMax[i - 1])
print(maxSum)
``` | output | 1 | 13,789 | 12 | 27,579 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8 | instruction | 0 | 13,790 | 12 | 27,580 |
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
def main():
n,m=map(int,input().split())
a=[]
for i in range(n):
b=list(map(int,input().split()))
pma,sma,su,su1=-1001,-1001,0,0
for j in range(1,len(b)):
su,su1=su+b[j],su1+b[-j]
pma=max(pma,su)
sma=max(sma,su1)
su,ma=0,max(b[1:])
for j in range(1,len(b)):
su=su+b[j]
ma=max(ma,su)
if su<0:
su=0
a.append((pma,ma,sma,su1))
ans=[-1001,-1001,-1001,0]
for i in input().split():
z=a[int(i)-1]
ans[0]=max(ans[0],ans[3]+z[0])
ans[1]=max(ans[1],ans[2]+z[0],z[1])
ans[2]=max(z[2],z[3]+ans[2])
ans[3]+=z[3]
print(max(ans))
# FAST INPUT OUTPUT 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()
``` | output | 1 | 13,790 | 12 | 27,581 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8 | instruction | 0 | 13,791 | 12 | 27,582 |
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
def main():
n,m=map(int,input().split())
a,ans=[],[-1001,-1001,-1001,0]
for i in range(n):
b=list(map(int,input().split()))
pma,sma,ma,su,su1,su2=-1001,-1001,-1001,0,0,0
for j in range(1,len(b)):
su,su1,su2=su+b[j],su1+b[-j],su2+b[j]
ma,pma,sma=max(ma,su2),max(pma,su),max(sma,su1)
su2=su2*(su2>0)
a.append((pma,ma,sma,su1))
for i in input().split():
z=a[int(i)-1]
ans=[max(ans[0],ans[3]+z[0]),max(ans[1],ans[2]+z[0],z[1]),max(z[2],z[3]+ans[2]),ans[3]+z[3]]
print(max(ans))
# FAST INPUT OUTPUT 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()
``` | output | 1 | 13,791 | 12 | 27,583 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8 | instruction | 0 | 13,792 | 12 | 27,584 |
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
n,m=map(int,input().split())
l=[]
d={}
e={}
for i in range(n):
l = list(map(int,input().split()))
a=l[1]
b=sum(l)-l[0]
c=l[-1]
x = l[1]
for j in range(2,len(l)):
x+=l[j]
a=max(a,x)
x = l[-1]
for j in range(len(l)-2,0,-1):
x+=l[j]
c=max(c,x)
d[i+1] = [a,b,c]
a=l[1]
b=0
for j in range(1,len(l)):
b+=l[j]
a=max(a,b)
if b<0:
b=0
e[i+1]=a
dp = [[0,0,0] for i in range(m)]
l=list(map(int,input().split()))
ans = 0
for i in range(m-1,-1,-1):
if i==m-1:
dp[i][0] = d[l[i]][0]
dp[i][1] =d[l[i]][1]
dp[i][2] = d[l[i]][2]
ans = max(max(dp[i][1],dp[i][0]),dp[i][2])
ans=max(ans,e[l[i]])
else:
dp[i][0] = d[l[i]][0]
dp[i][1] = d[l[i]][1] + max(max(0,dp[i+1][0]),dp[i+1][1])
dp[i][2] = d[l[i]][2] + max(max(0,dp[i+1][0]),dp[i+1][1])
ans=max(ans,dp[i][0])
ans=max(ans,dp[i][1])
ans=max(ans,dp[i][2])
ans=max(ans,e[l[i]])
print(ans)
``` | output | 1 | 13,792 | 12 | 27,585 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8 | instruction | 0 | 13,793 | 12 | 27,586 |
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
import sys
zz=1
sys.setrecursionlimit(10**5)
if zz:
input=sys.stdin.readline
else:
sys.stdin=open('input.txt', 'r')
sys.stdout=open('all.txt','w')
di=[[-1,0],[1,0],[0,1],[0,-1]]
def fori(n):
return [fi() for i in range(n)]
def inc(d,c,x=1):
d[c]=d[c]+x if c in d else x
def ii():
return input().rstrip()
def li():
return [int(xx) for xx in input().split()]
def fli():
return [float(x) for x in input().split()]
def comp(a,b):
if(a>b):
return 2
return 2 if a==b else 0
def gi():
return [xx for xx in input().split()]
def gtc(tc,ans):
print("Case #"+str(tc)+":",ans)
def cil(n,m):
return n//m+int(n%m>0)
def fi():
return int(input())
def pro(a):
return reduce(lambda a,b:a*b,a)
def swap(a,i,j):
a[i],a[j]=a[j],a[i]
def si():
return list(input().rstrip())
def mi():
return map(int,input().split())
def gh():
sys.stdout.flush()
def isvalid(i,j,n,m):
return 0<=i<n and 0<=j<m
def bo(i):
return ord(i)-ord('a')
def graph(n,m):
for i in range(m):
x,y=mi()
a[x].append(y)
a[y].append(x)
t=1
uu=t
while t>0:
t-=1
n,m=mi()
pm=[0]*n
sm=[0]*n
s=[0]*n
ans=[0]*n
for i in range(n):
a=li()
p=a[0]
a=a[1:]
maxi=-10**18;c=0
for j in range(p-1,-1,-1):
c+=a[j]
maxi=max(maxi,c)
sm[i]=maxi
s[i]=c
maxi=-10**18;c=0
for j in range(p):
c+=a[j]
maxi=max(maxi,c)
pm[i]=maxi
c=0;maxi=-10**18
for j in a:
if j>c+j:
c=j
else:
c+=j
maxi=max(maxi,c)
ans[i]=maxi
b=li()
maxi=-10**18;c=0
for i in b:
maxi=max([maxi,c+pm[i-1],ans[i-1]])
if sm[i-1]>c+s[i-1]:
c=sm[i-1]
else:
c+=s[i-1]
maxi=max(maxi,c)
if c<0:
c=0
print(maxi)
``` | output | 1 | 13,793 | 12 | 27,587 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8 | instruction | 0 | 13,794 | 12 | 27,588 |
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
def get_best(arr):
ans, now = -(1 << 64), 0
for i in arr:
now += i
ans = max(ans, now)
if (now < 0): now = 0
return ans
def compute(arr):
ans, now = -(1 << 64), 0
for i in arr:
now += i
ans = max(ans, now)
return ans
n, m = map(int, input().split())
vals = []
suffix, prefix, summation, best = [0] * n, [0] * n, [0] * n, [0] * n
for i in range(n):
arr = list(map(int, input().split()))[1:]
summation[i] = sum(arr)
suffix[i] = compute(list(reversed(arr)))
prefix[i] = compute(arr)
best[i] = get_best(arr)
vals.append(arr)
idx = list(map(lambda x: int(x) - 1, input().split()))
f = [[0 for x in range(m + 1)] for p in range(2)]
f[0][m] = -(1 << 64)
i = m - 1
while i >= 0:
cur = idx[i]
f[0][i] = max(max(f[0][i + 1], best[cur]), suffix[cur] + f[1][i + 1])
f[1][i] = max(prefix[cur], summation[cur] + f[1][i + 1])
i -= 1
print(f[0][0])
``` | output | 1 | 13,794 | 12 | 27,589 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8 | instruction | 0 | 13,795 | 12 | 27,590 |
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
def main():
n,m=map(int,input().split())
a,ans=[],[-1001,-1001,-1001,0]
for i in range(n):
b=list(map(int,input().split()))
pma,sma,ma,su,su1,su2=-1001,-1001,-1001,0,0,0
for j in range(1,len(b)):
su,su1=su+b[j],su1+b[-j]
pma,sma=max(pma,su),max(sma,su1)
for j in range(1,len(b)):
su2=su2+b[j]
ma=max(ma,su2)
su2=su2*(su2>0)
a.append((pma,ma,sma,su1))
for i in input().split():
z=a[int(i)-1]
ans=[max(ans[0],ans[3]+z[0]),max(ans[1],ans[2]+z[0],z[1]),max(z[2],z[3]+ans[2]),ans[3]+z[3]]
print(max(ans))
# FAST INPUT OUTPUT 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()
``` | output | 1 | 13,795 | 12 | 27,591 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Submitted Solution:
```
if __name__ == "__main__":
i = input().split()
N = int(i[0])
M = int(i[1])
arrList = []
for i in range(N):
list = [int(x) for x in input().split()]
arrList.append(list[1:])
idxOrder = [int(x) for x in input().split()][0:M]
maxSum = 0
currMax = 0
for i in idxOrder:
for j in arrList[i - 1]:
currMax = max(j, currMax + j)
maxSum = max(currMax, maxSum)
print(1)
``` | instruction | 0 | 13,796 | 12 | 27,592 |
No | output | 1 | 13,796 | 12 | 27,593 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Submitted Solution:
```
def main():
n, m = map(int, input().split())
d = {}
dp = []
res = 0
for i in range(1, n + 1):
d[i] = [int(k) for k in input().split()][1:]
indices = [int(k) for k in input().split()]
x = 1
for i in range(len(indices)):
for val in d[indices[i]]:
if not dp:
dp.append(val)
else:
dp.append(max(val + dp[x - 1], val))
x += 1
res = max(res, dp[-1])
print(res)
main()
``` | instruction | 0 | 13,797 | 12 | 27,594 |
No | output | 1 | 13,797 | 12 | 27,595 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Submitted Solution:
```
def main():
n, m = map(int, input().split())
d = {}
dp = []
res = 0
for i in range(1, n + 1):
d[i] = input().split()[1:]
indices = input().split()
for i in range(len(indices)):
if int(indices[i]) in d:
for val in d[int(indices[i])]:
val = int(val)
if not dp:
dp.append(val)
x = 1
else:
dp.append(max(val + dp[x - 1], val))
x += 1
res = max(res, dp[-1])
print(res)
main()
``` | instruction | 0 | 13,798 | 12 | 27,596 |
No | output | 1 | 13,798 | 12 | 27,597 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 ≤ n ≤ 50), and m is the number of indexes in the big array (1 ≤ m ≤ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 ≤ l ≤ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Submitted Solution:
```
def main():
n, m = map(int, input().split())
d = {}
dp = []
res = 0
for i in range(1, n + 1):
d[i] = [int(k) for k in input().split()][1:]
indices = [int(k) for k in input().split()]
if not indices:
return 0
setup = d[indices[0]]
dp.append(setup[0])
x = 1
for i in range(1, len(setup)):
res = max(res, dp[-1])
dp.append(max(setup[i] + dp[x - 1], setup[i]))
x += 1
for i in range(1, len(indices)):
for val in d[indices[i]]:
res = max(res, dp[-1])
dp.append(max(val + dp[x - 1], val))
x += 1
print(res)
main()
``` | instruction | 0 | 13,799 | 12 | 27,598 |
No | output | 1 | 13,799 | 12 | 27,599 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of positive integers and q queries to this array. There are two types of queries:
* 1 l r x — for each index i such that l ≤ i ≤ r set ai = x.
* 2 l r — find the minimum among such ai that l ≤ i ≤ r.
We decided that this problem is too easy. So the array a is given in a compressed form: there is an array b consisting of n elements and a number k in the input, and before all queries a is equal to the concatenation of k arrays b (so the size of a is n·k).
Input
The first line contains two integers n and k (1 ≤ n ≤ 105, 1 ≤ k ≤ 104).
The second line contains n integers — elements of the array b (1 ≤ bi ≤ 109).
The third line contains one integer q (1 ≤ q ≤ 105).
Then q lines follow, each representing a query. Each query is given either as 1 l r x — set all elements in the segment from l till r (including borders) to x (1 ≤ l ≤ r ≤ n·k, 1 ≤ x ≤ 109) or as 2 l r — find the minimum among all elements in the segment from l till r (1 ≤ l ≤ r ≤ n·k).
Output
For each query of type 2 print the answer to this query — the minimum on the corresponding segment.
Examples
Input
3 1
1 2 3
3
2 1 3
1 1 2 4
2 1 3
Output
1
3
Input
3 2
1 2 3
5
2 4 4
1 4 4 5
2 4 4
1 1 6 1
2 6 6
Output
1
5
1
Submitted Solution:
```
from sys import stdin, stdout
n, k = map(int, stdin.readline().split())
values = [0] + list(map(int, stdin.readline().split()))
m = int(stdin.readline())
questions = []
ar = set()
for i in range(m):
questions.append(tuple(map(int, stdin.readline().strip().split())))
ar.add(int(questions[-1][1]))
ar.add(int(questions[-1][2]))
compress = [0]
ar = sorted(list(ar))
counting = {}
d = {}
for i in range(len(ar)):
compress.append(ar[i])
d[ar[i]] = len(compress) - 1
if i != len(ar) - 1 and ar[i + 1] - ar[i] > 1:
compress.append(ar[i] + 1)
counting[len(compress) - 1] = float('inf')
d[ar[i] + 1] = len(compress) - 1
mn = min(values)
for ind in counting:
if (compress[ind + 1] - compress[ind - 1] - 1 >= n):
counting[ind] = mn
else:
for j in range(compress[ind - 1] + 1, compress[ind + 1]):
counting[ind] = min(counting[ind], values[j % n + n * (not(j % n))])
def update(l, r, ind, lb, rb, value):
if updating[ind] and ind * 2 < len(tree):
if (not updating[ind * 2] or (updating[ind * 2][1] < updating[ind][1])):
tree[ind * 2] = updating[ind][0]
updating[ind * 2] = updating[ind][::]
if (not updating[ind * 2 + 1] or (updating[ind * 2 + 1][1] < updating[ind][1])):
tree[ind * 2 + 1] = updating[ind][0]
updating[ind * 2 + 1] = updating[ind][::]
updating[ind] = 0
if (l == lb and r == rb):
tree[ind] = value
if (ind * 2 < len(tree)):
tree[ind * 2], tree[ind * 2 + 1] = value, value
updating[ind * 2], updating[ind * 2 + 1] = (value, time), (value, time)
while ind != 1:
ind //= 2
tree[ind] = min(tree[ind * 2], tree[ind * 2 + 1])
else:
m = (lb + rb) // 2
if (l <= m):
update(l, min(m, r), ind * 2, lb, m, value)
if (r > m):
update(max(l, m + 1), r, ind * 2 + 1, m + 1, rb, value)
def get(l, r, ind, lb, rb):
if updating[ind] and ind * 2 < len(tree):
if (not updating[ind * 2] or (updating[ind * 2][1] < updating[ind][1])):
tree[ind * 2] = updating[ind][0]
updating[ind * 2] = updating[ind][::]
if (not updating[ind * 2 + 1] or (updating[ind * 2 + 1][1] < updating[ind][1])):
tree[ind * 2 + 1] = updating[ind][0]
updating[ind * 2 + 1] = updating[ind][::]
updating[ind] = 0
if (l == lb and r == rb):
return tree[ind]
else:
m = (lb + rb) // 2
ans = float('inf')
if (l <= m):
ans = get(l, min(m, r), ind * 2, lb, m)
if (r > m):
ans = min(ans, get(max(l, m + 1), r, ind * 2 + 1, m + 1, rb))
return ans
def getvalue(ind):
if (ind < len(compress)):
return (values[compress[ind] % n + n * (not(compress[ind] % n))])
else:
return 0
size = 1
while (size < len(ar) * 2):
size *= 2
tree = [float('inf') for i in range(2 * size)]
updating = [0 for i in range (2 * size)]
for i in range(size, 2 * size):
if i - size + 1 in counting:
tree[i] = counting[i - size + 1]
else:
tree[i] = getvalue(i - size + 1)
for i in range(size - 1, 0, -1):
tree[i] = min(tree[i * 2], tree[i * 2 + 1])
for time in range(m):
if questions[time][0] == 1:
update(d[questions[time][1]], d[questions[time][2]], 1, 1, size, questions[time][-1])
else:
stdout.write(str(get(d[questions[time][1]], d[questions[time][2]], 1, 1, size)) + '\n')
'''
10 10
4 2 3 8 1 2 1 7 5 4
1
2 13 16
'''
``` | instruction | 0 | 13,816 | 12 | 27,632 |
No | output | 1 | 13,816 | 12 | 27,633 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of positive integers and q queries to this array. There are two types of queries:
* 1 l r x — for each index i such that l ≤ i ≤ r set ai = x.
* 2 l r — find the minimum among such ai that l ≤ i ≤ r.
We decided that this problem is too easy. So the array a is given in a compressed form: there is an array b consisting of n elements and a number k in the input, and before all queries a is equal to the concatenation of k arrays b (so the size of a is n·k).
Input
The first line contains two integers n and k (1 ≤ n ≤ 105, 1 ≤ k ≤ 104).
The second line contains n integers — elements of the array b (1 ≤ bi ≤ 109).
The third line contains one integer q (1 ≤ q ≤ 105).
Then q lines follow, each representing a query. Each query is given either as 1 l r x — set all elements in the segment from l till r (including borders) to x (1 ≤ l ≤ r ≤ n·k, 1 ≤ x ≤ 109) or as 2 l r — find the minimum among all elements in the segment from l till r (1 ≤ l ≤ r ≤ n·k).
Output
For each query of type 2 print the answer to this query — the minimum on the corresponding segment.
Examples
Input
3 1
1 2 3
3
2 1 3
1 1 2 4
2 1 3
Output
1
3
Input
3 2
1 2 3
5
2 4 4
1 4 4 5
2 4 4
1 1 6 1
2 6 6
Output
1
5
1
Submitted Solution:
```
from sys import stdin, stdout
n, k = map(int, stdin.readline().split())
values = [0] + list(map(int, stdin.readline().split()))
m = int(stdin.readline())
questions = []
ar = set()
for i in range(m):
questions.append(tuple(map(int, stdin.readline().strip().split())))
ar.add(int(questions[-1][1]))
ar.add(int(questions[-1][2]))
compress = [0]
ar = sorted(list(ar))
pw = 1
while (2 ** pw < n):
pw += 1
sparse = [[float('inf') for j in range(len(values))] for i in range(pw)]
sparse[0] = values
for i in range(1, pw):
for j in range(1, n - 2 ** i + 2):
sparse[i][j] = min(sparse[i - 1][j], sparse[i - 1][j + 2 ** (i - 1)])
mn = min(values[1:])
def getmin(first, second):
if second - first + 1 >= n:
return mn
else:
second = second % n + n * (not(second % n))
first = first % n + n * (not(first % n))
if second < first:
return min(getmin(1, second), getmin(first, n))
else:
length = second - first + 1
pw = 0
while 2 ** pw < length:
pw += 1
return min(sparse[pw][first], sparse[pw][second - 2 ** pw + 1])
counting = {}
d = {}
for i in range(len(ar)):
compress.append(ar[i])
d[ar[i]] = len(compress) - 1
if i != len(ar) - 1 and ar[i + 1] - ar[i] > 1:
compress.append(ar[i] + 1)
counting[len(compress) - 1] = float('inf')
d[ar[i] + 1] = len(compress) - 1
for ind in counting:
counting[ind] = getmin(compress[ind - 1] + 1, compress[ind + 1] + 1)
def update(l, r, ind, lb, rb, value):
if updating[ind] and ind * 2 < len(tree):
if (not updating[ind * 2] or (updating[ind * 2][1] < updating[ind][1])):
tree[ind * 2] = updating[ind][0]
updating[ind * 2] = updating[ind][::]
if (not updating[ind * 2 + 1] or (updating[ind * 2 + 1][1] < updating[ind][1])):
tree[ind * 2 + 1] = updating[ind][0]
updating[ind * 2 + 1] = updating[ind][::]
updating[ind] = 0
if (l == lb and r == rb):
tree[ind] = value
if (ind * 2 < len(tree)):
tree[ind * 2], tree[ind * 2 + 1] = value, value
updating[ind * 2], updating[ind * 2 + 1] = (value, time), (value, time)
while ind != 1:
ind //= 2
tree[ind] = min(tree[ind * 2], tree[ind * 2 + 1])
else:
m = (lb + rb) // 2
if (l <= m):
update(l, min(m, r), ind * 2, lb, m, value)
if (r > m):
update(max(l, m + 1), r, ind * 2 + 1, m + 1, rb, value)
def get(l, r, ind, lb, rb):
if updating[ind] and ind * 2 < len(tree):
if (not updating[ind * 2] or (updating[ind * 2][1] < updating[ind][1])):
tree[ind * 2] = updating[ind][0]
updating[ind * 2] = updating[ind][::]
if (not updating[ind * 2 + 1] or (updating[ind * 2 + 1][1] < updating[ind][1])):
tree[ind * 2 + 1] = updating[ind][0]
updating[ind * 2 + 1] = updating[ind][::]
updating[ind] = 0
if (l == lb and r == rb):
return tree[ind]
else:
m = (lb + rb) // 2
ans = float('inf')
if (l <= m):
ans = get(l, min(m, r), ind * 2, lb, m)
if (r > m):
ans = min(ans, get(max(l, m + 1), r, ind * 2 + 1, m + 1, rb))
return ans
def getvalue(ind):
if (ind < len(compress)):
return (values[compress[ind] % n + n * (not(compress[ind] % n))])
else:
return 0
size = 1
while (size < len(ar) * 2):
size *= 2
tree = [float('inf') for i in range(2 * size)]
updating = [0 for i in range (2 * size)]
for i in range(size, 2 * size):
if i - size + 1 in counting:
tree[i] = counting[i - size + 1]
else:
tree[i] = getvalue(i - size + 1)
for i in range(size - 1, 0, -1):
tree[i] = min(tree[i * 2], tree[i * 2 + 1])
for time in range(m):
if questions[time][0] == 1:
update(d[questions[time][1]], d[questions[time][2]], 1, 1, size, questions[time][-1])
else:
stdout.write(str(get(d[questions[time][1]], d[questions[time][2]], 1, 1, size)) + '\n')
'''
10 10
4 2 3 8 1 2 1 7 5 4
10
2 63 87
2 2 48
2 5 62
2 33 85
2 30 100
2 38 94
2 7 81
2 13 16
2 26 36
2 64 96
'''
``` | instruction | 0 | 13,817 | 12 | 27,634 |
No | output | 1 | 13,817 | 12 | 27,635 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of positive integers and q queries to this array. There are two types of queries:
* 1 l r x — for each index i such that l ≤ i ≤ r set ai = x.
* 2 l r — find the minimum among such ai that l ≤ i ≤ r.
We decided that this problem is too easy. So the array a is given in a compressed form: there is an array b consisting of n elements and a number k in the input, and before all queries a is equal to the concatenation of k arrays b (so the size of a is n·k).
Input
The first line contains two integers n and k (1 ≤ n ≤ 105, 1 ≤ k ≤ 104).
The second line contains n integers — elements of the array b (1 ≤ bi ≤ 109).
The third line contains one integer q (1 ≤ q ≤ 105).
Then q lines follow, each representing a query. Each query is given either as 1 l r x — set all elements in the segment from l till r (including borders) to x (1 ≤ l ≤ r ≤ n·k, 1 ≤ x ≤ 109) or as 2 l r — find the minimum among all elements in the segment from l till r (1 ≤ l ≤ r ≤ n·k).
Output
For each query of type 2 print the answer to this query — the minimum on the corresponding segment.
Examples
Input
3 1
1 2 3
3
2 1 3
1 1 2 4
2 1 3
Output
1
3
Input
3 2
1 2 3
5
2 4 4
1 4 4 5
2 4 4
1 1 6 1
2 6 6
Output
1
5
1
Submitted Solution:
```
from sys import stdin, stdout
n, k = map(int, stdin.readline().split())
values = [0] + list(map(int, stdin.readline().split()))
m = int(stdin.readline())
questions = []
ar = set()
for i in range(m):
questions.append(tuple(map(int, stdin.readline().strip().split())))
ar.add(int(questions[-1][1]))
ar.add(int(questions[-1][2]))
compress = [0]
ar = sorted(list(ar))
pw = 1
while (2 ** pw < n):
pw += 1
sparse = [[float('inf') for j in range(len(values))] for i in range(pw)]
sparse[0] = values[1:]
for i in range(1, pw):
for j in range(n - 2 ** i + 1):
sparse[i][j] = min(sparse[i - 1][j], sparse[i - 1][j + 2 ** (i - 1)])
mn = min(values[1:])
def getmin(first, second):
if second - first + 1 >= n:
return mn
else:
second = second % n + n * (not(second % n))
first = first % n + n * (not(first % n))
second -= 1
first -= 1
if second < first:
return min(getmin(1, second + 1), getmin(first + 1, n))
else:
length = second - first + 1
pw = 0
while 2 ** pw < length:
pw += 1
return min(sparse[pw][first], sparse[pw][second - 2 ** pw + 1])
counting = {}
d = {}
for i in range(len(ar)):
compress.append(ar[i])
d[ar[i]] = len(compress) - 1
if i != len(ar) - 1 and ar[i + 1] - ar[i] > 1:
compress.append(ar[i] + 1)
counting[len(compress) - 1] = float('inf')
d[ar[i] + 1] = len(compress) - 1
for ind in counting:
counting[ind] = getmin(compress[ind - 1] + 1, compress[ind + 1] + 1)
def update(l, r, ind, lb, rb, value):
if updating[ind] and ind * 2 < len(tree):
if (not updating[ind * 2] or (updating[ind * 2][1] < updating[ind][1])):
tree[ind * 2] = updating[ind][0]
updating[ind * 2] = updating[ind][::]
if (not updating[ind * 2 + 1] or (updating[ind * 2 + 1][1] < updating[ind][1])):
tree[ind * 2 + 1] = updating[ind][0]
updating[ind * 2 + 1] = updating[ind][::]
updating[ind] = 0
if (l == lb and r == rb):
tree[ind] = value
if (ind * 2 < len(tree)):
tree[ind * 2], tree[ind * 2 + 1] = value, value
updating[ind * 2], updating[ind * 2 + 1] = (value, time), (value, time)
while ind != 1:
ind //= 2
tree[ind] = min(tree[ind * 2], tree[ind * 2 + 1])
else:
m = (lb + rb) // 2
if (l <= m):
update(l, min(m, r), ind * 2, lb, m, value)
if (r > m):
update(max(l, m + 1), r, ind * 2 + 1, m + 1, rb, value)
def get(l, r, ind, lb, rb):
if updating[ind] and ind * 2 < len(tree):
if (not updating[ind * 2] or (updating[ind * 2][1] < updating[ind][1])):
tree[ind * 2] = updating[ind][0]
updating[ind * 2] = updating[ind][::]
if (not updating[ind * 2 + 1] or (updating[ind * 2 + 1][1] < updating[ind][1])):
tree[ind * 2 + 1] = updating[ind][0]
updating[ind * 2 + 1] = updating[ind][::]
updating[ind] = 0
if (l == lb and r == rb):
return tree[ind]
else:
m = (lb + rb) // 2
ans = float('inf')
if (l <= m):
ans = get(l, min(m, r), ind * 2, lb, m)
if (r > m):
ans = min(ans, get(max(l, m + 1), r, ind * 2 + 1, m + 1, rb))
return ans
def getvalue(ind):
if (ind < len(compress)):
return (values[compress[ind] % n + n * (not(compress[ind] % n))])
else:
return 0
size = 1
while (size < len(ar) * 2):
size *= 2
tree = [float('inf') for i in range(2 * size)]
updating = [0 for i in range (2 * size)]
for i in range(size, 2 * size):
if i - size + 1 in counting:
tree[i] = counting[i - size + 1]
else:
tree[i] = getvalue(i - size + 1)
for i in range(size - 1, 0, -1):
tree[i] = min(tree[i * 2], tree[i * 2 + 1])
for time in range(m):
if questions[time][0] == 1:
update(d[questions[time][1]], d[questions[time][2]], 1, 1, size, questions[time][-1])
else:
stdout.write(str(get(d[questions[time][1]], d[questions[time][2]], 1, 1, size)) + '\n')
'''
10 10
4 2 3 8 1 2 1 7 5 4
10
2 63 87
2 2 48
2 5 62
2 33 85
2 30 100
2 38 94
2 7 81
2 13 16
2 26 36
2 64 96
'''
``` | instruction | 0 | 13,818 | 12 | 27,636 |
No | output | 1 | 13,818 | 12 | 27,637 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a consisting of positive integers and q queries to this array. There are two types of queries:
* 1 l r x — for each index i such that l ≤ i ≤ r set ai = x.
* 2 l r — find the minimum among such ai that l ≤ i ≤ r.
We decided that this problem is too easy. So the array a is given in a compressed form: there is an array b consisting of n elements and a number k in the input, and before all queries a is equal to the concatenation of k arrays b (so the size of a is n·k).
Input
The first line contains two integers n and k (1 ≤ n ≤ 105, 1 ≤ k ≤ 104).
The second line contains n integers — elements of the array b (1 ≤ bi ≤ 109).
The third line contains one integer q (1 ≤ q ≤ 105).
Then q lines follow, each representing a query. Each query is given either as 1 l r x — set all elements in the segment from l till r (including borders) to x (1 ≤ l ≤ r ≤ n·k, 1 ≤ x ≤ 109) or as 2 l r — find the minimum among all elements in the segment from l till r (1 ≤ l ≤ r ≤ n·k).
Output
For each query of type 2 print the answer to this query — the minimum on the corresponding segment.
Examples
Input
3 1
1 2 3
3
2 1 3
1 1 2 4
2 1 3
Output
1
3
Input
3 2
1 2 3
5
2 4 4
1 4 4 5
2 4 4
1 1 6 1
2 6 6
Output
1
5
1
Submitted Solution:
```
from sys import stdin, stdout
n, k = map(int, stdin.readline().split())
values = list(map(int, stdin.readline().split())) * k
m = int(stdin.readline())
n *= k
size = 1
while (size < n):
size *= 2
tree = [float('inf') for i in range(2 * size)]
updating = [0 for i in range (2 * size)]
for i in range(n):
tree[size + i] = values[i]
for i in range(size - 1, 0, -1):
tree[i] = min(tree[i * 2], tree[i * 2 + 1])
def update(l, r, ind, lb, rb, value):
if updating[ind] and ind * 2 < len(tree):
if (not updating[ind * 2] or (updating[ind * 2][1] < updating[ind][1])):
tree[ind * 2] = updating[ind][0]
updating[ind * 2] = updating[ind][::]
if (not updating[ind * 2 + 1] or (updating[ind * 2 + 1][1] < updating[ind][1])):
tree[ind * 2 + 1] = updating[ind][0]
updating[ind * 2 + 1] = updating[ind][::]
updating[ind] = 0
if (l == lb and r == rb):
tree[ind] = value
if (ind * 2 < len(tree)):
tree[ind * 2], tree[ind * 2 + 1] = value, value
updating[ind * 2], updating[ind * 2 + 1] = (value, time), (value, time)
while ind != 1:
ind //= 2
tree[ind] = min(tree[ind * 2], tree[ind * 2 + 1])
if min(tree[ind * 2], tree[ind * 2 + 1]) != value:
break
else:
m = (lb + rb) // 2
if (l <= m):
update(l, min(m, r), ind * 2, lb, m, value)
if (r > m):
update(max(l, m + 1), r, ind * 2 + 1, m + 1, rb, value)
def get(l, r, ind, lb, rb):
if updating[ind] and ind * 2 < len(tree):
if (not updating[ind * 2] or (updating[ind * 2][1] < updating[ind][1])):
tree[ind * 2] = updating[ind][0]
updating[ind * 2] = updating[ind][::]
if (not updating[ind * 2 + 1] or (updating[ind * 2 + 1][1] < updating[ind][1])):
tree[ind * 2 + 1] = updating[ind][0]
updating[ind * 2 + 1] = updating[ind][::]
updating[ind] = 0
if (l == lb and r == rb):
return tree[ind]
else:
m = (lb + rb) // 2
ans = float('inf')
if (l <= m):
ans = get(l, min(m, r), ind * 2, lb, m)
if (r > m):
ans = min(ans, get(max(l, m + 1), r, ind * 2 + 1, m + 1, rb))
return ans
for time in range(1, m + 1):
questions = tuple(map(int, stdin.readline().split()))
if questions[0] == 1:
update(questions[1], questions[2], 1, 1, size, questions[-1])
else:
stdout.write('\n' + str(get(questions[1], questions[2], 1, 1, size)))
``` | instruction | 0 | 13,819 | 12 | 27,638 |
No | output | 1 | 13,819 | 12 | 27,639 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary matrix a of size n × m. A binary matrix is a matrix where each element is either 0 or 1.
You may perform some (possibly zero) operations with this matrix. During each operation you can inverse the row of this matrix or a column of this matrix. Formally, inverting a row is changing all values in this row to the opposite (0 to 1, 1 to 0). Inverting a column is changing all values in this column to the opposite.
Your task is to sort the initial matrix by some sequence of such operations. The matrix is considered sorted if the array [a_{1, 1}, a_{1, 2}, ..., a_{1, m}, a_{2, 1}, a_{2, 2}, ..., a_{2, m}, ..., a_{n, m - 1}, a_{n, m}] is sorted in non-descending order.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 200) — the number of rows and the number of columns in the matrix.
The next n lines contain m integers each. The j-th element in the i-th line is a_{i, j} (0 ≤ a_{i, j} ≤ 1) — the element of a at position (i, j).
Output
If it is impossible to obtain a sorted matrix, print "NO" in the first line.
Otherwise print "YES" in the first line. In the second line print a string r of length n. The i-th character r_i of this string should be '1' if the i-th row of the matrix is inverted and '0' otherwise. In the third line print a string c of length m. The j-th character c_j of this string should be '1' if the j-th column of the matrix is inverted and '0' otherwise. If there are multiple answers, you can print any.
Examples
Input
2 2
1 1
0 1
Output
YES
00
10
Input
3 4
0 0 0 1
0 0 0 0
1 1 1 1
Output
YES
010
0000
Input
3 3
0 0 0
1 0 1
1 1 0
Output
NO | instruction | 0 | 14,214 | 12 | 28,428 |
Tags: brute force, constructive algorithms
Correct Solution:
```
def check(a):
n = len(a)
m = len(a[0])
if a[0][-1] == 1:
flag = True
else:
flag = False
ones = [1] * m
zeros = [0] * m
r = [0] * n
c = [0] * m
for i in range(1, n):
if flag:
if a[i] == ones:
continue
elif a[i] == zeros:
r[i] ^= 1
else:
return None, None
elif a[i] == ones:
r[i] ^= 1
elif a[i] == zeros:
continue
elif a[i] == sorted(a[i]):
flag = True
elif a[i] == sorted(a[i], reverse=True):
flag = True
r[i] ^= 1
else:
return None, None
return r, c
def combine(a, b):
return list(map(lambda x: x[0] ^ x[1], zip(a, b)))
def solve():
n, m = map(int, input().split())
a = [[0] * m for _ in range(n)]
for i in range(n):
a[i] = list(map(int, input().split()))
for t in range(2):
for r in range(m):
acur = [[a[i][j] for j in range(m)] for i in range(n)]
c1 = [0] * m
for i in range(m):
acur[0][i] ^= t
if acur[0][i] == 1 and i <= r:
c1[i] ^= 1
for j in range(n):
acur[j][i] ^= 1
elif acur[0][i] == 0 and i > r:
c1[i] ^= 1
for j in range(n):
acur[j][i] ^= 1
r, c = check(acur)
if r:
print("YES")
r[0] ^= t
print(*r, sep='')
print(*combine(c, c1), sep='')
return
print("NO")
for _ in range(1):
solve()
``` | output | 1 | 14,214 | 12 | 28,429 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary matrix a of size n × m. A binary matrix is a matrix where each element is either 0 or 1.
You may perform some (possibly zero) operations with this matrix. During each operation you can inverse the row of this matrix or a column of this matrix. Formally, inverting a row is changing all values in this row to the opposite (0 to 1, 1 to 0). Inverting a column is changing all values in this column to the opposite.
Your task is to sort the initial matrix by some sequence of such operations. The matrix is considered sorted if the array [a_{1, 1}, a_{1, 2}, ..., a_{1, m}, a_{2, 1}, a_{2, 2}, ..., a_{2, m}, ..., a_{n, m - 1}, a_{n, m}] is sorted in non-descending order.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 200) — the number of rows and the number of columns in the matrix.
The next n lines contain m integers each. The j-th element in the i-th line is a_{i, j} (0 ≤ a_{i, j} ≤ 1) — the element of a at position (i, j).
Output
If it is impossible to obtain a sorted matrix, print "NO" in the first line.
Otherwise print "YES" in the first line. In the second line print a string r of length n. The i-th character r_i of this string should be '1' if the i-th row of the matrix is inverted and '0' otherwise. In the third line print a string c of length m. The j-th character c_j of this string should be '1' if the j-th column of the matrix is inverted and '0' otherwise. If there are multiple answers, you can print any.
Examples
Input
2 2
1 1
0 1
Output
YES
00
10
Input
3 4
0 0 0 1
0 0 0 0
1 1 1 1
Output
YES
010
0000
Input
3 3
0 0 0
1 0 1
1 1 0
Output
NO | instruction | 0 | 14,215 | 12 | 28,430 |
Tags: brute force, constructive algorithms
Correct Solution:
```
def inverse_row(row):
inv_row[row]= not inv_row[row]
for i in range(m):
a[row][i]=not a[row][i]
def inverse_col(col):
inv_col[col]= not inv_col[col]
for i in range(n):
a[i][col]=not a[i][col]
def check_row(row):
if a[row][0]<a[row-1][m-1]:
return False
for i in range(1,m):
if a[row][i]<a[row][i-1]:
return False
return True
def check_all():
for i in range(1,n):
if a[i][0]:
inverse_row(i)
if check_row(i):
continue
inverse_row(i)
if check_row(i):
continue
return False
return True
def print_result():
print("YES")
for i in inv_row:
print(int(i),end="")
print("")
for i in inv_col:
print(int(i),end="")
print("")
n,m = [int(i) for i in input().split(" ")]
a=[]
inv_row=[False]*n
inv_col=[False]*m
had_result=False
for i in range(n):
a.append([bool(int(i)) for i in input().split(" ")])
for i in range(m):
if a[0][i]:
inverse_col(i)
if check_all():
print_result()
had_result=True
if not had_result:
for i in range(m-1,-1,-1):
inverse_col(i)
if check_all():
print_result()
had_result=True
break
if not had_result:
print("NO")
``` | output | 1 | 14,215 | 12 | 28,431 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary matrix a of size n × m. A binary matrix is a matrix where each element is either 0 or 1.
You may perform some (possibly zero) operations with this matrix. During each operation you can inverse the row of this matrix or a column of this matrix. Formally, inverting a row is changing all values in this row to the opposite (0 to 1, 1 to 0). Inverting a column is changing all values in this column to the opposite.
Your task is to sort the initial matrix by some sequence of such operations. The matrix is considered sorted if the array [a_{1, 1}, a_{1, 2}, ..., a_{1, m}, a_{2, 1}, a_{2, 2}, ..., a_{2, m}, ..., a_{n, m - 1}, a_{n, m}] is sorted in non-descending order.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 200) — the number of rows and the number of columns in the matrix.
The next n lines contain m integers each. The j-th element in the i-th line is a_{i, j} (0 ≤ a_{i, j} ≤ 1) — the element of a at position (i, j).
Output
If it is impossible to obtain a sorted matrix, print "NO" in the first line.
Otherwise print "YES" in the first line. In the second line print a string r of length n. The i-th character r_i of this string should be '1' if the i-th row of the matrix is inverted and '0' otherwise. In the third line print a string c of length m. The j-th character c_j of this string should be '1' if the j-th column of the matrix is inverted and '0' otherwise. If there are multiple answers, you can print any.
Examples
Input
2 2
1 1
0 1
Output
YES
00
10
Input
3 4
0 0 0 1
0 0 0 0
1 1 1 1
Output
YES
010
0000
Input
3 3
0 0 0
1 0 1
1 1 0
Output
NO | instruction | 0 | 14,216 | 12 | 28,432 |
Tags: brute force, constructive algorithms
Correct Solution:
```
import sys
input = sys.stdin.readline
n,m=map(int,input().split())
A=[list(map(int,input().split())) for i in range(n)]
for i in range(m):
#一行目をi-1まで0にする
ANSR=[0]*n
ANSC=[0]*m
for j in range(i):
if A[0][j]==1:
ANSC[j]=1
for j in range(i,m):
if A[0][j]==0:
ANSC[j]=1
for r in range(1,n):
B=set()
for c in range(m):
if ANSC[c]==0:
B.add(A[r][c])
else:
B.add(1-A[r][c])
if len(B)>=2:
break
if max(B)==0:
ANSR[r]=1
else:
print("YES")
print("".join(map(str,ANSR)))
print("".join(map(str,ANSC)))
sys.exit()
ANSR=[0]*n
ANSC=[0]*m
for j in range(m):
if A[0][j]==1:
ANSC[j]=1
flag=0
for r in range(1,n):
if flag==0:
B=[]
for c in range(m):
if ANSC[c]==0:
B.append(A[r][c])
else:
B.append(1-A[r][c])
if max(B)==0:
continue
elif min(B)==1:
ANSR[r]=1
continue
else:
OI=B.index(1)
if min(B[OI:])==1:
flag=1
continue
OO=B.index(0)
if max(B[OO:])==0:
flag=1
ANSR[r]=1
continue
else:
print("NO")
sys.exit()
else:
B=set()
for c in range(m):
if ANSC[c]==0:
B.add(A[r][c])
else:
B.add(1-A[r][c])
if len(B)>=2:
break
if max(B)==0:
ANSR[r]=1
else:
print("YES")
print("".join(map(str,ANSR)))
print("".join(map(str,ANSC)))
sys.exit()
print("NO")
``` | output | 1 | 14,216 | 12 | 28,433 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a binary matrix a of size n × m. A binary matrix is a matrix where each element is either 0 or 1.
You may perform some (possibly zero) operations with this matrix. During each operation you can inverse the row of this matrix or a column of this matrix. Formally, inverting a row is changing all values in this row to the opposite (0 to 1, 1 to 0). Inverting a column is changing all values in this column to the opposite.
Your task is to sort the initial matrix by some sequence of such operations. The matrix is considered sorted if the array [a_{1, 1}, a_{1, 2}, ..., a_{1, m}, a_{2, 1}, a_{2, 2}, ..., a_{2, m}, ..., a_{n, m - 1}, a_{n, m}] is sorted in non-descending order.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 200) — the number of rows and the number of columns in the matrix.
The next n lines contain m integers each. The j-th element in the i-th line is a_{i, j} (0 ≤ a_{i, j} ≤ 1) — the element of a at position (i, j).
Output
If it is impossible to obtain a sorted matrix, print "NO" in the first line.
Otherwise print "YES" in the first line. In the second line print a string r of length n. The i-th character r_i of this string should be '1' if the i-th row of the matrix is inverted and '0' otherwise. In the third line print a string c of length m. The j-th character c_j of this string should be '1' if the j-th column of the matrix is inverted and '0' otherwise. If there are multiple answers, you can print any.
Examples
Input
2 2
1 1
0 1
Output
YES
00
10
Input
3 4
0 0 0 1
0 0 0 0
1 1 1 1
Output
YES
010
0000
Input
3 3
0 0 0
1 0 1
1 1 0
Output
NO | instruction | 0 | 14,217 | 12 | 28,434 |
Tags: brute force, constructive algorithms
Correct Solution:
```
import io
import os
from collections import defaultdict
from sys import stdin, stdout
#input = stdin.readline
def main():
n, m = map(int, input().split())
g = [[] for _ in range(n)]
for r in range(n):
g[r] = list(map(int, input().split()))
cols = [0 for _ in range(m)]
rows = [0 for _ in range(n)]
def prefZeros(vec):
f = False
for val in vec:
if val == 1:
if not f:
f = True
else:
if f:
return False
return True
def prefOnes(vec):
f = False
for val in vec:
if val == 0:
if not f:
f = True
else:
if f:
return False
return True
# 1. first row all zeros
def case1():
for i in range(m):
cols[i] = 0
for i in range(n):
rows[i] = 0
for i in range(m):
if g[0][i] == 1:
cols[i] = 1
# test rows
flip = False
for r in range(1, n):
row = [g[r][c] ^ cols[c] for c in range(m)]
s = sum(row)
is_pref_zeros = prefZeros(row)
is_pref_ones = prefOnes(row)
if s == 0:
if flip:
rows[r] = 1
elif s == m:
if not flip:
rows[r] = 1
elif is_pref_zeros:
if not flip:
flip = True
else:
rows[r] = 1
elif is_pref_ones:
rows[r] = 1
if not flip:
flip = True
else:
return False
else:
return False
return True
# 2. last row all ones
def case2():
for i in range(m):
cols[i] = 0
for i in range(n):
rows[i] = 0
for i in range(m):
if g[n-1][i] == 0:
cols[i] = 1
# test rows
flip = False
for r in range(n-1):
row = [g[r][c] ^ cols[c] for c in range(m)]
s = sum(row)
is_pref_zeros = prefZeros(row)
is_pref_ones = prefOnes(row)
if s == 0:
if flip:
rows[r] = 1
elif s == m:
if not flip:
rows[r] = 1
elif is_pref_zeros:
if not flip:
flip = True
else:
rows[r] = 1
elif is_pref_ones:
rows[r] = 1
if not flip:
flip = True
else:
return False
else:
return False
return True
if case1() or case2():
print('YES')
print(''.join(str(r) for r in rows))
print(''.join(str(c) for c in cols))
else:
print('NO')
if __name__ == '__main__':
main()
``` | output | 1 | 14,217 | 12 | 28,435 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.